// Auto-generated source file
#include <cstring>
#include <dlfcn.h>
#include <mutex>

#include <polyhook2/MemProtector.hpp>

#include <koalabox/lib.hpp>
#include <koalabox/logger.hpp>
#include <koalabox/util.hpp>

#include "proxy_exports.hpp"

#define EXPORT extern "C" __attribute__((visibility("default"))) __attribute__((naked))

EXPORT void CAddAppDependencyResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CAddAppDependencyResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CAddUGCDependencyResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CAddUGCDependencyResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CAssociateWithClanResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CAssociateWithClanResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CChangeNumOpenSlotsCallback_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CChangeNumOpenSlotsCallback_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CCheckFileSignature_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CCheckFileSignature_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CClanOfficerListResponse_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CClanOfficerListResponse_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CComputeNewPlayerCompatibilityResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CComputeNewPlayerCompatibilityResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CCreateBeaconCallback_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CCreateBeaconCallback_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CCreateItemResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CCreateItemResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CDeleteItemResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CDeleteItemResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CDurationControl_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CDurationControl_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CEncryptedAppTicketResponse_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CEncryptedAppTicketResponse_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFileDetailsResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFileDetailsResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFriendsEnumerateFollowingList_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFriendsEnumerateFollowingList_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFriendsGetFollowerCount_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFriendsGetFollowerCount_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFriendsIsFollowing_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CFriendsIsFollowing_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGSReputation_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGSReputation_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGSStatsReceived_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGSStatsReceived_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGSStatsStored_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGSStatsStored_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGetAppDependenciesResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGetAppDependenciesResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGetOPFSettingsResult_t_RemoveCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGetOPFSettingsResult_t_SetCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGetUserItemVoteResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGetUserItemVoteResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGlobalAchievementPercentagesReady_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGlobalAchievementPercentagesReady_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGlobalStatsReceived_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CGlobalStatsReceived_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CHTML_BrowserReady_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CHTML_BrowserReady_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CJoinClanChatRoomCompletionResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CJoinClanChatRoomCompletionResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CJoinPartyCallback_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CJoinPartyCallback_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardFindResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardFindResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardScoreUploaded_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardScoreUploaded_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardScoresDownloaded_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardScoresDownloaded_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardUGCSet_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLeaderboardUGCSet_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLobbyCreated_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLobbyCreated_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLobbyEnter_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLobbyEnter_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLobbyMatchList_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CLobbyMatchList_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CMarketEligibilityResponse_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CMarketEligibilityResponse_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CNumberOfCurrentPlayers_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CNumberOfCurrentPlayers_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CPublisherOwnedAppDataReady_t_RemoveCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CPublisherOwnedAppDataReady_t_SetCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageDeletePublishedFileResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageDeletePublishedFileResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageDownloadUGCResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageDownloadUGCResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumerateUserPublishedFilesResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumerateUserPublishedFilesResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumerateUserSubscribedFilesResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumerateUserSubscribedFilesResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumerateWorkshopFilesResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageEnumerateWorkshopFilesResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageFileReadAsyncComplete_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageFileReadAsyncComplete_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageFileShareResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageFileShareResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageFileWriteAsyncComplete_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageFileWriteAsyncComplete_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageGetPublishedFileDetailsResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageGetPublishedFileDetailsResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageGetPublishedItemVoteDetailsResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageGetPublishedItemVoteDetailsResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStoragePublishFileProgress_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStoragePublishFileProgress_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageSetUserPublishedFileActionResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageSetUserPublishedFileActionResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageSubscribePublishedFileResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageSubscribePublishedFileResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageUnsubscribePublishedFileResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageUnsubscribePublishedFileResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageUpdatePublishedFileResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageUpdatePublishedFileResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageUpdateUserPublishedItemVoteResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoteStorageUpdateUserPublishedItemVoteResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoveAppDependencyResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoveAppDependencyResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoveUGCDependencyResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CRemoveUGCDependencyResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSetPersonaNameResponse_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSetPersonaNameResponse_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSetUserItemVoteResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSetUserItemVoteResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CStartPlaytimeTrackingResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CStartPlaytimeTrackingResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamInventoryEligiblePromoItemDefIDs_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamInventoryEligiblePromoItemDefIDs_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamInventoryRequestPricesResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamInventoryRequestPricesResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamInventoryStartPurchaseResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamInventoryStartPurchaseResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamUGCQueryCompleted_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSteamUGCQueryCompleted_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CStopPlaytimeTrackingResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CStopPlaytimeTrackingResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CStoreAuthURLResponse_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CStoreAuthURLResponse_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSubmitItemUpdateResult_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CSubmitItemUpdateResult_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CUserFavoriteItemsListChanged_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CUserFavoriteItemsListChanged_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CUserStatsReceived_t_RemoveCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CUserStatsReceived_t_RemoveCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CUserStatsReceived_t_SetCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void CUserStatsReceived_t_SetCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void GetHSteamPipe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void GetHSteamUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamApps_BIsCybercafe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamApps_BIsLowViolence() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamApps_BIsSubscribed() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamApps_BIsSubscribedApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamApps_GetAvailableGameLanguages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamApps_GetCurrentGameLanguage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamClient_SetLocalIPBinding() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_BLoggedOn() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_BSecure() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_BUpdateUserData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_CreateUnauthenticatedUserConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_GetSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_SendUserConnectAndAuthenticate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_SendUserDisconnect() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_SetGameType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_SetServerType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_UpdateSpectatorPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamGameServer_UpdateStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_AddMasterServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_ClearAllKeyValues() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_ForceHeartbeat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_GetMasterServerAddress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_GetNextOutgoingPacket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_GetNumMasterServers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_HandleIncomingPacket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_NotifyShutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_RemoveMasterServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_SetActive() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_SetBasicServerData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_SetHeartbeatInterval() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_SetKeyValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamMasterServerUpdater_WasRestartRequested() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamUser_BLoggedOn() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamUser_InitiateGameConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamUser_TerminateGameConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void ISteamUtils_GetAppID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_GetHSteamPipe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_GetHSteamUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_GetSteamInstallPath() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamAppList_GetAppBuildId() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamAppList_GetAppInstallDir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamAppList_GetAppName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamAppList_GetInstalledApps() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamAppList_GetNumInstalledApps() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BGetDLCDataByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsAppInstalled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsCybercafe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsDlcInstalled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsLowViolence() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsSubscribed() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsSubscribedApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsTimedTrial() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_BIsVACBanned() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetAppBuildId() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetAppInstallDir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetAppOwner() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetAvailableGameLanguages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetBetaInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetCurrentBetaName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetCurrentGameLanguage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetDLCCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetDlcDownloadProgress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetFileDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetInstalledDepots() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetLaunchCommandLine() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetLaunchQueryParam() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetNumBetas() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_GetPublisherOwnedAppData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_InstallDLC() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_MarkContentCorrupt() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_RequestPublisherOwnedAppData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_SetActiveBeta() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_SetDlcContext() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamApps_UninstallDLC() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_BReleaseSteamPipe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_BShutdownIfAllPipesClosed() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_ConnectToGlobalUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_CreateLocalUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_CreateSteamPipe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetIPCCallCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamAppList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamApps() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamController() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamFriends() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamGameSearch() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamGameServerStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamGenericInterface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamHTMLSurface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamHTTP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamInventory() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamMatchmaking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamMatchmakingServers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamMusic() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamMusicRemote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamNetworking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamParentalSettings() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamParties() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamRemotePlay() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamRemoteStorage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamScreenshots() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamUGC() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamUnifiedMessages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamUserStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamUtils() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_GetISteamVideo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_ReleaseUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_Remove_SteamAPI_CPostAPIResultInProcess() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_RunFrame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_SetLocalIPBinding() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_SetWarningMessageHook() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_Set_SteamAPI_CCheckCallbackRegisteredInProcess() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamClient_Set_SteamAPI_CPostAPIResultInProcess() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_ActivateActionSet() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_ActivateActionSetLayer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_DeactivateActionSetLayer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_DeactivateAllActionSetLayers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetActionOriginFromXboxOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetActionSetHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetActiveActionSetLayers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetAnalogActionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetAnalogActionHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetAnalogActionOrigins() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetConnectedControllers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetControllerBindingRevision() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetControllerForGamepadIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetControllerState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetCurrentActionSet() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetDigitalActionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetDigitalActionHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetDigitalActionOrigins() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetGamepadIndexForController() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetGlyphForActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetGlyphForXboxOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetInputTypeForHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetMotionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetStringForActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_GetStringForXboxOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_RunFrame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_SetLEDColor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_SetOverrideMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_ShowAnalogActionOrigins() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_ShowBindingPanel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_ShowDigitalActionOrigins() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_StopAnalogActionMomentum() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_TranslateActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_TriggerHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_TriggerRepeatedHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamController_TriggerVibration() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlay() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlayToStore() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlayToUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_BHasEquippedProfileItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ClearRichPresence() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_CloseClanChatWindowInSteam() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_DownloadClanActivityCounts() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_EnumerateFollowingList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetChatMemberByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanActivityCounts() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanChatMemberCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanChatMessage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanOfficerByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanOfficerCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanOwner() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetClanTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetCoplayFriend() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetCoplayFriendCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFollowerCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendCoplayGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendCoplayTime() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendCountFromSource() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendFromSourceByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendGamePlayed() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendMessage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendPersonaName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendPersonaNameHistory() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendPersonaState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendRelationship() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendRichPresence() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendSteamLevel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendsGroupCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendsGroupMembersCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendsGroupMembersList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetFriendsGroupName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetLargeFriendAvatar() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetMediumFriendAvatar() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetPersonaName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetPersonaState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetPlayerNickname() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetProfileItemPropertyString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetProfileItemPropertyUint() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetSmallFriendAvatar() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_GetUserRestrictions() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_HasFriend() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_InviteUserToGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_IsClanChatAdmin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_IsClanOfficialGameGroup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_IsClanPublic() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_IsFollowing() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_IsUserInSource() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_JoinClanChatRoom() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_LeaveClanChatRoom() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_OpenClanChatWindowInSteam() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_ReplyToFriendMessage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_RequestClanOfficerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_RequestEquippedProfileItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_RequestFriendRichPresence() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_RequestUserInformation() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_SendClanChatMessage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_SetInGameVoiceSpeaking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_SetListenForFriendsMessages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_SetPersonaName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_SetPlayedWith() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamFriends_SetRichPresence() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_AcceptGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_AddGameSearchParams() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_DeclineGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_EndGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_EndGameSearch() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_HostConfirmGameStart() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_RequestPlayersForGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_RetrieveConnectionDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_SearchForGameSolo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_SearchForGameWithLobby() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_SetConnectionDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_SetGameHostParams() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameSearch_SubmitPlayerResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_ClearUserAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_GetUserAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_GetUserStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_GetUserStat0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_GetUserStatFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_GetUserStatInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_RequestUserStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_SetUserAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_SetUserStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_SetUserStat0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_SetUserStatFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_SetUserStatInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_StoreUserStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_AssociateWithClan() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_BLoggedOn() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_BSecure() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_BUpdateUserData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_BeginAuthSession() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_CancelAuthTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_ClearAllKeyValues() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_EnableHeartbeats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_EndAuthSession() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_ForceHeartbeat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_GetAuthSessionTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_GetGameplayStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_GetNextOutgoingPacket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_GetPublicIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_GetServerReputation() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_GetSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_HandleIncomingPacket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_InitGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_LogOff() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_LogOn() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_LogOnAnonymous() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_RequestUserGroupStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate_DEPRECATED() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SendUserDisconnect() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetAdvertiseServerActive() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetBotPlayerCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetDedicatedServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetGameData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetGameDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetGameTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetHeartbeatInterval() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetKeyValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetMapName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetMaxPlayerCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetModDir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetPasswordProtected() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetProduct() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetRegion() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetServerName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetSpectatorPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_SetSpectatorServerName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_UserHasLicenseForApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamGameServer_WasRestartRequested() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_AddHeader() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_AllowStartRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_CopyToClipboard() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_CreateBrowser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_DestructISteamHTMLSurface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_ExecuteJavascript() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_Find() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_GetLinkAtPosition() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_GoBack() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_GoForward() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_JSDialogResponse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_KeyChar() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_KeyDown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_KeyUp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_LoadURL() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_MouseDoubleClick() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_MouseDown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_MouseMove() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_MouseUp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_MouseWheel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_OpenDeveloperTools() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_PasteFromClipboard() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_Reload() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_RemoveBrowser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetBackgroundMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetCookie() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetHorizontalScroll() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetKeyFocus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetPageScaleFactor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_SetVerticalScroll() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_StopFind() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_StopLoad() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTMLSurface_ViewSource() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_CreateCookieContainer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_CreateHTTPRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_DeferHTTPRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPResponseBodyData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPResponseBodySize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_PrioritizeHTTPRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_ReleaseCookieContainer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_ReleaseHTTPRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SendHTTPRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetCookie() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestContextValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_ActivateActionSet() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_ActivateActionSetLayer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_BNewDataAvailable() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_BWaitForData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_DeactivateActionSetLayer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_DeactivateAllActionSetLayers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_EnableActionEventCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_EnableDeviceCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetActionSetHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetActiveActionSetLayers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetAnalogActionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetAnalogActionHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetAnalogActionOrigins() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetConnectedControllers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetControllerForGamepadIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetCurrentActionSet() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetDeviceBindingRevision() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetDigitalActionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetDigitalActionHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetDigitalActionOrigins() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetGamepadIndexForController() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetGlyphForActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetGlyphForActionOrigin_Legacy() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetGlyphForXboxOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetGlyphPNGForActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetGlyphSVGForActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetInputTypeForHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetMotionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetRemotePlaySessionID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetSessionInputConfigurationSettings() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetStringForActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetStringForAnalogActionName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetStringForDigitalActionName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_GetStringForXboxOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_Legacy_TriggerHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_Legacy_TriggerRepeatedHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_RunFrame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_SetDualSenseTriggerEffect() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_SetInputActionManifestFilePath() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_SetLEDColor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_ShowBindingPanel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_StopAnalogActionMomentum() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_TranslateActionOrigin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_TriggerHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_TriggerRepeatedHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_TriggerSimpleHapticEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_TriggerVibration() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInput_TriggerVibrationExtended() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_AddPromoItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_AddPromoItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_CheckResultSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_ConsumeItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_DeserializeResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_DestroyResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_ExchangeItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GenerateItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetAllItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetItemDefinitionIDs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetItemDefinitionProperty() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetItemPrice() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetItemsByID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetItemsWithPrices() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetNumItemsWithPrices() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetResultItemProperty() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetResultItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetResultStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GetResultTimestamp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_GrantPromoItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_InspectItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_LoadItemDefinitions() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_RemoveProperty() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_RequestPrices() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SendItemDropHeartbeat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SerializeResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetProperty() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetProperty0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetProperty1() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetProperty2() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetPropertyBool() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetPropertyFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetPropertyInt64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SetPropertyString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_StartPurchase() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_StartUpdateProperties() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_SubmitUpdateProperties() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_TradeItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_TransferItemQuantity() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamInventory_TriggerItemDrop() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingPingResponse_ServerResponded() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_CancelQuery() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_CancelServerQuery() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_GetServerCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_GetServerDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_IsRefreshing() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_PingServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_PlayerDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RefreshQuery() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RefreshServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_ReleaseRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RequestInternetServerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RequestLANServerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmakingServers_ServerRules() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddFavoriteGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_CreateLobby() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_DeleteLobbyData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetFavoriteGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetFavoriteGameCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyChatEntry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyDataCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyMemberData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetLobbyOwner() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_GetNumLobbyMembers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_InviteUserToLobby() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_JoinLobby() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_LeaveLobby() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_RemoveFavoriteGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_RequestLobbyData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_RequestLobbyList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SendLobbyChatMsg() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLinkedLobby() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyJoinable() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyMemberData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyOwner() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMatchmaking_SetLobbyType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_BActivationSuccess() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_CurrentEntryDidChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_CurrentEntryWillChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_EnableLooped() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_EnablePlayNext() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_EnablePlayPrevious() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_EnablePlaylists() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_EnableQueue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_EnableShuffled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_PlaylistDidChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_PlaylistWillChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_QueueDidChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_QueueWillChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_ResetPlaylistEntries() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_ResetQueueEntries() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_SetDisplayName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_SetPlaylistEntry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_SetQueueEntry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdateLooped() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdateShuffled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusicRemote_UpdateVolume() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_BIsEnabled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_BIsPlaying() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_GetPlaybackStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_GetVolume() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_Pause() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_Play() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_PlayNext() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_PlayPrevious() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamMusic_SetVolume() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingConnectionCustomSignaling_Release() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingConnectionCustomSignaling_SendSignal() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingCustomSignalingRecvContext_OnConnectRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingMessages_SendMessageToUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_AcceptConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CloseConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CloseListenSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ConnectP2P() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreatePollGroup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_CreateSocketPair() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_DestroyPollGroup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetCertificateRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetConnectionInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetConnectionName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetConnectionUserData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetIdentity() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_InitAuthentication() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_ResetIdentity() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_RunCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_SendMessageToConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_SendMessages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_SetCertificate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_SetConnectionName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingSockets_SetConnectionUserData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_AllocateMessage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetConfigValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetPOPCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetPOPList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_IsFakeIPv4() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_ParsePingLocationString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetConfigValue() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValuePtr() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_AllowP2PPacketRelay() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_CloseP2PChannelWithUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_CloseP2PSessionWithUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_CreateConnectionSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_CreateListenSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_CreateP2PConnectionSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_DestroyListenSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_DestroySocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_GetListenSocketInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_GetMaxPacketSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_GetP2PSessionState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_GetSocketConnectionType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_GetSocketInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_IsDataAvailable() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_IsDataAvailableOnSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_IsP2PPacketAvailable() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_ReadP2PPacket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_RetrieveData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_RetrieveDataFromSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_SendDataOnSocket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamNetworking_SendP2PPacket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParentalSettings_BIsAppBlocked() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParentalSettings_BIsAppInBlockList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParentalSettings_BIsFeatureBlocked() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParentalSettings_BIsParentalLockLocked() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_CancelReservation() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_ChangeNumOpenSlots() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_CreateBeacon() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_DestroyBeacon() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_GetAvailableBeaconLocations() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_GetBeaconByIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_GetBeaconDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_GetBeaconLocationData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_GetNumActiveBeacons() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_GetNumAvailableBeaconLocations() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_JoinParty() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamParties_OnReservationCompleted() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_BGetSessionClientResolution() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_CreateMouseCursor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_GetInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_GetSessionClientName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_GetSessionCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_GetSessionID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_GetSessionSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_SetMouseCursor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_SetMousePosition() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_SetMouseVisibility() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_CommitPublishedFileUpdate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_CreatePublishedFileUpdateRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_DeletePublishedFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_EndFileWriteBatch() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_EnumeratePublishedFilesByUserAction() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_EnumeratePublishedWorkshopFiles() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_EnumerateUserPublishedFiles() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_EnumerateUserSharedWorkshopFiles() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_EnumerateUserSubscribedFiles() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileDelete() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileExists() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileForget() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FilePersisted() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileRead() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileReadAsync() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileShare() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileWrite() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileWriteAsync() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileWriteStreamClose() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetCachedUGCCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetFileCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetFileNameAndSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetFileSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetFileTimestamp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetLocalFileChange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetLocalFileChangeCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetPublishedFileDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetPublishedItemVoteDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetQuota() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetSyncPlatforms() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetUGCDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_GetUserPublishedItemVoteDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_PublishVideo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_PublishWorkshopFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_SetSyncPlatforms() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_SetUserPublishedFileAction() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_SubscribePublishedFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UGCDownload() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UGCRead() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UnsubscribePublishedFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFileDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFileFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFilePreviewFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTitle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdatePublishedFileVisibility() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamRemoteStorage_UpdateUserPublishedItemVote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_AddScreenshotToLibrary() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_HookScreenshots() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_IsScreenshotsHooked() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_SetLocation() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_TagPublishedFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_TagUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_TriggerScreenshot() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamScreenshots_WriteScreenshot() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_AddBroadcastGameData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_AddRegion() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_AddTimelineMarker() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_IsBroadcasting() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_RemoveBroadcastGameData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_RemoveRegion() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTV_RemoveTimelineMarker() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_AddGamePhaseTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_AddRangeTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_AddTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_ClearTimelineStateDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_ClearTimelineTooltip() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_DoesEventRecordingExist() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_EndGamePhase() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_EndRangeTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_OpenOverlayToGamePhase() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_RemoveTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_SetGamePhaseAttribute() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_SetGamePhaseID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_SetTimelineGameMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_SetTimelineStateDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_SetTimelineTooltip() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_StartGamePhase() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_StartRangeTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddAppDependency() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddContentDescriptor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddDependency() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddExcludedTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddItemKeyValueTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddItemPreviewFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddItemPreviewVideo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddItemToFavorites() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddRequiredKeyValueTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddRequiredTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_AddRequiredTagGroup() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_BInitWorkshopForGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateQueryAllUGCRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateQueryAllUGCRequest0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_CreateQueryUserUGCRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_DeleteItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_DownloadItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetAppDependencies() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetItemDownloadInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetItemInstallInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetItemState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetItemUpdateProgress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetNumSubscribedItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetNumSupportedGameVersions() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCChildren() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCMetadata() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCNumTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCPreviewURL() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCStatistic() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetSubscribedItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetSupportedGameVersionData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetUserItemVote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_GetWorkshopEULAStatus() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_ReleaseQueryUGCRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveAppDependency() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveContentDescriptor() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveDependency() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveItemFromFavorites() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveItemKeyValueTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RemoveItemPreview() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_RequestUGCDetails() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SendQueryUGCRequest() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetAdminQuery() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetAllowCachedResponse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetAllowLegacyUpload() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetCloudFileNameFilter() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemContent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemMetadata() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemPreview() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemTitle() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemUpdateLanguage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemVisibility() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetItemsDisabledLocally() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetLanguage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetMatchAnyTag() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetRankedByTrendDays() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetRequiredGameVersions() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnAdditionalPreviews() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnChildren() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnKeyValueTags() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnLongDescription() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnMetadata() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnOnlyIDs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnPlaytimeStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetReturnTotalOnly() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetSearchText() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetTimeCreatedDateRange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetTimeUpdatedDateRange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SetUserItemVote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_ShowWorkshopEULA() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_StartItemUpdate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_StartPlaytimeTracking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_StopPlaytimeTracking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SubmitItemUpdate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SubscribeItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_SuspendDownloads() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_UnsubscribeItem() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_UpdateItemPreviewFile() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUGC_UpdateItemPreviewVideo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUnifiedMessages_GetMethodResponseData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUnifiedMessages_GetMethodResponseInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUnifiedMessages_ReleaseMethod() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUnifiedMessages_SendMethod() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUnifiedMessages_SendNotification() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_AttachLeaderboardUGC() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_ClearAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_DownloadLeaderboardEntries() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_FindLeaderboard() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_FindOrCreateLeaderboard() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementAchievedPercent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementIcon() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStat0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStatDouble() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStatHistory() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStatHistory0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetGlobalStatInt64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetLeaderboardDisplayType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetLeaderboardEntryCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetLeaderboardName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetLeaderboardSortMethod() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetNumAchievements() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetStat0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetStatFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetStatInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetUserAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetUserStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetUserStat0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetUserStatFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_GetUserStatInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_IndicateAchievementProgress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_RequestCurrentStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_RequestGlobalStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_RequestUserStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_ResetAllStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_SetAchievement() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_SetStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_SetStat0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_SetStatFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_SetStatInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_StoreStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_UpdateAvgRateStat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUserStats_UploadLeaderboardScore() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_AdvertiseGame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BIsBehindNAT() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BIsPhoneIdentifying() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BIsPhoneRequiringVerification() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BIsPhoneVerified() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BIsTwoFactorEnabled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BLoggedOn() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BSetDurationControlOnlineState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_BeginAuthSession() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_CancelAuthTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_DecompressVoice() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_EndAuthSession() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetAuthSessionTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetAuthTicketForWebApi() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetAvailableVoice() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetDurationControl() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetEncryptedAppTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetGameBadgeLevel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetHSteamUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetMarketEligibility() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetPlayerSteamLevel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetUserDataFolder() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetVoice() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_GetVoiceOptimalSampleRate() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_InitiateGameConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_InitiateGameConnection_DEPRECATED() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_RequestEncryptedAppTicket() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_RequestStoreAuthURL() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_StartVoiceRecording() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_StopVoiceRecording() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_TerminateGameConnection() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_TerminateGameConnection_DEPRECATED() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_TrackAppUsageEvent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUser_UserHasLicenseForApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_BOverlayNeedsPresent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_CheckFileSignature() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_DismissGamepadTextInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_FilterText() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetAPICallFailureReason() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetAPICallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetAppID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetCSERIPPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetConnectedUniverse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetCurrentBatteryPower() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetEnteredGamepadTextInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetEnteredGamepadTextLength() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetIPCCallCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetIPCountry() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetIPv6ConnectivityState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetImageRGBA() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetImageSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetSecondsSinceAppActive() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetSecondsSinceComputerActive() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetServerRealTime() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_GetSteamUILanguage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_InitFilterText() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsAPICallCompleted() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsOverlayEnabled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsSteamChinaLauncher() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsSteamInBigPictureMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsSteamRunningInVR() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_RunFrame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_SetGameLauncherMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_SetOverlayNotificationInset() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_SetOverlayNotificationPosition() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_SetWarningMessageHook() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_ShowGamepadTextInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_ShowModalGamepadTextInput() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamUtils_StartVRDashboard() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_AddTimelineHighlightMarker() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_AddTimelineRange() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_AddTimelineRangeEnd() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_AddTimelineRangeStart() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_AddTimelineTimestamp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_GetOPFSettings() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_GetOPFStringForApp() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_GetVideoURL() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_IsBroadcasting() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ISteamVideo_SetTimelineGameMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_InitAnonymousUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_InitFlat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_InitSafe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_IsSteamRunning() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ManualDispatch_FreeLastCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ManualDispatch_GetAPICallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ManualDispatch_GetNextCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ManualDispatch_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ManualDispatch_RunFrame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_MatchMakingKeyValuePair_t_Construct() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_RegisterCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_RegisterCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_ReleaseCurrentThreadMemory() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_RestartAppIfNecessary() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_RunCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SetBreakpadAppID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SetMiniDumpComment() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SetTryCatchCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamAppList_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamApps_v008() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamController_v007() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamController_v008() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamDatagramHostedAddress_Clear() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamDatagramHostedAddress_GetPopID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamDatagramHostedAddress_SetDevAddress() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamFriends_v017() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamFriends_v018() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameSearch_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerApps_v008() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerHTTP_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerInventory_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingMessages_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v011() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingSockets_v008() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworkingSockets_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerNetworking_v006() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerStats_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v014() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v015() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v016() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v017() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v018() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v020() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUGC_v021() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUtils_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServerUtils_v010() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServer_v013() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServer_v014() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamGameServer_v015() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamHTMLSurface_v005() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamHTTP_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamIPAddress_t_IsSet() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamInput_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamInput_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamInput_v005() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamInput_v006() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamInventory_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamMatchmakingServers_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamMatchmaking_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamMusicRemote_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamMusic_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingConfigValue_t_SetFloat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingConfigValue_t_SetInt32() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingConfigValue_t_SetInt64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingConfigValue_t_SetPtr() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingConfigValue_t_SetString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddrRender_c_str() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_Clear() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_GetFakeIPType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_GetIPv4() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_IsEqualTo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_IsFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_IsIPv4() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_IsLocalHost() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_ParseString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_SetIPv4() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_SetIPv6() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIPAddr_ToString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentityRender_c_str() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_Clear() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetFakeIPType() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetGenericBytes() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetGenericString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetIPAddr() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetIPv4() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetPSNID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetStadiaID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetSteamID64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_IsEqualTo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_IsFakeIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_IsInvalid() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_IsLocalHost() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_ParseString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetGenericBytes() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetGenericString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetIPAddr() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetIPv4Addr() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetLocalHost() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetPSNID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetStadiaID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetSteamID64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingIdentity_ToString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingMessage_t_Release() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingMessages_SteamAPI_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingMessages_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingPOPIDRender_c_str() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingSockets_SteamAPI_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingSockets_SteamAPI_v011() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingSockets_SteamAPI_v012() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingSockets_v008() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingSockets_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingUtils_SteamAPI_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingUtils_SteamAPI_v004() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworkingUtils_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamNetworking_v006() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamParentalSettings_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamParties_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamRemotePlay_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamRemotePlay_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamRemotePlay_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamRemoteStorage_v014() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamRemoteStorage_v016() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamScreenshots_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamTV_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamTimeline_v001() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamTimeline_v004() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v014() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v015() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v016() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v017() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v018() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v020() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUGC_v021() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUserStats_v011() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUserStats_v012() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUserStats_v013() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUser_v020() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUser_v021() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUser_v022() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUser_v023() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUtils_v009() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamUtils_v010() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamVideo_v002() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamVideo_v003() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamVideo_v004() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_SteamVideo_v007() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_UnregisterCallResult() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_UnregisterCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_UseBreakpadCrashHandler() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_WriteMiniDump() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_gameserveritem_t_Construct() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_gameserveritem_t_GetName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_gameserveritem_t_SetName() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_Assign() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_Construct() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_GetConnectionAddressString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_GetConnectionPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_GetIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_GetQueryAddressString() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_GetQueryPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_IsLessThan() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_SetConnectionPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_SetIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAPI_servernetadr_t_SetQueryPort() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamAppList() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamApps() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamClient() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamContentServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamContentServerUtils() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamContentServer_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamContentServer_RunCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamContentServer_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamController() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamController_GetControllerState() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamController_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamController_SetOverrideMode() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamController_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamController_TriggerHapticPulse() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamFriends() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerApps() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerHTTP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerInventory() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerNetworking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerUGC() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServerUtils() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_BSecure() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_GetHSteamPipe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_GetHSteamUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_GetIPCCallCount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_GetSteamID() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_InitSafe() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_RunCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamGameServer_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamHTMLSurface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamHTTP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_ContextInit() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_CreateInterface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_FindOrCreateGameServerInterface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_FindOrCreateUserInterface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_GameServer_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_GameServer_Init_V2() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_GlobalContextGameServerPtr() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInternal_SteamAPI_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamInventory() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamMasterServerUpdater() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamMatchmaking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamMatchmakingServers() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamMusic() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamMusicRemote() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamNetworking() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamRealPath() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamRemoteStorage() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamScreenshots() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamUGC() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamUnifiedMessages() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamUser() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamUserStats() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamUtils() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_ComputeDistortion() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetD3D9AdapterIndex() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetDisplayId() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetDriverId() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetEyeOutputViewport() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetHeadFromEyePose() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetLastTrackerFromHeadPose() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetProjectionMatrix() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetProjectionRaw() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetRecommendedRenderTargetSize() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetTrackerFromHeadPose() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetTrackerZeroPose() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetViewMatrix() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_GetWindowBounds() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_IHmd_Version() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_WillDriftInYaw() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVR_ZeroTracker() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void SteamVideo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void Steam_BGetCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void Steam_FreeLastCallback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void Steam_GetHSteamUserCurrent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void Steam_RegisterInterfaceFuncs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void Steam_RunCallbacks() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void VR_GetControlPanel() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void VR_GetGenericInterface() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void VR_GetStringForHmdError() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void VR_Init() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void VR_IsHmdPresent() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void VR_Shutdown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_Backtrace() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_DeleteException() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_FindEnclosingFunction() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_Find_FDE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_ForcedUnwind() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetCFA() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetDataRelBase() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetGR() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetLanguageSpecificData() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetRegionStart() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_GetTextRelBase() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_RaiseException() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_Resume() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_Resume_or_Rethrow() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_SetGR() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Unwind_SetIP() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv111__terminateEPFvvE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv112__unexpectedEPFvvE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv115__forced_unwindD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv115__forced_unwindD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv115__forced_unwindD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv117__class_type_infoD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv117__class_type_infoD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv117__class_type_infoD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv119__foreign_exceptionD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv119__foreign_exceptionD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv119__foreign_exceptionD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv119__terminate_handlerE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv120__si_class_type_infoD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv120__si_class_type_infoD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv120__si_class_type_infoD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv120__unexpected_handlerE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv121__vmi_class_type_infoD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv121__vmi_class_type_infoD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN10__cxxabiv121__vmi_class_type_infoD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN9__gnu_cxx20recursive_init_errorD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN9__gnu_cxx20recursive_init_errorD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN9__gnu_cxx20recursive_init_errorD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZN9__gnu_cxx27__verbose_terminate_handlerEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv117__class_type_info10__do_catchEPKSt9type_infoPPvj() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PKvRNS0_15__upcast_resultE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PPv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv117__class_type_info12__do_dyncastEiNS0_10__sub_kindEPKS0_PKvS3_S5_RNS0_16__dyncast_resultE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv117__class_type_info20__do_find_public_srcEiPKvPKS0_S2_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv120__si_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv120__si_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv120__si_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv121__vmi_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv121__vmi_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNK10__cxxabiv121__vmi_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt10bad_typeid4whatEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt13bad_exception4whatEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt8bad_cast4whatEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt9bad_alloc4whatEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt9exception4whatEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt9type_info10__do_catchEPKS_PPvj() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt9type_info11__do_upcastEPKN10__cxxabiv117__class_type_infoEPPv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt9type_info14__is_pointer_pEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNKSt9type_info15__is_function_pEv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt10bad_typeidD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt10bad_typeidD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt10bad_typeidD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt13bad_exceptionD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt13bad_exceptionD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt13bad_exceptionD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt8bad_castD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt8bad_castD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt8bad_castD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9bad_allocD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9bad_allocD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9bad_allocD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9exceptionD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9exceptionD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9exceptionD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9type_infoD0Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9type_infoD1Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZNSt9type_infoD2Ev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt10unexpectedv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt13set_terminatePFvvE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt14set_unexpectedPFvvE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt15set_new_handlerPFvvE() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt18uncaught_exceptionv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt20_Rb_tree_black_countPKSt18_Rb_tree_node_baseS1_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt20_Rb_tree_rotate_leftPSt18_Rb_tree_node_baseRS0_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt28_Rb_tree_rebalance_for_erasePSt18_Rb_tree_node_baseRS_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt7nothrow() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZSt9terminatev() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _ZdlPv() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void _Znwj() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __deregister_frame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __deregister_frame_info() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __deregister_frame_info_bases() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __dynamic_cast() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __frame_state_for() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __gcclibcxx_demangle_callback() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __gxx_personality_v0() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __new_handler() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __register_frame() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __register_frame_info() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __register_frame_info_bases() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __register_frame_info_table() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __register_frame_info_table_bases() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __register_frame_table() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap___lxstat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap___lxstat64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap___xstat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap___xstat64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_access() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_chdir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_chmod() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_chown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_dlmopen() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_dlopen() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_fopen() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_fopen64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_freopen() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_lchown() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_link() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_lstat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_lstat64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_mkdir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_mkfifo() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_mknod() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_mount() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_open() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_open64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_opendir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_rename() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_rmdir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_scandir() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_scandir64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_stat() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_stat64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_statfs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_statfs64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_statvfs() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_statvfs64() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_symlink() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_unlink() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_utime() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void __wrap_utimes() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}

EXPORT void g_pSteamClientGameServer() {
    asm volatile ("movl $0xDeadC0de, %%eax":::"eax");
    asm volatile ("jmp *%eax");
}


namespace {
    void panic_exit(){
        koalabox::util::panic("Invocation of uninitialized exported function.");
    }
}

namespace proxy_exports {
    void init(void* const self_lib_handle, void* const original_lib_handle) {
        static std::mutex section;
        const std::lock_guard lock(section);

        static bool initialized = false;
        if(initialized) {
            LOG_WARN("proxy_exports is already initialized");
            return;
        }

        LOG_INFO(
            "Initializing proxy_exports. self handle: {}, original handle: {}",
            self_lib_handle, original_lib_handle
        );

        const auto code_section = koalabox::lib::get_section_or_throw(self_lib_handle, koalabox::lib::CODE_SECTION);
        PLH::MemAccessor mem_accessor;
        PLH::MemoryProtector const protector(
            reinterpret_cast<uint64_t>(code_section.start_address),
            code_section.size,
            PLH::ProtFlag::RWX,
            mem_accessor
        );

        void* src_address = nullptr;
        void* dest_address = nullptr;

        dest_address = dlsym(self_lib_handle, "CAddAppDependencyResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CAddAppDependencyResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CAddAppDependencyResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CAddAppDependencyResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CAddAppDependencyResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CAddAppDependencyResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CAddUGCDependencyResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CAddUGCDependencyResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CAddUGCDependencyResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CAddUGCDependencyResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CAddUGCDependencyResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CAddUGCDependencyResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CAssociateWithClanResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CAssociateWithClanResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CAssociateWithClanResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CAssociateWithClanResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CAssociateWithClanResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CAssociateWithClanResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CChangeNumOpenSlotsCallback_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CChangeNumOpenSlotsCallback_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CChangeNumOpenSlotsCallback_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CChangeNumOpenSlotsCallback_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CChangeNumOpenSlotsCallback_t_SetCallResult");
        LOG_TRACE("{} -> 'CChangeNumOpenSlotsCallback_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CCheckFileSignature_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CCheckFileSignature_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CCheckFileSignature_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CCheckFileSignature_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CCheckFileSignature_t_SetCallResult");
        LOG_TRACE("{} -> 'CCheckFileSignature_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CClanOfficerListResponse_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CClanOfficerListResponse_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CClanOfficerListResponse_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CClanOfficerListResponse_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CClanOfficerListResponse_t_SetCallResult");
        LOG_TRACE("{} -> 'CClanOfficerListResponse_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CComputeNewPlayerCompatibilityResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CComputeNewPlayerCompatibilityResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CComputeNewPlayerCompatibilityResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CComputeNewPlayerCompatibilityResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CComputeNewPlayerCompatibilityResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CComputeNewPlayerCompatibilityResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CCreateBeaconCallback_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CCreateBeaconCallback_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CCreateBeaconCallback_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CCreateBeaconCallback_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CCreateBeaconCallback_t_SetCallResult");
        LOG_TRACE("{} -> 'CCreateBeaconCallback_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CCreateItemResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CCreateItemResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CCreateItemResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CCreateItemResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CCreateItemResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CCreateItemResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CDeleteItemResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CDeleteItemResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CDeleteItemResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CDeleteItemResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CDeleteItemResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CDeleteItemResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CDurationControl_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CDurationControl_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CDurationControl_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CDurationControl_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CDurationControl_t_SetCallResult");
        LOG_TRACE("{} -> 'CDurationControl_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CEncryptedAppTicketResponse_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CEncryptedAppTicketResponse_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CEncryptedAppTicketResponse_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CEncryptedAppTicketResponse_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CEncryptedAppTicketResponse_t_SetCallResult");
        LOG_TRACE("{} -> 'CEncryptedAppTicketResponse_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFileDetailsResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CFileDetailsResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CFileDetailsResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFileDetailsResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CFileDetailsResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CFileDetailsResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFriendsEnumerateFollowingList_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CFriendsEnumerateFollowingList_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CFriendsEnumerateFollowingList_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFriendsEnumerateFollowingList_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CFriendsEnumerateFollowingList_t_SetCallResult");
        LOG_TRACE("{} -> 'CFriendsEnumerateFollowingList_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFriendsGetFollowerCount_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CFriendsGetFollowerCount_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CFriendsGetFollowerCount_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFriendsGetFollowerCount_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CFriendsGetFollowerCount_t_SetCallResult");
        LOG_TRACE("{} -> 'CFriendsGetFollowerCount_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFriendsIsFollowing_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CFriendsIsFollowing_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CFriendsIsFollowing_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CFriendsIsFollowing_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CFriendsIsFollowing_t_SetCallResult");
        LOG_TRACE("{} -> 'CFriendsIsFollowing_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGSReputation_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGSReputation_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGSReputation_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGSReputation_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGSReputation_t_SetCallResult");
        LOG_TRACE("{} -> 'CGSReputation_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGSStatsReceived_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGSStatsReceived_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGSStatsReceived_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGSStatsReceived_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGSStatsReceived_t_SetCallResult");
        LOG_TRACE("{} -> 'CGSStatsReceived_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGSStatsStored_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGSStatsStored_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGSStatsStored_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGSStatsStored_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGSStatsStored_t_SetCallResult");
        LOG_TRACE("{} -> 'CGSStatsStored_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGetAppDependenciesResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGetAppDependenciesResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGetAppDependenciesResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGetAppDependenciesResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGetAppDependenciesResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CGetAppDependenciesResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGetOPFSettingsResult_t_RemoveCallback");
        src_address = dlsym(original_lib_handle, "CGetOPFSettingsResult_t_RemoveCallback");
        LOG_TRACE("{} -> 'CGetOPFSettingsResult_t_RemoveCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGetOPFSettingsResult_t_SetCallback");
        src_address = dlsym(original_lib_handle, "CGetOPFSettingsResult_t_SetCallback");
        LOG_TRACE("{} -> 'CGetOPFSettingsResult_t_SetCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGetUserItemVoteResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGetUserItemVoteResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGetUserItemVoteResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGetUserItemVoteResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGetUserItemVoteResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CGetUserItemVoteResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGlobalAchievementPercentagesReady_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGlobalAchievementPercentagesReady_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGlobalAchievementPercentagesReady_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGlobalAchievementPercentagesReady_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGlobalAchievementPercentagesReady_t_SetCallResult");
        LOG_TRACE("{} -> 'CGlobalAchievementPercentagesReady_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGlobalStatsReceived_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CGlobalStatsReceived_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CGlobalStatsReceived_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CGlobalStatsReceived_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CGlobalStatsReceived_t_SetCallResult");
        LOG_TRACE("{} -> 'CGlobalStatsReceived_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CHTML_BrowserReady_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CHTML_BrowserReady_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CHTML_BrowserReady_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CHTML_BrowserReady_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CHTML_BrowserReady_t_SetCallResult");
        LOG_TRACE("{} -> 'CHTML_BrowserReady_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CJoinClanChatRoomCompletionResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CJoinClanChatRoomCompletionResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CJoinClanChatRoomCompletionResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CJoinClanChatRoomCompletionResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CJoinClanChatRoomCompletionResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CJoinClanChatRoomCompletionResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CJoinPartyCallback_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CJoinPartyCallback_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CJoinPartyCallback_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CJoinPartyCallback_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CJoinPartyCallback_t_SetCallResult");
        LOG_TRACE("{} -> 'CJoinPartyCallback_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardFindResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardFindResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLeaderboardFindResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardFindResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardFindResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CLeaderboardFindResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardScoreUploaded_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardScoreUploaded_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLeaderboardScoreUploaded_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardScoreUploaded_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardScoreUploaded_t_SetCallResult");
        LOG_TRACE("{} -> 'CLeaderboardScoreUploaded_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardScoresDownloaded_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardScoresDownloaded_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLeaderboardScoresDownloaded_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardScoresDownloaded_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardScoresDownloaded_t_SetCallResult");
        LOG_TRACE("{} -> 'CLeaderboardScoresDownloaded_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardUGCSet_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardUGCSet_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLeaderboardUGCSet_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLeaderboardUGCSet_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLeaderboardUGCSet_t_SetCallResult");
        LOG_TRACE("{} -> 'CLeaderboardUGCSet_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLobbyCreated_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLobbyCreated_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLobbyCreated_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLobbyCreated_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLobbyCreated_t_SetCallResult");
        LOG_TRACE("{} -> 'CLobbyCreated_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLobbyEnter_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLobbyEnter_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLobbyEnter_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLobbyEnter_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLobbyEnter_t_SetCallResult");
        LOG_TRACE("{} -> 'CLobbyEnter_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLobbyMatchList_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CLobbyMatchList_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CLobbyMatchList_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CLobbyMatchList_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CLobbyMatchList_t_SetCallResult");
        LOG_TRACE("{} -> 'CLobbyMatchList_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CMarketEligibilityResponse_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CMarketEligibilityResponse_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CMarketEligibilityResponse_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CMarketEligibilityResponse_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CMarketEligibilityResponse_t_SetCallResult");
        LOG_TRACE("{} -> 'CMarketEligibilityResponse_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CNumberOfCurrentPlayers_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CNumberOfCurrentPlayers_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CNumberOfCurrentPlayers_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CNumberOfCurrentPlayers_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CNumberOfCurrentPlayers_t_SetCallResult");
        LOG_TRACE("{} -> 'CNumberOfCurrentPlayers_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CPublisherOwnedAppDataReady_t_RemoveCallback");
        src_address = dlsym(original_lib_handle, "CPublisherOwnedAppDataReady_t_RemoveCallback");
        LOG_TRACE("{} -> 'CPublisherOwnedAppDataReady_t_RemoveCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CPublisherOwnedAppDataReady_t_SetCallback");
        src_address = dlsym(original_lib_handle, "CPublisherOwnedAppDataReady_t_SetCallback");
        LOG_TRACE("{} -> 'CPublisherOwnedAppDataReady_t_SetCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageDeletePublishedFileResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageDeletePublishedFileResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageDeletePublishedFileResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageDeletePublishedFileResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageDeletePublishedFileResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageDeletePublishedFileResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageDownloadUGCResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageDownloadUGCResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageDownloadUGCResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageDownloadUGCResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageDownloadUGCResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageDownloadUGCResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumeratePublishedFilesByUserActionResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumerateUserPublishedFilesResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumerateUserPublishedFilesResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumerateUserPublishedFilesResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumerateUserPublishedFilesResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumerateUserPublishedFilesResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumerateUserPublishedFilesResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumerateUserSubscribedFilesResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumerateUserSubscribedFilesResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumerateUserSubscribedFilesResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumerateUserSubscribedFilesResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumerateUserSubscribedFilesResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumerateUserSubscribedFilesResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumerateWorkshopFilesResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumerateWorkshopFilesResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumerateWorkshopFilesResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageEnumerateWorkshopFilesResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageEnumerateWorkshopFilesResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageEnumerateWorkshopFilesResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageFileReadAsyncComplete_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageFileReadAsyncComplete_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageFileReadAsyncComplete_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageFileReadAsyncComplete_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageFileReadAsyncComplete_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageFileReadAsyncComplete_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageFileShareResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageFileShareResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageFileShareResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageFileShareResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageFileShareResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageFileShareResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageFileWriteAsyncComplete_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageFileWriteAsyncComplete_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageFileWriteAsyncComplete_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageFileWriteAsyncComplete_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageFileWriteAsyncComplete_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageFileWriteAsyncComplete_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageGetPublishedFileDetailsResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageGetPublishedFileDetailsResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageGetPublishedFileDetailsResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageGetPublishedFileDetailsResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageGetPublishedFileDetailsResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageGetPublishedFileDetailsResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageGetPublishedItemVoteDetailsResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageGetPublishedItemVoteDetailsResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageGetPublishedItemVoteDetailsResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageGetPublishedItemVoteDetailsResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageGetPublishedItemVoteDetailsResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageGetPublishedItemVoteDetailsResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStoragePublishFileProgress_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStoragePublishFileProgress_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStoragePublishFileProgress_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStoragePublishFileProgress_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStoragePublishFileProgress_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStoragePublishFileProgress_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageSetUserPublishedFileActionResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageSetUserPublishedFileActionResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageSetUserPublishedFileActionResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageSetUserPublishedFileActionResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageSetUserPublishedFileActionResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageSetUserPublishedFileActionResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageSubscribePublishedFileResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageSubscribePublishedFileResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageSubscribePublishedFileResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageSubscribePublishedFileResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageSubscribePublishedFileResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageSubscribePublishedFileResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageUnsubscribePublishedFileResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageUnsubscribePublishedFileResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageUnsubscribePublishedFileResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageUnsubscribePublishedFileResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageUnsubscribePublishedFileResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageUnsubscribePublishedFileResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageUpdatePublishedFileResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageUpdatePublishedFileResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageUpdatePublishedFileResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageUpdatePublishedFileResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageUpdatePublishedFileResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageUpdatePublishedFileResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageUpdateUserPublishedItemVoteResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageUpdateUserPublishedItemVoteResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageUpdateUserPublishedItemVoteResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoteStorageUpdateUserPublishedItemVoteResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoteStorageUpdateUserPublishedItemVoteResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoteStorageUpdateUserPublishedItemVoteResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoveAppDependencyResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoveAppDependencyResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoveAppDependencyResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoveAppDependencyResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoveAppDependencyResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoveAppDependencyResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoveUGCDependencyResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CRemoveUGCDependencyResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CRemoveUGCDependencyResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CRemoveUGCDependencyResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CRemoveUGCDependencyResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CRemoveUGCDependencyResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSetPersonaNameResponse_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSetPersonaNameResponse_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSetPersonaNameResponse_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSetPersonaNameResponse_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSetPersonaNameResponse_t_SetCallResult");
        LOG_TRACE("{} -> 'CSetPersonaNameResponse_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSetUserItemVoteResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSetUserItemVoteResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSetUserItemVoteResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSetUserItemVoteResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSetUserItemVoteResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CSetUserItemVoteResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CStartPlaytimeTrackingResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CStartPlaytimeTrackingResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CStartPlaytimeTrackingResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CStartPlaytimeTrackingResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CStartPlaytimeTrackingResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CStartPlaytimeTrackingResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamInventoryEligiblePromoItemDefIDs_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSteamInventoryEligiblePromoItemDefIDs_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSteamInventoryEligiblePromoItemDefIDs_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamInventoryEligiblePromoItemDefIDs_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSteamInventoryEligiblePromoItemDefIDs_t_SetCallResult");
        LOG_TRACE("{} -> 'CSteamInventoryEligiblePromoItemDefIDs_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamInventoryRequestPricesResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSteamInventoryRequestPricesResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSteamInventoryRequestPricesResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamInventoryRequestPricesResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSteamInventoryRequestPricesResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CSteamInventoryRequestPricesResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamInventoryStartPurchaseResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSteamInventoryStartPurchaseResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSteamInventoryStartPurchaseResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamInventoryStartPurchaseResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSteamInventoryStartPurchaseResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CSteamInventoryStartPurchaseResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamUGCQueryCompleted_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSteamUGCQueryCompleted_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSteamUGCQueryCompleted_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSteamUGCQueryCompleted_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSteamUGCQueryCompleted_t_SetCallResult");
        LOG_TRACE("{} -> 'CSteamUGCQueryCompleted_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CStopPlaytimeTrackingResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CStopPlaytimeTrackingResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CStopPlaytimeTrackingResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CStopPlaytimeTrackingResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CStopPlaytimeTrackingResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CStopPlaytimeTrackingResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CStoreAuthURLResponse_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CStoreAuthURLResponse_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CStoreAuthURLResponse_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CStoreAuthURLResponse_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CStoreAuthURLResponse_t_SetCallResult");
        LOG_TRACE("{} -> 'CStoreAuthURLResponse_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSubmitItemUpdateResult_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CSubmitItemUpdateResult_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CSubmitItemUpdateResult_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CSubmitItemUpdateResult_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CSubmitItemUpdateResult_t_SetCallResult");
        LOG_TRACE("{} -> 'CSubmitItemUpdateResult_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CUserFavoriteItemsListChanged_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CUserFavoriteItemsListChanged_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CUserFavoriteItemsListChanged_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CUserFavoriteItemsListChanged_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CUserFavoriteItemsListChanged_t_SetCallResult");
        LOG_TRACE("{} -> 'CUserFavoriteItemsListChanged_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CUserStatsReceived_t_RemoveCallResult");
        src_address = dlsym(original_lib_handle, "CUserStatsReceived_t_RemoveCallResult");
        LOG_TRACE("{} -> 'CUserStatsReceived_t_RemoveCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CUserStatsReceived_t_RemoveCallback");
        src_address = dlsym(original_lib_handle, "CUserStatsReceived_t_RemoveCallback");
        LOG_TRACE("{} -> 'CUserStatsReceived_t_RemoveCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CUserStatsReceived_t_SetCallResult");
        src_address = dlsym(original_lib_handle, "CUserStatsReceived_t_SetCallResult");
        LOG_TRACE("{} -> 'CUserStatsReceived_t_SetCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "CUserStatsReceived_t_SetCallback");
        src_address = dlsym(original_lib_handle, "CUserStatsReceived_t_SetCallback");
        LOG_TRACE("{} -> 'CUserStatsReceived_t_SetCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "GetHSteamPipe");
        src_address = dlsym(original_lib_handle, "GetHSteamPipe");
        LOG_TRACE("{} -> 'GetHSteamPipe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "GetHSteamUser");
        src_address = dlsym(original_lib_handle, "GetHSteamUser");
        LOG_TRACE("{} -> 'GetHSteamUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamApps_BIsCybercafe");
        src_address = dlsym(original_lib_handle, "ISteamApps_BIsCybercafe");
        LOG_TRACE("{} -> 'ISteamApps_BIsCybercafe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamApps_BIsLowViolence");
        src_address = dlsym(original_lib_handle, "ISteamApps_BIsLowViolence");
        LOG_TRACE("{} -> 'ISteamApps_BIsLowViolence' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamApps_BIsSubscribed");
        src_address = dlsym(original_lib_handle, "ISteamApps_BIsSubscribed");
        LOG_TRACE("{} -> 'ISteamApps_BIsSubscribed' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamApps_BIsSubscribedApp");
        src_address = dlsym(original_lib_handle, "ISteamApps_BIsSubscribedApp");
        LOG_TRACE("{} -> 'ISteamApps_BIsSubscribedApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamApps_GetAvailableGameLanguages");
        src_address = dlsym(original_lib_handle, "ISteamApps_GetAvailableGameLanguages");
        LOG_TRACE("{} -> 'ISteamApps_GetAvailableGameLanguages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamApps_GetCurrentGameLanguage");
        src_address = dlsym(original_lib_handle, "ISteamApps_GetCurrentGameLanguage");
        LOG_TRACE("{} -> 'ISteamApps_GetCurrentGameLanguage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamClient_SetLocalIPBinding");
        src_address = dlsym(original_lib_handle, "ISteamClient_SetLocalIPBinding");
        LOG_TRACE("{} -> 'ISteamClient_SetLocalIPBinding' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_BLoggedOn");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_BLoggedOn");
        LOG_TRACE("{} -> 'ISteamGameServer_BLoggedOn' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_BSecure");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_BSecure");
        LOG_TRACE("{} -> 'ISteamGameServer_BSecure' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_BUpdateUserData");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_BUpdateUserData");
        LOG_TRACE("{} -> 'ISteamGameServer_BUpdateUserData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_CreateUnauthenticatedUserConnection");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_CreateUnauthenticatedUserConnection");
        LOG_TRACE("{} -> 'ISteamGameServer_CreateUnauthenticatedUserConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_GetSteamID");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_GetSteamID");
        LOG_TRACE("{} -> 'ISteamGameServer_GetSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_SendUserConnectAndAuthenticate");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_SendUserConnectAndAuthenticate");
        LOG_TRACE("{} -> 'ISteamGameServer_SendUserConnectAndAuthenticate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_SendUserDisconnect");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_SendUserDisconnect");
        LOG_TRACE("{} -> 'ISteamGameServer_SendUserDisconnect' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_SetGameType");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_SetGameType");
        LOG_TRACE("{} -> 'ISteamGameServer_SetGameType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_SetServerType");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_SetServerType");
        LOG_TRACE("{} -> 'ISteamGameServer_SetServerType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_UpdateSpectatorPort");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_UpdateSpectatorPort");
        LOG_TRACE("{} -> 'ISteamGameServer_UpdateSpectatorPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamGameServer_UpdateStatus");
        src_address = dlsym(original_lib_handle, "ISteamGameServer_UpdateStatus");
        LOG_TRACE("{} -> 'ISteamGameServer_UpdateStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_AddMasterServer");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_AddMasterServer");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_AddMasterServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_ClearAllKeyValues");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_ClearAllKeyValues");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_ClearAllKeyValues' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_ForceHeartbeat");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_ForceHeartbeat");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_ForceHeartbeat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_GetMasterServerAddress");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_GetMasterServerAddress");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_GetMasterServerAddress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_GetNextOutgoingPacket");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_GetNextOutgoingPacket");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_GetNextOutgoingPacket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_GetNumMasterServers");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_GetNumMasterServers");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_GetNumMasterServers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_HandleIncomingPacket");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_HandleIncomingPacket");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_HandleIncomingPacket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_NotifyShutdown");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_NotifyShutdown");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_NotifyShutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_RemoveMasterServer");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_RemoveMasterServer");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_RemoveMasterServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_SetActive");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_SetActive");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_SetActive' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_SetBasicServerData");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_SetBasicServerData");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_SetBasicServerData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_SetHeartbeatInterval");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_SetHeartbeatInterval");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_SetHeartbeatInterval' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_SetKeyValue");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_SetKeyValue");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_SetKeyValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamMasterServerUpdater_WasRestartRequested");
        src_address = dlsym(original_lib_handle, "ISteamMasterServerUpdater_WasRestartRequested");
        LOG_TRACE("{} -> 'ISteamMasterServerUpdater_WasRestartRequested' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamUser_BLoggedOn");
        src_address = dlsym(original_lib_handle, "ISteamUser_BLoggedOn");
        LOG_TRACE("{} -> 'ISteamUser_BLoggedOn' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamUser_InitiateGameConnection");
        src_address = dlsym(original_lib_handle, "ISteamUser_InitiateGameConnection");
        LOG_TRACE("{} -> 'ISteamUser_InitiateGameConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamUser_TerminateGameConnection");
        src_address = dlsym(original_lib_handle, "ISteamUser_TerminateGameConnection");
        LOG_TRACE("{} -> 'ISteamUser_TerminateGameConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "ISteamUtils_GetAppID");
        src_address = dlsym(original_lib_handle, "ISteamUtils_GetAppID");
        LOG_TRACE("{} -> 'ISteamUtils_GetAppID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_GetHSteamPipe");
        src_address = dlsym(original_lib_handle, "SteamAPI_GetHSteamPipe");
        LOG_TRACE("{} -> 'SteamAPI_GetHSteamPipe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_GetHSteamUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_GetHSteamUser");
        LOG_TRACE("{} -> 'SteamAPI_GetHSteamUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_GetSteamInstallPath");
        src_address = dlsym(original_lib_handle, "SteamAPI_GetSteamInstallPath");
        LOG_TRACE("{} -> 'SteamAPI_GetSteamInstallPath' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamAppList_GetAppBuildId");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamAppList_GetAppBuildId");
        LOG_TRACE("{} -> 'SteamAPI_ISteamAppList_GetAppBuildId' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamAppList_GetAppInstallDir");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamAppList_GetAppInstallDir");
        LOG_TRACE("{} -> 'SteamAPI_ISteamAppList_GetAppInstallDir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamAppList_GetAppName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamAppList_GetAppName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamAppList_GetAppName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamAppList_GetInstalledApps");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamAppList_GetInstalledApps");
        LOG_TRACE("{} -> 'SteamAPI_ISteamAppList_GetInstalledApps' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamAppList_GetNumInstalledApps");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamAppList_GetNumInstalledApps");
        LOG_TRACE("{} -> 'SteamAPI_ISteamAppList_GetNumInstalledApps' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BGetDLCDataByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BGetDLCDataByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BGetDLCDataByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsAppInstalled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsAppInstalled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsAppInstalled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsCybercafe");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsCybercafe");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsCybercafe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsDlcInstalled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsDlcInstalled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsDlcInstalled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsLowViolence");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsLowViolence");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsLowViolence' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsSubscribed");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsSubscribed");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsSubscribed' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsSubscribedApp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsSubscribedApp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsSubscribedApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsTimedTrial");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsTimedTrial");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsTimedTrial' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_BIsVACBanned");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_BIsVACBanned");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_BIsVACBanned' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetAppBuildId");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetAppBuildId");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetAppBuildId' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetAppInstallDir");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetAppInstallDir");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetAppInstallDir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetAppOwner");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetAppOwner");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetAppOwner' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetAvailableGameLanguages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetAvailableGameLanguages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetAvailableGameLanguages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetBetaInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetBetaInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetBetaInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetCurrentBetaName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetCurrentBetaName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetCurrentBetaName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetCurrentGameLanguage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetCurrentGameLanguage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetCurrentGameLanguage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetDLCCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetDLCCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetDLCCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetDlcDownloadProgress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetDlcDownloadProgress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetDlcDownloadProgress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetFileDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetFileDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetFileDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetInstalledDepots");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetInstalledDepots");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetInstalledDepots' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetLaunchCommandLine");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetLaunchCommandLine");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetLaunchCommandLine' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetLaunchQueryParam");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetLaunchQueryParam");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetLaunchQueryParam' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetNumBetas");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetNumBetas");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetNumBetas' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_GetPublisherOwnedAppData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_GetPublisherOwnedAppData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_GetPublisherOwnedAppData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_InstallDLC");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_InstallDLC");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_InstallDLC' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_MarkContentCorrupt");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_MarkContentCorrupt");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_MarkContentCorrupt' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_RequestPublisherOwnedAppData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_RequestPublisherOwnedAppData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_RequestPublisherOwnedAppData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_SetActiveBeta");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_SetActiveBeta");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_SetActiveBeta' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_SetDlcContext");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_SetDlcContext");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_SetDlcContext' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamApps_UninstallDLC");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamApps_UninstallDLC");
        LOG_TRACE("{} -> 'SteamAPI_ISteamApps_UninstallDLC' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_BReleaseSteamPipe");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_BReleaseSteamPipe");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_BReleaseSteamPipe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_BShutdownIfAllPipesClosed");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_BShutdownIfAllPipesClosed");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_BShutdownIfAllPipesClosed' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_ConnectToGlobalUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_ConnectToGlobalUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_ConnectToGlobalUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_CreateLocalUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_CreateLocalUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_CreateLocalUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_CreateSteamPipe");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_CreateSteamPipe");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_CreateSteamPipe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetIPCCallCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetIPCCallCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetIPCCallCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamAppList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamAppList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamAppList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamApps");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamApps");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamApps' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamController");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamController");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamController' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamFriends");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamFriends");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamFriends' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamGameSearch");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamGameSearch");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamGameSearch' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamGameServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamGameServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamGameServerStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamGameServerStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamGameServerStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamGenericInterface");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamGenericInterface");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamGenericInterface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamHTMLSurface");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamHTMLSurface");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamHTMLSurface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamHTTP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamHTTP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamHTTP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamInventory");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamInventory");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamInventory' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamMatchmaking");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamMatchmaking");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamMatchmaking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamMatchmakingServers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamMatchmakingServers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamMatchmakingServers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamMusic");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamMusic");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamMusic' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamMusicRemote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamMusicRemote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamMusicRemote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamNetworking");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamNetworking");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamNetworking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamParentalSettings");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamParentalSettings");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamParentalSettings' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamParties");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamParties");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamParties' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamRemotePlay");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamRemotePlay");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamRemotePlay' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamRemoteStorage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamRemoteStorage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamRemoteStorage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamScreenshots");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamScreenshots");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamScreenshots' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamUGC");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamUGC");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamUGC' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamUnifiedMessages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamUnifiedMessages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamUnifiedMessages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamUserStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamUserStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamUserStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamUtils");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamUtils");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamUtils' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_GetISteamVideo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_GetISteamVideo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_GetISteamVideo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_ReleaseUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_ReleaseUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_ReleaseUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_Remove_SteamAPI_CPostAPIResultInProcess");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_Remove_SteamAPI_CPostAPIResultInProcess");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_Remove_SteamAPI_CPostAPIResultInProcess' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_RunFrame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_RunFrame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_RunFrame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_SetLocalIPBinding");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_SetLocalIPBinding");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_SetLocalIPBinding' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_SetWarningMessageHook");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_SetWarningMessageHook");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_SetWarningMessageHook' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_Set_SteamAPI_CCheckCallbackRegisteredInProcess");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_Set_SteamAPI_CCheckCallbackRegisteredInProcess");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_Set_SteamAPI_CCheckCallbackRegisteredInProcess' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamClient_Set_SteamAPI_CPostAPIResultInProcess");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamClient_Set_SteamAPI_CPostAPIResultInProcess");
        LOG_TRACE("{} -> 'SteamAPI_ISteamClient_Set_SteamAPI_CPostAPIResultInProcess' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_ActivateActionSet");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_ActivateActionSet");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_ActivateActionSet' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_ActivateActionSetLayer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_ActivateActionSetLayer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_ActivateActionSetLayer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_DeactivateActionSetLayer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_DeactivateActionSetLayer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_DeactivateActionSetLayer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_DeactivateAllActionSetLayers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_DeactivateAllActionSetLayers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_DeactivateAllActionSetLayers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetActionOriginFromXboxOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetActionOriginFromXboxOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetActionOriginFromXboxOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetActionSetHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetActionSetHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetActionSetHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetActiveActionSetLayers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetActiveActionSetLayers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetActiveActionSetLayers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetAnalogActionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetAnalogActionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetAnalogActionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetAnalogActionHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetAnalogActionHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetAnalogActionHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetAnalogActionOrigins");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetAnalogActionOrigins");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetAnalogActionOrigins' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetConnectedControllers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetConnectedControllers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetConnectedControllers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetControllerBindingRevision");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetControllerBindingRevision");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetControllerBindingRevision' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetControllerForGamepadIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetControllerForGamepadIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetControllerForGamepadIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetControllerState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetControllerState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetControllerState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetCurrentActionSet");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetCurrentActionSet");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetCurrentActionSet' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetDigitalActionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetDigitalActionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetDigitalActionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetDigitalActionHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetDigitalActionHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetDigitalActionHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetDigitalActionOrigins");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetDigitalActionOrigins");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetDigitalActionOrigins' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetGamepadIndexForController");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetGamepadIndexForController");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetGamepadIndexForController' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetGlyphForActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetGlyphForActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetGlyphForActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetGlyphForXboxOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetGlyphForXboxOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetGlyphForXboxOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetInputTypeForHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetInputTypeForHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetInputTypeForHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetMotionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetMotionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetMotionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetStringForActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetStringForActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetStringForActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_GetStringForXboxOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_GetStringForXboxOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_GetStringForXboxOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_Init");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_Init");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_RunFrame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_RunFrame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_RunFrame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_SetLEDColor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_SetLEDColor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_SetLEDColor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_SetOverrideMode");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_SetOverrideMode");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_SetOverrideMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_ShowAnalogActionOrigins");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_ShowAnalogActionOrigins");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_ShowAnalogActionOrigins' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_ShowBindingPanel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_ShowBindingPanel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_ShowBindingPanel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_ShowDigitalActionOrigins");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_ShowDigitalActionOrigins");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_ShowDigitalActionOrigins' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_Shutdown");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_StopAnalogActionMomentum");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_StopAnalogActionMomentum");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_StopAnalogActionMomentum' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_TranslateActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_TranslateActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_TranslateActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_TriggerHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_TriggerHapticPulse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_TriggerHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_TriggerRepeatedHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_TriggerRepeatedHapticPulse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_TriggerRepeatedHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamController_TriggerVibration");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamController_TriggerVibration");
        LOG_TRACE("{} -> 'SteamAPI_ISteamController_TriggerVibration' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlay");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlay");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlay' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayToStore");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayToStore");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlayToStore' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayToUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayToUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlayToUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_BHasEquippedProfileItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_BHasEquippedProfileItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_BHasEquippedProfileItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ClearRichPresence");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ClearRichPresence");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ClearRichPresence' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_CloseClanChatWindowInSteam");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_CloseClanChatWindowInSteam");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_CloseClanChatWindowInSteam' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_DownloadClanActivityCounts");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_DownloadClanActivityCounts");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_DownloadClanActivityCounts' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_EnumerateFollowingList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_EnumerateFollowingList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_EnumerateFollowingList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetChatMemberByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetChatMemberByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetChatMemberByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanActivityCounts");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanActivityCounts");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanActivityCounts' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanChatMemberCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanChatMemberCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanChatMemberCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanChatMessage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanChatMessage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanChatMessage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanOfficerByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanOfficerByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanOfficerByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanOfficerCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanOfficerCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanOfficerCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanOwner");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanOwner");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanOwner' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetClanTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetClanTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetClanTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetCoplayFriend");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetCoplayFriend");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetCoplayFriend' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetCoplayFriendCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetCoplayFriendCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetCoplayFriendCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFollowerCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFollowerCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFollowerCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendCoplayGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendCoplayGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendCoplayGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendCoplayTime");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendCoplayTime");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendCoplayTime' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendCountFromSource");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendCountFromSource");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendCountFromSource' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendFromSourceByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendFromSourceByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendFromSourceByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendGamePlayed");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendGamePlayed");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendGamePlayed' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendMessage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendMessage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendMessage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendPersonaName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendPersonaName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendPersonaName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendPersonaNameHistory");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendPersonaNameHistory");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendPersonaNameHistory' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendPersonaState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendPersonaState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendPersonaState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendRelationship");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendRelationship");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendRelationship' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendRichPresence");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendRichPresence");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendRichPresence' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendSteamLevel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendSteamLevel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendSteamLevel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendsGroupCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupMembersCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupMembersCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendsGroupMembersCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupMembersList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupMembersList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendsGroupMembersList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetFriendsGroupName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetFriendsGroupName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetLargeFriendAvatar");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetLargeFriendAvatar");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetLargeFriendAvatar' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetMediumFriendAvatar");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetMediumFriendAvatar");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetMediumFriendAvatar' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetPersonaName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetPersonaName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetPersonaName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetPersonaState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetPersonaState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetPersonaState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetPlayerNickname");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetPlayerNickname");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetPlayerNickname' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetProfileItemPropertyString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetProfileItemPropertyString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetProfileItemPropertyString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetProfileItemPropertyUint");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetProfileItemPropertyUint");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetProfileItemPropertyUint' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetSmallFriendAvatar");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetSmallFriendAvatar");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetSmallFriendAvatar' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_GetUserRestrictions");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_GetUserRestrictions");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_GetUserRestrictions' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_HasFriend");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_HasFriend");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_HasFriend' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_InviteUserToGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_InviteUserToGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_InviteUserToGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_IsClanChatAdmin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_IsClanChatAdmin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_IsClanChatAdmin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_IsClanOfficialGameGroup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_IsClanOfficialGameGroup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_IsClanOfficialGameGroup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_IsClanPublic");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_IsClanPublic");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_IsClanPublic' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_IsFollowing");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_IsFollowing");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_IsFollowing' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_IsUserInSource");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_IsUserInSource");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_IsUserInSource' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_JoinClanChatRoom");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_JoinClanChatRoom");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_JoinClanChatRoom' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_LeaveClanChatRoom");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_LeaveClanChatRoom");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_LeaveClanChatRoom' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_OpenClanChatWindowInSteam");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_OpenClanChatWindowInSteam");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_OpenClanChatWindowInSteam' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_ReplyToFriendMessage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_ReplyToFriendMessage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_ReplyToFriendMessage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_RequestClanOfficerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_RequestClanOfficerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_RequestClanOfficerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_RequestEquippedProfileItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_RequestEquippedProfileItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_RequestEquippedProfileItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_RequestFriendRichPresence");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_RequestFriendRichPresence");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_RequestFriendRichPresence' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_RequestUserInformation");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_RequestUserInformation");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_RequestUserInformation' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_SendClanChatMessage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_SendClanChatMessage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_SendClanChatMessage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_SetInGameVoiceSpeaking");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_SetInGameVoiceSpeaking");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_SetInGameVoiceSpeaking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_SetListenForFriendsMessages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_SetListenForFriendsMessages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_SetListenForFriendsMessages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_SetPersonaName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_SetPersonaName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_SetPersonaName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_SetPlayedWith");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_SetPlayedWith");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_SetPlayedWith' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamFriends_SetRichPresence");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamFriends_SetRichPresence");
        LOG_TRACE("{} -> 'SteamAPI_ISteamFriends_SetRichPresence' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_AcceptGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_AcceptGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_AcceptGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_AddGameSearchParams");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_AddGameSearchParams");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_AddGameSearchParams' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_DeclineGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_DeclineGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_DeclineGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_EndGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_EndGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_EndGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_EndGameSearch");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_EndGameSearch");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_EndGameSearch' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_HostConfirmGameStart");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_HostConfirmGameStart");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_HostConfirmGameStart' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_RequestPlayersForGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_RequestPlayersForGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_RequestPlayersForGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_RetrieveConnectionDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_RetrieveConnectionDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_RetrieveConnectionDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_SearchForGameSolo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_SearchForGameSolo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_SearchForGameSolo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_SearchForGameWithLobby");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_SearchForGameWithLobby");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_SearchForGameWithLobby' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_SetConnectionDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_SetConnectionDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_SetConnectionDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_SetGameHostParams");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_SetGameHostParams");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_SetGameHostParams' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameSearch_SubmitPlayerResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameSearch_SubmitPlayerResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameSearch_SubmitPlayerResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_ClearUserAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_ClearUserAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_ClearUserAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_GetUserAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_GetUserStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStat0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStat0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_GetUserStat0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStatFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStatFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_GetUserStatFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStatInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_GetUserStatInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_GetUserStatInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_RequestUserStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_RequestUserStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_RequestUserStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_SetUserAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_SetUserStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStat0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStat0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_SetUserStat0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStatFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStatFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_SetUserStatFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStatInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_SetUserStatInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_SetUserStatInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_StoreUserStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_StoreUserStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_StoreUserStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_AssociateWithClan");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_AssociateWithClan");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_AssociateWithClan' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_BLoggedOn");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_BLoggedOn");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_BLoggedOn' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_BSecure");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_BSecure");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_BSecure' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_BUpdateUserData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_BUpdateUserData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_BUpdateUserData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_BeginAuthSession");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_BeginAuthSession");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_BeginAuthSession' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_CancelAuthTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_CancelAuthTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_CancelAuthTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_ClearAllKeyValues");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_ClearAllKeyValues");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_ClearAllKeyValues' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_EnableHeartbeats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_EnableHeartbeats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_EnableHeartbeats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_EndAuthSession");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_EndAuthSession");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_EndAuthSession' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_ForceHeartbeat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_ForceHeartbeat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_ForceHeartbeat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_GetAuthSessionTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_GetAuthSessionTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_GetAuthSessionTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_GetGameplayStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_GetGameplayStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_GetGameplayStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_GetNextOutgoingPacket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_GetNextOutgoingPacket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_GetNextOutgoingPacket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_GetPublicIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_GetPublicIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_GetPublicIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_GetServerReputation");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_GetServerReputation");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_GetServerReputation' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_GetSteamID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_GetSteamID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_GetSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_HandleIncomingPacket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_HandleIncomingPacket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_HandleIncomingPacket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_InitGameServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_InitGameServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_InitGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_LogOff");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_LogOff");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_LogOff' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_LogOn");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_LogOn");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_LogOn' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_LogOnAnonymous");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_LogOnAnonymous");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_LogOnAnonymous' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_RequestUserGroupStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_RequestUserGroupStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_RequestUserGroupStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate_DEPRECATED");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate_DEPRECATED");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate_DEPRECATED' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SendUserDisconnect");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SendUserDisconnect");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SendUserDisconnect' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetAdvertiseServerActive");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetAdvertiseServerActive");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetAdvertiseServerActive' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetBotPlayerCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetBotPlayerCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetBotPlayerCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetDedicatedServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetDedicatedServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetDedicatedServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetGameData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetGameData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetGameData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetGameDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetGameDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetGameDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetGameTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetGameTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetGameTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetHeartbeatInterval");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetHeartbeatInterval");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetHeartbeatInterval' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetKeyValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetKeyValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetKeyValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetMapName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetMapName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetMapName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetMaxPlayerCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetMaxPlayerCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetMaxPlayerCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetModDir");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetModDir");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetModDir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetPasswordProtected");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetPasswordProtected");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetPasswordProtected' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetProduct");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetProduct");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetProduct' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetRegion");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetRegion");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetRegion' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetServerName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetServerName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetServerName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetSpectatorPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetSpectatorPort");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetSpectatorPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_SetSpectatorServerName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_SetSpectatorServerName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_SetSpectatorServerName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_UserHasLicenseForApp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_UserHasLicenseForApp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_UserHasLicenseForApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamGameServer_WasRestartRequested");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamGameServer_WasRestartRequested");
        LOG_TRACE("{} -> 'SteamAPI_ISteamGameServer_WasRestartRequested' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_AddHeader");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_AddHeader");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_AddHeader' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_AllowStartRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_AllowStartRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_AllowStartRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_CopyToClipboard");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_CopyToClipboard");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_CopyToClipboard' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_CreateBrowser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_CreateBrowser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_CreateBrowser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_DestructISteamHTMLSurface");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_DestructISteamHTMLSurface");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_DestructISteamHTMLSurface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_ExecuteJavascript");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_ExecuteJavascript");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_ExecuteJavascript' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_Find");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_Find");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_Find' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_GetLinkAtPosition");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_GetLinkAtPosition");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_GetLinkAtPosition' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_GoBack");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_GoBack");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_GoBack' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_GoForward");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_GoForward");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_GoForward' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_Init");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_Init");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_JSDialogResponse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_JSDialogResponse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_JSDialogResponse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_KeyChar");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_KeyChar");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_KeyChar' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_KeyDown");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_KeyDown");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_KeyDown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_KeyUp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_KeyUp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_KeyUp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_LoadURL");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_LoadURL");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_LoadURL' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseDoubleClick");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseDoubleClick");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_MouseDoubleClick' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseDown");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseDown");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_MouseDown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseMove");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseMove");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_MouseMove' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseUp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseUp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_MouseUp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseWheel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_MouseWheel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_MouseWheel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_OpenDeveloperTools");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_OpenDeveloperTools");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_OpenDeveloperTools' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_PasteFromClipboard");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_PasteFromClipboard");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_PasteFromClipboard' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_Reload");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_Reload");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_Reload' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_RemoveBrowser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_RemoveBrowser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_RemoveBrowser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetBackgroundMode");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetBackgroundMode");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetBackgroundMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetCookie");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetCookie");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetCookie' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetHorizontalScroll");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetHorizontalScroll");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetHorizontalScroll' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetKeyFocus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetKeyFocus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetKeyFocus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetPageScaleFactor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetPageScaleFactor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetPageScaleFactor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetSize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetSize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_SetVerticalScroll");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_SetVerticalScroll");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_SetVerticalScroll' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_Shutdown");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_StopFind");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_StopFind");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_StopFind' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_StopLoad");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_StopLoad");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_StopLoad' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTMLSurface_ViewSource");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTMLSurface_ViewSource");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTMLSurface_ViewSource' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_CreateCookieContainer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_CreateCookieContainer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_CreateCookieContainer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_CreateHTTPRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_CreateHTTPRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_CreateHTTPRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_DeferHTTPRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_DeferHTTPRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_DeferHTTPRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseBodyData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseBodyData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPResponseBodyData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseBodySize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseBodySize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPResponseBodySize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_PrioritizeHTTPRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_PrioritizeHTTPRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_PrioritizeHTTPRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_ReleaseCookieContainer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_ReleaseCookieContainer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_ReleaseCookieContainer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_ReleaseHTTPRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_ReleaseHTTPRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_ReleaseHTTPRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SendHTTPRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SendHTTPRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SendHTTPRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetCookie");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetCookie");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetCookie' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestContextValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestContextValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestContextValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_ActivateActionSet");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_ActivateActionSet");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_ActivateActionSet' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_ActivateActionSetLayer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_ActivateActionSetLayer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_ActivateActionSetLayer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_BNewDataAvailable");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_BNewDataAvailable");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_BNewDataAvailable' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_BWaitForData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_BWaitForData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_BWaitForData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_DeactivateActionSetLayer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_DeactivateActionSetLayer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_DeactivateActionSetLayer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_DeactivateAllActionSetLayers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_DeactivateAllActionSetLayers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_DeactivateAllActionSetLayers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_EnableActionEventCallbacks");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_EnableActionEventCallbacks");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_EnableActionEventCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_EnableDeviceCallbacks");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_EnableDeviceCallbacks");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_EnableDeviceCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetActionSetHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetActionSetHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetActionSetHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetActiveActionSetLayers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetActiveActionSetLayers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetActiveActionSetLayers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetAnalogActionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetAnalogActionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetAnalogActionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetAnalogActionHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetAnalogActionHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetAnalogActionHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetAnalogActionOrigins");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetAnalogActionOrigins");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetAnalogActionOrigins' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetConnectedControllers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetConnectedControllers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetConnectedControllers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetControllerForGamepadIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetControllerForGamepadIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetControllerForGamepadIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetCurrentActionSet");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetCurrentActionSet");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetCurrentActionSet' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetDeviceBindingRevision");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetDeviceBindingRevision");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetDeviceBindingRevision' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetDigitalActionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetDigitalActionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetDigitalActionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetDigitalActionHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetDigitalActionHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetDigitalActionHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetDigitalActionOrigins");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetDigitalActionOrigins");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetDigitalActionOrigins' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetGamepadIndexForController");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetGamepadIndexForController");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetGamepadIndexForController' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetGlyphForActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetGlyphForActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetGlyphForActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetGlyphForActionOrigin_Legacy");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetGlyphForActionOrigin_Legacy");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetGlyphForActionOrigin_Legacy' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetGlyphForXboxOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetGlyphForXboxOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetGlyphForXboxOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetGlyphPNGForActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetGlyphPNGForActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetGlyphPNGForActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetGlyphSVGForActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetGlyphSVGForActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetGlyphSVGForActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetInputTypeForHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetInputTypeForHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetInputTypeForHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetMotionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetMotionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetMotionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetRemotePlaySessionID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetRemotePlaySessionID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetRemotePlaySessionID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetSessionInputConfigurationSettings");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetSessionInputConfigurationSettings");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetSessionInputConfigurationSettings' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetStringForActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetStringForActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetStringForActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetStringForAnalogActionName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetStringForAnalogActionName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetStringForAnalogActionName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetStringForDigitalActionName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetStringForDigitalActionName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetStringForDigitalActionName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_GetStringForXboxOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_GetStringForXboxOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_GetStringForXboxOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_Init");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_Init");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_Legacy_TriggerHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_Legacy_TriggerHapticPulse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_Legacy_TriggerHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_Legacy_TriggerRepeatedHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_Legacy_TriggerRepeatedHapticPulse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_Legacy_TriggerRepeatedHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_RunFrame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_RunFrame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_RunFrame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_SetDualSenseTriggerEffect");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_SetDualSenseTriggerEffect");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_SetDualSenseTriggerEffect' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_SetInputActionManifestFilePath");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_SetInputActionManifestFilePath");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_SetInputActionManifestFilePath' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_SetLEDColor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_SetLEDColor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_SetLEDColor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_ShowBindingPanel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_ShowBindingPanel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_ShowBindingPanel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_Shutdown");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_StopAnalogActionMomentum");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_StopAnalogActionMomentum");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_StopAnalogActionMomentum' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_TranslateActionOrigin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_TranslateActionOrigin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_TranslateActionOrigin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_TriggerHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_TriggerHapticPulse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_TriggerHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_TriggerRepeatedHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_TriggerRepeatedHapticPulse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_TriggerRepeatedHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_TriggerSimpleHapticEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_TriggerSimpleHapticEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_TriggerSimpleHapticEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_TriggerVibration");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_TriggerVibration");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_TriggerVibration' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInput_TriggerVibrationExtended");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInput_TriggerVibrationExtended");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInput_TriggerVibrationExtended' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_AddPromoItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_AddPromoItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_AddPromoItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_AddPromoItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_AddPromoItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_AddPromoItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_CheckResultSteamID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_CheckResultSteamID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_CheckResultSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_ConsumeItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_ConsumeItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_ConsumeItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_DeserializeResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_DeserializeResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_DeserializeResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_DestroyResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_DestroyResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_DestroyResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_ExchangeItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_ExchangeItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_ExchangeItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GenerateItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GenerateItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GenerateItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetAllItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetAllItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetAllItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetItemDefinitionIDs");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetItemDefinitionIDs");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetItemDefinitionIDs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetItemDefinitionProperty");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetItemDefinitionProperty");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetItemDefinitionProperty' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetItemPrice");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetItemPrice");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetItemPrice' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetItemsByID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetItemsByID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetItemsByID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetItemsWithPrices");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetItemsWithPrices");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetItemsWithPrices' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetNumItemsWithPrices");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetNumItemsWithPrices");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetNumItemsWithPrices' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetResultItemProperty");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetResultItemProperty");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetResultItemProperty' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetResultItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetResultItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetResultItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetResultStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetResultStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetResultStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GetResultTimestamp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GetResultTimestamp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GetResultTimestamp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_GrantPromoItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_GrantPromoItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_GrantPromoItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_InspectItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_InspectItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_InspectItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_LoadItemDefinitions");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_LoadItemDefinitions");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_LoadItemDefinitions' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_RemoveProperty");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_RemoveProperty");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_RemoveProperty' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_RequestPrices");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_RequestPrices");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_RequestPrices' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SendItemDropHeartbeat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SendItemDropHeartbeat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SendItemDropHeartbeat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SerializeResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SerializeResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SerializeResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetProperty");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetProperty");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetProperty' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetProperty0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetProperty0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetProperty0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetProperty1");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetProperty1");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetProperty1' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetProperty2");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetProperty2");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetProperty2' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetPropertyBool");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetPropertyBool");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetPropertyBool' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetPropertyFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetPropertyFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetPropertyFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetPropertyInt64");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetPropertyInt64");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetPropertyInt64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SetPropertyString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SetPropertyString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SetPropertyString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_StartPurchase");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_StartPurchase");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_StartPurchase' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_StartUpdateProperties");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_StartUpdateProperties");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_StartUpdateProperties' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_SubmitUpdateProperties");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_SubmitUpdateProperties");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_SubmitUpdateProperties' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_TradeItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_TradeItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_TradeItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_TransferItemQuantity");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_TransferItemQuantity");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_TransferItemQuantity' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamInventory_TriggerItemDrop");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamInventory_TriggerItemDrop");
        LOG_TRACE("{} -> 'SteamAPI_ISteamInventory_TriggerItemDrop' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingPingResponse_ServerResponded");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingPingResponse_ServerResponded");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingPingResponse_ServerResponded' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_CancelQuery");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_CancelQuery");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_CancelQuery' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_CancelServerQuery");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_CancelServerQuery");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_CancelServerQuery' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_GetServerCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_GetServerCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_GetServerCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_GetServerDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_GetServerDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_GetServerDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_IsRefreshing");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_IsRefreshing");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_IsRefreshing' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_PingServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_PingServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_PingServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_PlayerDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_PlayerDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_PlayerDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RefreshQuery");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RefreshQuery");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RefreshQuery' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RefreshServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RefreshServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RefreshServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_ReleaseRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_ReleaseRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_ReleaseRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestInternetServerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestInternetServerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RequestInternetServerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestLANServerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestLANServerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RequestLANServerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmakingServers_ServerRules");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmakingServers_ServerRules");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmakingServers_ServerRules' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddFavoriteGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddFavoriteGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddFavoriteGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_CreateLobby");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_CreateLobby");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_CreateLobby' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_DeleteLobbyData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_DeleteLobbyData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_DeleteLobbyData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetFavoriteGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetFavoriteGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetFavoriteGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetFavoriteGameCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetFavoriteGameCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetFavoriteGameCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyChatEntry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyChatEntry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyChatEntry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyDataCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyDataCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyDataCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyGameServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyGameServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyMemberData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyMemberData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyMemberData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyOwner");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetLobbyOwner");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetLobbyOwner' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_GetNumLobbyMembers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_GetNumLobbyMembers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_GetNumLobbyMembers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_InviteUserToLobby");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_InviteUserToLobby");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_InviteUserToLobby' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_JoinLobby");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_JoinLobby");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_JoinLobby' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_LeaveLobby");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_LeaveLobby");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_LeaveLobby' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_RemoveFavoriteGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_RemoveFavoriteGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_RemoveFavoriteGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_RequestLobbyData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_RequestLobbyData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_RequestLobbyData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_RequestLobbyList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_RequestLobbyList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_RequestLobbyList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SendLobbyChatMsg");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SendLobbyChatMsg");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SendLobbyChatMsg' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLinkedLobby");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLinkedLobby");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLinkedLobby' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyGameServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyGameServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyJoinable");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyJoinable");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyJoinable' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyMemberData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyMemberData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyMemberData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyOwner");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyOwner");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyOwner' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyType");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMatchmaking_SetLobbyType");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMatchmaking_SetLobbyType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_BActivationSuccess");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_BActivationSuccess");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_BActivationSuccess' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_CurrentEntryDidChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_CurrentEntryDidChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_CurrentEntryDidChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_CurrentEntryWillChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_CurrentEntryWillChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_CurrentEntryWillChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_EnableLooped");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_EnableLooped");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_EnableLooped' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_EnablePlayNext");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_EnablePlayNext");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_EnablePlayNext' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_EnablePlayPrevious");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_EnablePlayPrevious");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_EnablePlayPrevious' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_EnablePlaylists");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_EnablePlaylists");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_EnablePlaylists' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_EnableQueue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_EnableQueue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_EnableQueue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_EnableShuffled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_EnableShuffled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_EnableShuffled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_PlaylistDidChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_PlaylistDidChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_PlaylistDidChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_PlaylistWillChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_PlaylistWillChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_PlaylistWillChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_QueueDidChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_QueueDidChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_QueueDidChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_QueueWillChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_QueueWillChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_QueueWillChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_ResetPlaylistEntries");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_ResetPlaylistEntries");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_ResetPlaylistEntries' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_ResetQueueEntries");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_ResetQueueEntries");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_ResetQueueEntries' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_SetDisplayName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_SetDisplayName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_SetDisplayName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_SetPlaylistEntry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_SetPlaylistEntry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_SetPlaylistEntry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_SetQueueEntry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_SetQueueEntry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_SetQueueEntry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateLooped");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateLooped");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdateLooped' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateShuffled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateShuffled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdateShuffled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateVolume");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusicRemote_UpdateVolume");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusicRemote_UpdateVolume' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_BIsEnabled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_BIsEnabled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_BIsEnabled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_BIsPlaying");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_BIsPlaying");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_BIsPlaying' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_GetPlaybackStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_GetPlaybackStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_GetPlaybackStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_GetVolume");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_GetVolume");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_GetVolume' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_Pause");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_Pause");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_Pause' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_Play");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_Play");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_Play' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_PlayNext");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_PlayNext");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_PlayNext' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_PlayPrevious");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_PlayPrevious");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_PlayPrevious' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamMusic_SetVolume");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamMusic_SetVolume");
        LOG_TRACE("{} -> 'SteamAPI_ISteamMusic_SetVolume' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingConnectionCustomSignaling_Release");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingConnectionCustomSignaling_Release");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingConnectionCustomSignaling_Release' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingConnectionCustomSignaling_SendSignal");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingConnectionCustomSignaling_SendSignal");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingConnectionCustomSignaling_SendSignal' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_OnConnectRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_OnConnectRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingCustomSignalingRecvContext_OnConnectRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingMessages_SendMessageToUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingMessages_SendMessageToUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingMessages_SendMessageToUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_AcceptConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_AcceptConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_AcceptConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CloseConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CloseConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CloseConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CloseListenSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CloseListenSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CloseListenSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectP2P");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectP2P");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ConnectP2P' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreatePollGroup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreatePollGroup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreatePollGroup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateSocketPair");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_CreateSocketPair");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_CreateSocketPair' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_DestroyPollGroup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_DestroyPollGroup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_DestroyPollGroup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetCertificateRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetCertificateRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetCertificateRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetConnectionInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetConnectionName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionUserData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetConnectionUserData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetConnectionUserData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetIdentity");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetIdentity");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetIdentity' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_InitAuthentication");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_InitAuthentication");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_InitAuthentication' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_ResetIdentity");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_ResetIdentity");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_ResetIdentity' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_RunCallbacks");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_RunCallbacks");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_RunCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_SendMessageToConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_SendMessageToConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_SendMessageToConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_SendMessages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_SendMessages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_SendMessages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetCertificate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetCertificate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_SetCertificate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetConnectionName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetConnectionName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_SetConnectionName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetConnectionUserData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingSockets_SetConnectionUserData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingSockets_SetConnectionUserData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_AllocateMessage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_AllocateMessage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_AllocateMessage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetConfigValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetConfigValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetConfigValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetPOPCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetPOPCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetPOPCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetPOPList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetPOPList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetPOPList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_IsFakeIPv4");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_IsFakeIPv4");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_IsFakeIPv4' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_ParsePingLocationString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_ParsePingLocationString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_ParsePingLocationString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConfigValue");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConfigValue");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetConfigValue' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValuePtr");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValuePtr");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValuePtr' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_AllowP2PPacketRelay");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_AllowP2PPacketRelay");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_AllowP2PPacketRelay' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_CloseP2PChannelWithUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_CloseP2PChannelWithUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_CloseP2PChannelWithUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_CloseP2PSessionWithUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_CloseP2PSessionWithUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_CloseP2PSessionWithUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_CreateConnectionSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_CreateConnectionSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_CreateConnectionSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_CreateListenSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_CreateListenSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_CreateListenSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_CreateP2PConnectionSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_CreateP2PConnectionSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_CreateP2PConnectionSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_DestroyListenSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_DestroyListenSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_DestroyListenSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_DestroySocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_DestroySocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_DestroySocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_GetListenSocketInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_GetListenSocketInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_GetListenSocketInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_GetMaxPacketSize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_GetMaxPacketSize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_GetMaxPacketSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_GetP2PSessionState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_GetP2PSessionState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_GetP2PSessionState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_GetSocketConnectionType");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_GetSocketConnectionType");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_GetSocketConnectionType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_GetSocketInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_GetSocketInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_GetSocketInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_IsDataAvailable");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_IsDataAvailable");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_IsDataAvailable' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_IsDataAvailableOnSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_IsDataAvailableOnSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_IsDataAvailableOnSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_IsP2PPacketAvailable");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_IsP2PPacketAvailable");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_IsP2PPacketAvailable' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_ReadP2PPacket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_ReadP2PPacket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_ReadP2PPacket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_RetrieveData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_RetrieveData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_RetrieveData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_RetrieveDataFromSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_RetrieveDataFromSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_RetrieveDataFromSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_SendDataOnSocket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_SendDataOnSocket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_SendDataOnSocket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamNetworking_SendP2PPacket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamNetworking_SendP2PPacket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamNetworking_SendP2PPacket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParentalSettings_BIsAppBlocked");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParentalSettings_BIsAppBlocked");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParentalSettings_BIsAppBlocked' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParentalSettings_BIsAppInBlockList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParentalSettings_BIsAppInBlockList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParentalSettings_BIsAppInBlockList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParentalSettings_BIsFeatureBlocked");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParentalSettings_BIsFeatureBlocked");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParentalSettings_BIsFeatureBlocked' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParentalSettings_BIsParentalLockLocked");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParentalSettings_BIsParentalLockLocked");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParentalSettings_BIsParentalLockLocked' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_CancelReservation");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_CancelReservation");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_CancelReservation' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_ChangeNumOpenSlots");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_ChangeNumOpenSlots");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_ChangeNumOpenSlots' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_CreateBeacon");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_CreateBeacon");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_CreateBeacon' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_DestroyBeacon");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_DestroyBeacon");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_DestroyBeacon' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_GetAvailableBeaconLocations");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_GetAvailableBeaconLocations");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_GetAvailableBeaconLocations' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_GetBeaconByIndex");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_GetBeaconByIndex");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_GetBeaconByIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_GetBeaconDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_GetBeaconDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_GetBeaconDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_GetBeaconLocationData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_GetBeaconLocationData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_GetBeaconLocationData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_GetNumActiveBeacons");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_GetNumActiveBeacons");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_GetNumActiveBeacons' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_GetNumAvailableBeaconLocations");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_GetNumAvailableBeaconLocations");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_GetNumAvailableBeaconLocations' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_JoinParty");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_JoinParty");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_JoinParty' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamParties_OnReservationCompleted");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamParties_OnReservationCompleted");
        LOG_TRACE("{} -> 'SteamAPI_ISteamParties_OnReservationCompleted' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_BGetSessionClientResolution");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_BGetSessionClientResolution");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_BGetSessionClientResolution' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_CreateMouseCursor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_CreateMouseCursor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_CreateMouseCursor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_GetInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_GetInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_GetInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionClientName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionClientName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_GetSessionClientName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_GetSessionCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_GetSessionID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionSteamID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_GetSessionSteamID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_GetSessionSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_SetMouseCursor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_SetMouseCursor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_SetMouseCursor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_SetMousePosition");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_SetMousePosition");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_SetMousePosition' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_SetMouseVisibility");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_SetMouseVisibility");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_SetMouseVisibility' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_CommitPublishedFileUpdate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_CommitPublishedFileUpdate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_CommitPublishedFileUpdate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_CreatePublishedFileUpdateRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_CreatePublishedFileUpdateRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_CreatePublishedFileUpdateRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_DeletePublishedFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_DeletePublishedFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_DeletePublishedFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_EndFileWriteBatch");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_EndFileWriteBatch");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_EndFileWriteBatch' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumeratePublishedFilesByUserAction");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumeratePublishedFilesByUserAction");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_EnumeratePublishedFilesByUserAction' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumeratePublishedWorkshopFiles");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumeratePublishedWorkshopFiles");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_EnumeratePublishedWorkshopFiles' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumerateUserPublishedFiles");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumerateUserPublishedFiles");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_EnumerateUserPublishedFiles' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumerateUserSharedWorkshopFiles");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumerateUserSharedWorkshopFiles");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_EnumerateUserSharedWorkshopFiles' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumerateUserSubscribedFiles");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_EnumerateUserSubscribedFiles");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_EnumerateUserSubscribedFiles' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileDelete");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileDelete");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileDelete' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileExists");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileExists");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileExists' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileForget");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileForget");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileForget' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FilePersisted");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FilePersisted");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FilePersisted' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileRead");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileRead");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileRead' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileReadAsync");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileReadAsync");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileReadAsync' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileShare");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileShare");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileShare' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWrite");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWrite");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileWrite' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteAsync");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteAsync");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileWriteAsync' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamClose");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamClose");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileWriteStreamClose' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetCachedUGCCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetCachedUGCCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetCachedUGCCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetFileCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileNameAndSize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileNameAndSize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetFileNameAndSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileSize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileSize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetFileSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileTimestamp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetFileTimestamp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetFileTimestamp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetLocalFileChange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetLocalFileChange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetLocalFileChange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetLocalFileChangeCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetLocalFileChangeCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetLocalFileChangeCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetPublishedFileDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetPublishedFileDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetPublishedFileDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetPublishedItemVoteDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetPublishedItemVoteDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetPublishedItemVoteDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetQuota");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetQuota");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetQuota' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetSyncPlatforms");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetSyncPlatforms");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetSyncPlatforms' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetUGCDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetUGCDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetUGCDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_GetUserPublishedItemVoteDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_GetUserPublishedItemVoteDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_GetUserPublishedItemVoteDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_PublishVideo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_PublishVideo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_PublishVideo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_PublishWorkshopFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_PublishWorkshopFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_PublishWorkshopFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_SetSyncPlatforms");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_SetSyncPlatforms");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_SetSyncPlatforms' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_SetUserPublishedFileAction");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_SetUserPublishedFileAction");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_SetUserPublishedFileAction' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_SubscribePublishedFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_SubscribePublishedFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_SubscribePublishedFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UGCDownload");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UGCDownload");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UGCDownload' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UGCRead");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UGCRead");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UGCRead' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UnsubscribePublishedFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UnsubscribePublishedFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UnsubscribePublishedFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFileDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFileFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFilePreviewFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFilePreviewFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFilePreviewFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTitle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTitle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTitle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileVisibility");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdatePublishedFileVisibility");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdatePublishedFileVisibility' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdateUserPublishedItemVote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamRemoteStorage_UpdateUserPublishedItemVote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamRemoteStorage_UpdateUserPublishedItemVote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_AddScreenshotToLibrary");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_AddScreenshotToLibrary");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_AddScreenshotToLibrary' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_HookScreenshots");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_HookScreenshots");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_HookScreenshots' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_IsScreenshotsHooked");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_IsScreenshotsHooked");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_IsScreenshotsHooked' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_SetLocation");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_SetLocation");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_SetLocation' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_TagPublishedFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_TagPublishedFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_TagPublishedFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_TagUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_TagUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_TagUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_TriggerScreenshot");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_TriggerScreenshot");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_TriggerScreenshot' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamScreenshots_WriteScreenshot");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamScreenshots_WriteScreenshot");
        LOG_TRACE("{} -> 'SteamAPI_ISteamScreenshots_WriteScreenshot' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_AddBroadcastGameData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_AddBroadcastGameData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_AddBroadcastGameData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_AddRegion");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_AddRegion");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_AddRegion' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_AddTimelineMarker");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_AddTimelineMarker");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_AddTimelineMarker' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_IsBroadcasting");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_IsBroadcasting");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_IsBroadcasting' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_RemoveBroadcastGameData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_RemoveBroadcastGameData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_RemoveBroadcastGameData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_RemoveRegion");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_RemoveRegion");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_RemoveRegion' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTV_RemoveTimelineMarker");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTV_RemoveTimelineMarker");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTV_RemoveTimelineMarker' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_AddGamePhaseTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_AddGamePhaseTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_AddGamePhaseTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_AddRangeTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_AddRangeTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_AddRangeTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_AddTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_AddTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_AddTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_ClearTimelineStateDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_ClearTimelineStateDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_ClearTimelineStateDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_ClearTimelineTooltip");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_ClearTimelineTooltip");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_ClearTimelineTooltip' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_DoesEventRecordingExist");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_DoesEventRecordingExist");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_DoesEventRecordingExist' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_EndGamePhase");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_EndGamePhase");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_EndGamePhase' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_EndRangeTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_EndRangeTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_EndRangeTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_OpenOverlayToGamePhase");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_OpenOverlayToGamePhase");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_OpenOverlayToGamePhase' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_RemoveTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_RemoveTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_RemoveTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_SetGamePhaseAttribute");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_SetGamePhaseAttribute");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_SetGamePhaseAttribute' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_SetGamePhaseID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_SetGamePhaseID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_SetGamePhaseID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_SetTimelineGameMode");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_SetTimelineGameMode");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_SetTimelineGameMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_SetTimelineStateDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_SetTimelineStateDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_SetTimelineStateDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_SetTimelineTooltip");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_SetTimelineTooltip");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_SetTimelineTooltip' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_StartGamePhase");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_StartGamePhase");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_StartGamePhase' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_StartRangeTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_StartRangeTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_StartRangeTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddAppDependency");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddAppDependency");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddAppDependency' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddContentDescriptor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddContentDescriptor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddContentDescriptor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddDependency");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddDependency");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddDependency' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddExcludedTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddExcludedTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddExcludedTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddItemKeyValueTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddItemKeyValueTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddItemKeyValueTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddItemPreviewFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddItemPreviewFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddItemPreviewFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddItemPreviewVideo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddItemPreviewVideo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddItemPreviewVideo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddItemToFavorites");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddItemToFavorites");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddItemToFavorites' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddRequiredKeyValueTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddRequiredKeyValueTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddRequiredKeyValueTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddRequiredTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddRequiredTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddRequiredTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_AddRequiredTagGroup");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_AddRequiredTagGroup");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_AddRequiredTagGroup' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_BInitWorkshopForGameServer");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_BInitWorkshopForGameServer");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_BInitWorkshopForGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateQueryAllUGCRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateQueryAllUGCRequest0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_CreateQueryUserUGCRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_CreateQueryUserUGCRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_CreateQueryUserUGCRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_DeleteItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_DeleteItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_DeleteItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_DownloadItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_DownloadItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_DownloadItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetAppDependencies");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetAppDependencies");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetAppDependencies' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetItemDownloadInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetItemDownloadInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetItemDownloadInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetItemInstallInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetItemInstallInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetItemInstallInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetItemState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetItemState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetItemState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetItemUpdateProgress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetItemUpdateProgress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetItemUpdateProgress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetNumSubscribedItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetNumSubscribedItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetNumSubscribedItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetNumSupportedGameVersions");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetNumSupportedGameVersions");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetNumSupportedGameVersions' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCChildren");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCChildren");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCChildren' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCMetadata");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCMetadata");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCMetadata' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCNumTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCNumTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCNumTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCPreviewURL");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCPreviewURL");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCPreviewURL' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCStatistic");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCStatistic");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCStatistic' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetSubscribedItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetSubscribedItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetSubscribedItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetSupportedGameVersionData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetSupportedGameVersionData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetSupportedGameVersionData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetUserItemVote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetUserItemVote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetUserItemVote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_GetWorkshopEULAStatus");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_GetWorkshopEULAStatus");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_GetWorkshopEULAStatus' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_ReleaseQueryUGCRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_ReleaseQueryUGCRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_ReleaseQueryUGCRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveAppDependency");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveAppDependency");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveAppDependency' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveContentDescriptor");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveContentDescriptor");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveContentDescriptor' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveDependency");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveDependency");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveDependency' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveItemFromFavorites");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveItemFromFavorites");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveItemFromFavorites' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveItemKeyValueTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveItemKeyValueTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveItemKeyValueTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RemoveItemPreview");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RemoveItemPreview");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RemoveItemPreview' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_RequestUGCDetails");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_RequestUGCDetails");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_RequestUGCDetails' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SendQueryUGCRequest");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SendQueryUGCRequest");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SendQueryUGCRequest' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetAdminQuery");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetAdminQuery");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetAdminQuery' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetAllowCachedResponse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetAllowCachedResponse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetAllowCachedResponse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetAllowLegacyUpload");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetAllowLegacyUpload");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetAllowLegacyUpload' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetCloudFileNameFilter");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetCloudFileNameFilter");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetCloudFileNameFilter' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemContent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemContent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemContent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemMetadata");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemMetadata");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemMetadata' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemPreview");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemPreview");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemPreview' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemTitle");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemTitle");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemTitle' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemUpdateLanguage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemUpdateLanguage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemUpdateLanguage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemVisibility");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemVisibility");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemVisibility' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetItemsDisabledLocally");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetItemsDisabledLocally");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetItemsDisabledLocally' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetLanguage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetLanguage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetLanguage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetMatchAnyTag");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetMatchAnyTag");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetMatchAnyTag' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetRankedByTrendDays");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetRankedByTrendDays");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetRankedByTrendDays' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetRequiredGameVersions");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetRequiredGameVersions");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetRequiredGameVersions' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnAdditionalPreviews");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnAdditionalPreviews");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnAdditionalPreviews' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnChildren");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnChildren");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnChildren' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnKeyValueTags");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnKeyValueTags");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnKeyValueTags' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnLongDescription");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnLongDescription");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnLongDescription' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnMetadata");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnMetadata");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnMetadata' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnOnlyIDs");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnOnlyIDs");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnOnlyIDs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnPlaytimeStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnPlaytimeStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnPlaytimeStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetReturnTotalOnly");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetReturnTotalOnly");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetReturnTotalOnly' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetSearchText");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetSearchText");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetSearchText' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetTimeCreatedDateRange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetTimeCreatedDateRange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetTimeCreatedDateRange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetTimeUpdatedDateRange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetTimeUpdatedDateRange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetTimeUpdatedDateRange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SetUserItemVote");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SetUserItemVote");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SetUserItemVote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_ShowWorkshopEULA");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_ShowWorkshopEULA");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_ShowWorkshopEULA' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_StartItemUpdate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_StartItemUpdate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_StartItemUpdate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_StartPlaytimeTracking");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_StartPlaytimeTracking");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_StartPlaytimeTracking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_StopPlaytimeTracking");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_StopPlaytimeTracking");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_StopPlaytimeTracking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SubmitItemUpdate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SubmitItemUpdate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SubmitItemUpdate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SubscribeItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SubscribeItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SubscribeItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_SuspendDownloads");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_SuspendDownloads");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_SuspendDownloads' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_UnsubscribeItem");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_UnsubscribeItem");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_UnsubscribeItem' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_UpdateItemPreviewFile");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_UpdateItemPreviewFile");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_UpdateItemPreviewFile' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUGC_UpdateItemPreviewVideo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUGC_UpdateItemPreviewVideo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUGC_UpdateItemPreviewVideo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUnifiedMessages_GetMethodResponseData");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUnifiedMessages_GetMethodResponseData");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUnifiedMessages_GetMethodResponseData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUnifiedMessages_GetMethodResponseInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUnifiedMessages_GetMethodResponseInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUnifiedMessages_GetMethodResponseInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUnifiedMessages_ReleaseMethod");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUnifiedMessages_ReleaseMethod");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUnifiedMessages_ReleaseMethod' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUnifiedMessages_SendMethod");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUnifiedMessages_SendMethod");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUnifiedMessages_SendMethod' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUnifiedMessages_SendNotification");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUnifiedMessages_SendNotification");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUnifiedMessages_SendNotification' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_AttachLeaderboardUGC");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_AttachLeaderboardUGC");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_AttachLeaderboardUGC' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_ClearAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_ClearAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_ClearAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_DownloadLeaderboardEntries");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_DownloadLeaderboardEntries");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_DownloadLeaderboardEntries' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_FindLeaderboard");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_FindLeaderboard");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_FindLeaderboard' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_FindOrCreateLeaderboard");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_FindOrCreateLeaderboard");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_FindOrCreateLeaderboard' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementAchievedPercent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementAchievedPercent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementAchievedPercent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementIcon");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementIcon");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementIcon' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStat0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStat0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStat0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatDouble");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatDouble");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStatDouble' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistory");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistory");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStatHistory' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistory0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistory0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStatHistory0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatInt64");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetGlobalStatInt64");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetGlobalStatInt64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardDisplayType");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardDisplayType");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetLeaderboardDisplayType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardEntryCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardEntryCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetLeaderboardEntryCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardName");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardName");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetLeaderboardName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardSortMethod");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetLeaderboardSortMethod");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetLeaderboardSortMethod' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetNumAchievements");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetNumAchievements");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetNumAchievements' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetStat0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetStat0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetStat0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetStatFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetStatFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetStatFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetStatInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetStatInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetStatInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetUserAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetUserAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetUserAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetUserStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetUserStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetUserStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetUserStat0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetUserStat0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetUserStat0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetUserStatFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetUserStatFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetUserStatFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_GetUserStatInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_GetUserStatInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_GetUserStatInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_IndicateAchievementProgress");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_IndicateAchievementProgress");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_IndicateAchievementProgress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_RequestCurrentStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_RequestCurrentStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_RequestCurrentStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_RequestGlobalStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_RequestGlobalStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_RequestGlobalStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_RequestUserStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_RequestUserStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_RequestUserStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_ResetAllStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_ResetAllStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_ResetAllStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_SetAchievement");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_SetAchievement");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_SetAchievement' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_SetStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_SetStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_SetStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_SetStat0");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_SetStat0");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_SetStat0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_SetStatFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_SetStatFloat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_SetStatFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_SetStatInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_SetStatInt32");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_SetStatInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_StoreStats");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_StoreStats");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_StoreStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_UpdateAvgRateStat");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_UpdateAvgRateStat");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_UpdateAvgRateStat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUserStats_UploadLeaderboardScore");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUserStats_UploadLeaderboardScore");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUserStats_UploadLeaderboardScore' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_AdvertiseGame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_AdvertiseGame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_AdvertiseGame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BIsBehindNAT");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BIsBehindNAT");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BIsBehindNAT' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BIsPhoneIdentifying");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BIsPhoneIdentifying");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BIsPhoneIdentifying' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BIsPhoneRequiringVerification");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BIsPhoneRequiringVerification");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BIsPhoneRequiringVerification' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BIsPhoneVerified");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BIsPhoneVerified");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BIsPhoneVerified' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BIsTwoFactorEnabled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BIsTwoFactorEnabled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BIsTwoFactorEnabled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BLoggedOn");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BLoggedOn");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BLoggedOn' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BSetDurationControlOnlineState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BSetDurationControlOnlineState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BSetDurationControlOnlineState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_BeginAuthSession");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_BeginAuthSession");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_BeginAuthSession' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_CancelAuthTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_CancelAuthTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_CancelAuthTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_DecompressVoice");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_DecompressVoice");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_DecompressVoice' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_EndAuthSession");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_EndAuthSession");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_EndAuthSession' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetAuthSessionTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetAuthSessionTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetAuthSessionTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetAuthTicketForWebApi");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetAuthTicketForWebApi");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetAuthTicketForWebApi' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetAvailableVoice");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetAvailableVoice");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetAvailableVoice' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetDurationControl");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetDurationControl");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetDurationControl' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetEncryptedAppTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetEncryptedAppTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetEncryptedAppTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetGameBadgeLevel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetGameBadgeLevel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetGameBadgeLevel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetHSteamUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetHSteamUser");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetHSteamUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetMarketEligibility");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetMarketEligibility");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetMarketEligibility' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetPlayerSteamLevel");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetPlayerSteamLevel");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetPlayerSteamLevel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetSteamID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetSteamID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetUserDataFolder");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetUserDataFolder");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetUserDataFolder' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetVoice");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetVoice");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetVoice' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_GetVoiceOptimalSampleRate");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_GetVoiceOptimalSampleRate");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_GetVoiceOptimalSampleRate' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_InitiateGameConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_InitiateGameConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_InitiateGameConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_InitiateGameConnection_DEPRECATED");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_InitiateGameConnection_DEPRECATED");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_InitiateGameConnection_DEPRECATED' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_RequestEncryptedAppTicket");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_RequestEncryptedAppTicket");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_RequestEncryptedAppTicket' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_RequestStoreAuthURL");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_RequestStoreAuthURL");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_RequestStoreAuthURL' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_StartVoiceRecording");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_StartVoiceRecording");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_StartVoiceRecording' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_StopVoiceRecording");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_StopVoiceRecording");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_StopVoiceRecording' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_TerminateGameConnection");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_TerminateGameConnection");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_TerminateGameConnection' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_TerminateGameConnection_DEPRECATED");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_TerminateGameConnection_DEPRECATED");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_TerminateGameConnection_DEPRECATED' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_TrackAppUsageEvent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_TrackAppUsageEvent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_TrackAppUsageEvent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUser_UserHasLicenseForApp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUser_UserHasLicenseForApp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUser_UserHasLicenseForApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_BOverlayNeedsPresent");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_BOverlayNeedsPresent");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_BOverlayNeedsPresent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_CheckFileSignature");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_CheckFileSignature");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_CheckFileSignature' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_DismissGamepadTextInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_DismissGamepadTextInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_DismissGamepadTextInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_FilterText");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_FilterText");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_FilterText' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetAPICallFailureReason");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetAPICallFailureReason");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetAPICallFailureReason' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetAPICallResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetAPICallResult");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetAPICallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetAppID");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetAppID");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetAppID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetCSERIPPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetCSERIPPort");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetCSERIPPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetConnectedUniverse");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetConnectedUniverse");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetConnectedUniverse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetCurrentBatteryPower");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetCurrentBatteryPower");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetCurrentBatteryPower' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetEnteredGamepadTextInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetEnteredGamepadTextInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetEnteredGamepadTextInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetEnteredGamepadTextLength");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetEnteredGamepadTextLength");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetEnteredGamepadTextLength' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetIPCCallCount");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetIPCCallCount");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetIPCCallCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetIPCountry");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetIPCountry");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetIPCountry' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetIPv6ConnectivityState");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetIPv6ConnectivityState");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetIPv6ConnectivityState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetImageRGBA");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetImageRGBA");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetImageRGBA' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetImageSize");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetImageSize");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetImageSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetSecondsSinceAppActive");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetSecondsSinceAppActive");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetSecondsSinceAppActive' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetSecondsSinceComputerActive");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetSecondsSinceComputerActive");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetSecondsSinceComputerActive' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetServerRealTime");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetServerRealTime");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetServerRealTime' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_GetSteamUILanguage");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_GetSteamUILanguage");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_GetSteamUILanguage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_InitFilterText");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_InitFilterText");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_InitFilterText' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsAPICallCompleted");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsAPICallCompleted");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsAPICallCompleted' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsOverlayEnabled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsOverlayEnabled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsOverlayEnabled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsSteamChinaLauncher");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsSteamChinaLauncher");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsSteamChinaLauncher' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsSteamInBigPictureMode");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsSteamInBigPictureMode");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsSteamInBigPictureMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsSteamRunningInVR");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsSteamRunningInVR");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsSteamRunningInVR' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_RunFrame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_RunFrame");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_RunFrame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_SetGameLauncherMode");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_SetGameLauncherMode");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_SetGameLauncherMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_SetOverlayNotificationInset");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_SetOverlayNotificationInset");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_SetOverlayNotificationInset' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_SetOverlayNotificationPosition");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_SetOverlayNotificationPosition");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_SetOverlayNotificationPosition' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_SetWarningMessageHook");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_SetWarningMessageHook");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_SetWarningMessageHook' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_ShowGamepadTextInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_ShowGamepadTextInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_ShowGamepadTextInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_ShowModalGamepadTextInput");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_ShowModalGamepadTextInput");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_ShowModalGamepadTextInput' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamUtils_StartVRDashboard");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamUtils_StartVRDashboard");
        LOG_TRACE("{} -> 'SteamAPI_ISteamUtils_StartVRDashboard' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_AddTimelineHighlightMarker");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_AddTimelineHighlightMarker");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_AddTimelineHighlightMarker' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_AddTimelineRange");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_AddTimelineRange");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_AddTimelineRange' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_AddTimelineRangeEnd");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_AddTimelineRangeEnd");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_AddTimelineRangeEnd' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_AddTimelineRangeStart");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_AddTimelineRangeStart");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_AddTimelineRangeStart' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_AddTimelineTimestamp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_AddTimelineTimestamp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_AddTimelineTimestamp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_GetOPFSettings");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_GetOPFSettings");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_GetOPFSettings' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_GetOPFStringForApp");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_GetOPFStringForApp");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_GetOPFStringForApp' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_GetVideoURL");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_GetVideoURL");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_GetVideoURL' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_IsBroadcasting");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_IsBroadcasting");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_IsBroadcasting' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ISteamVideo_SetTimelineGameMode");
        src_address = dlsym(original_lib_handle, "SteamAPI_ISteamVideo_SetTimelineGameMode");
        LOG_TRACE("{} -> 'SteamAPI_ISteamVideo_SetTimelineGameMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_Init");
        src_address = dlsym(original_lib_handle, "SteamAPI_Init");
        LOG_TRACE("{} -> 'SteamAPI_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_InitAnonymousUser");
        src_address = dlsym(original_lib_handle, "SteamAPI_InitAnonymousUser");
        LOG_TRACE("{} -> 'SteamAPI_InitAnonymousUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_InitFlat");
        src_address = dlsym(original_lib_handle, "SteamAPI_InitFlat");
        LOG_TRACE("{} -> 'SteamAPI_InitFlat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_InitSafe");
        src_address = dlsym(original_lib_handle, "SteamAPI_InitSafe");
        LOG_TRACE("{} -> 'SteamAPI_InitSafe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_IsSteamRunning");
        src_address = dlsym(original_lib_handle, "SteamAPI_IsSteamRunning");
        LOG_TRACE("{} -> 'SteamAPI_IsSteamRunning' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ManualDispatch_FreeLastCallback");
        src_address = dlsym(original_lib_handle, "SteamAPI_ManualDispatch_FreeLastCallback");
        LOG_TRACE("{} -> 'SteamAPI_ManualDispatch_FreeLastCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ManualDispatch_GetAPICallResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_ManualDispatch_GetAPICallResult");
        LOG_TRACE("{} -> 'SteamAPI_ManualDispatch_GetAPICallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ManualDispatch_GetNextCallback");
        src_address = dlsym(original_lib_handle, "SteamAPI_ManualDispatch_GetNextCallback");
        LOG_TRACE("{} -> 'SteamAPI_ManualDispatch_GetNextCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ManualDispatch_Init");
        src_address = dlsym(original_lib_handle, "SteamAPI_ManualDispatch_Init");
        LOG_TRACE("{} -> 'SteamAPI_ManualDispatch_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ManualDispatch_RunFrame");
        src_address = dlsym(original_lib_handle, "SteamAPI_ManualDispatch_RunFrame");
        LOG_TRACE("{} -> 'SteamAPI_ManualDispatch_RunFrame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_MatchMakingKeyValuePair_t_Construct");
        src_address = dlsym(original_lib_handle, "SteamAPI_MatchMakingKeyValuePair_t_Construct");
        LOG_TRACE("{} -> 'SteamAPI_MatchMakingKeyValuePair_t_Construct' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_RegisterCallResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_RegisterCallResult");
        LOG_TRACE("{} -> 'SteamAPI_RegisterCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_RegisterCallback");
        src_address = dlsym(original_lib_handle, "SteamAPI_RegisterCallback");
        LOG_TRACE("{} -> 'SteamAPI_RegisterCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_ReleaseCurrentThreadMemory");
        src_address = dlsym(original_lib_handle, "SteamAPI_ReleaseCurrentThreadMemory");
        LOG_TRACE("{} -> 'SteamAPI_ReleaseCurrentThreadMemory' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_RestartAppIfNecessary");
        src_address = dlsym(original_lib_handle, "SteamAPI_RestartAppIfNecessary");
        LOG_TRACE("{} -> 'SteamAPI_RestartAppIfNecessary' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_RunCallbacks");
        src_address = dlsym(original_lib_handle, "SteamAPI_RunCallbacks");
        LOG_TRACE("{} -> 'SteamAPI_RunCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SetBreakpadAppID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SetBreakpadAppID");
        LOG_TRACE("{} -> 'SteamAPI_SetBreakpadAppID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SetMiniDumpComment");
        src_address = dlsym(original_lib_handle, "SteamAPI_SetMiniDumpComment");
        LOG_TRACE("{} -> 'SteamAPI_SetMiniDumpComment' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SetTryCatchCallbacks");
        src_address = dlsym(original_lib_handle, "SteamAPI_SetTryCatchCallbacks");
        LOG_TRACE("{} -> 'SteamAPI_SetTryCatchCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamAPI_Shutdown");
        LOG_TRACE("{} -> 'SteamAPI_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamAppList_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamAppList_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamAppList_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamApps_v008");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamApps_v008");
        LOG_TRACE("{} -> 'SteamAPI_SteamApps_v008' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamController_v007");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamController_v007");
        LOG_TRACE("{} -> 'SteamAPI_SteamController_v007' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamController_v008");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamController_v008");
        LOG_TRACE("{} -> 'SteamAPI_SteamController_v008' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamDatagramHostedAddress_Clear");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamDatagramHostedAddress_Clear");
        LOG_TRACE("{} -> 'SteamAPI_SteamDatagramHostedAddress_Clear' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamDatagramHostedAddress_GetPopID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamDatagramHostedAddress_GetPopID");
        LOG_TRACE("{} -> 'SteamAPI_SteamDatagramHostedAddress_GetPopID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamDatagramHostedAddress_SetDevAddress");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamDatagramHostedAddress_SetDevAddress");
        LOG_TRACE("{} -> 'SteamAPI_SteamDatagramHostedAddress_SetDevAddress' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamFriends_v017");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamFriends_v017");
        LOG_TRACE("{} -> 'SteamAPI_SteamFriends_v017' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamFriends_v018");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamFriends_v018");
        LOG_TRACE("{} -> 'SteamAPI_SteamFriends_v018' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameSearch_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameSearch_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameSearch_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerApps_v008");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerApps_v008");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerApps_v008' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerHTTP_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerHTTP_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerHTTP_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerInventory_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerInventory_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerInventory_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingMessages_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingMessages_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingMessages_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v011");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v011");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v011' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_v008");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_v008");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingSockets_v008' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworkingSockets_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworkingSockets_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerNetworking_v006");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerNetworking_v006");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerNetworking_v006' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerStats_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerStats_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerStats_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v014");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v014");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v014' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v015");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v015");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v015' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v016");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v016");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v016' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v017");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v017");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v017' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v018");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v018");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v018' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v020");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v020");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v020' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUGC_v021");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUGC_v021");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUGC_v021' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUtils_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUtils_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUtils_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServerUtils_v010");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServerUtils_v010");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServerUtils_v010' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServer_v013");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServer_v013");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServer_v013' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServer_v014");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServer_v014");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServer_v014' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamGameServer_v015");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamGameServer_v015");
        LOG_TRACE("{} -> 'SteamAPI_SteamGameServer_v015' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamHTMLSurface_v005");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamHTMLSurface_v005");
        LOG_TRACE("{} -> 'SteamAPI_SteamHTMLSurface_v005' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamHTTP_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamHTTP_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamHTTP_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamIPAddress_t_IsSet");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamIPAddress_t_IsSet");
        LOG_TRACE("{} -> 'SteamAPI_SteamIPAddress_t_IsSet' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamInput_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamInput_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamInput_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamInput_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamInput_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamInput_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamInput_v005");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamInput_v005");
        LOG_TRACE("{} -> 'SteamAPI_SteamInput_v005' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamInput_v006");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamInput_v006");
        LOG_TRACE("{} -> 'SteamAPI_SteamInput_v006' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamInventory_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamInventory_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamInventory_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamMatchmakingServers_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamMatchmakingServers_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamMatchmakingServers_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamMatchmaking_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamMatchmaking_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamMatchmaking_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamMusicRemote_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamMusicRemote_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamMusicRemote_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamMusic_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamMusic_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamMusic_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetFloat");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetFloat");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingConfigValue_t_SetFloat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetInt32");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetInt32");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingConfigValue_t_SetInt32' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetInt64");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetInt64");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingConfigValue_t_SetInt64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetPtr");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetPtr");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingConfigValue_t_SetPtr' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingConfigValue_t_SetString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingConfigValue_t_SetString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddrRender_c_str");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddrRender_c_str");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddrRender_c_str' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_Clear");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_Clear");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_Clear' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_GetFakeIPType");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_GetFakeIPType");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_GetFakeIPType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_GetIPv4");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_GetIPv4");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_GetIPv4' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsEqualTo");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsEqualTo");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_IsEqualTo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_IsFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsIPv4");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsIPv4");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_IsIPv4' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsLocalHost");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_IsLocalHost");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_IsLocalHost' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_ParseString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_ParseString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_ParseString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_SetIPv4");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_SetIPv4");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_SetIPv4' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_SetIPv6");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_SetIPv6");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_SetIPv6' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIPAddr_ToString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIPAddr_ToString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIPAddr_ToString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentityRender_c_str");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentityRender_c_str");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentityRender_c_str' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_Clear");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_Clear");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_Clear' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetFakeIPType");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetFakeIPType");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetFakeIPType' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetGenericBytes");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetGenericBytes");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetGenericBytes' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetGenericString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetGenericString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetGenericString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetIPAddr");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetIPAddr");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetIPAddr' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetIPv4");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetIPv4");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetIPv4' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetPSNID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetPSNID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetPSNID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetStadiaID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetStadiaID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetStadiaID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetSteamID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetSteamID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetSteamID64");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetSteamID64");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetSteamID64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsEqualTo");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsEqualTo");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_IsEqualTo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsFakeIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsFakeIP");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_IsFakeIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsInvalid");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsInvalid");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_IsInvalid' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsLocalHost");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_IsLocalHost");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_IsLocalHost' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_ParseString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_ParseString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_ParseString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetGenericBytes");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetGenericBytes");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetGenericBytes' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetGenericString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetGenericString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetGenericString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetIPAddr");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetIPAddr");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetIPAddr' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetIPv4Addr");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetIPv4Addr");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetIPv4Addr' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetLocalHost");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetLocalHost");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetLocalHost' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetPSNID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetPSNID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetPSNID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetStadiaID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetStadiaID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetStadiaID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetSteamID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetSteamID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetSteamID64");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetSteamID64");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetSteamID64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingIdentity_ToString");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingIdentity_ToString");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingIdentity_ToString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingMessage_t_Release");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingMessage_t_Release");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingMessage_t_Release' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingMessages_SteamAPI_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingMessages_SteamAPI_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingMessages_SteamAPI_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingMessages_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingMessages_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingMessages_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingPOPIDRender_c_str");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingPOPIDRender_c_str");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingPOPIDRender_c_str' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingSockets_SteamAPI_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingSockets_SteamAPI_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingSockets_SteamAPI_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingSockets_SteamAPI_v011");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingSockets_SteamAPI_v011");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingSockets_SteamAPI_v011' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingSockets_SteamAPI_v012");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingSockets_SteamAPI_v012");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingSockets_SteamAPI_v012' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingSockets_v008");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingSockets_v008");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingSockets_v008' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingSockets_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingSockets_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingSockets_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingUtils_SteamAPI_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingUtils_SteamAPI_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingUtils_SteamAPI_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingUtils_SteamAPI_v004");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingUtils_SteamAPI_v004");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingUtils_SteamAPI_v004' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworkingUtils_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworkingUtils_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworkingUtils_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamNetworking_v006");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamNetworking_v006");
        LOG_TRACE("{} -> 'SteamAPI_SteamNetworking_v006' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamParentalSettings_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamParentalSettings_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamParentalSettings_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamParties_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamParties_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamParties_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamRemotePlay_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamRemotePlay_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamRemotePlay_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamRemotePlay_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamRemotePlay_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamRemotePlay_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamRemotePlay_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamRemotePlay_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamRemotePlay_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamRemoteStorage_v014");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamRemoteStorage_v014");
        LOG_TRACE("{} -> 'SteamAPI_SteamRemoteStorage_v014' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamRemoteStorage_v016");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamRemoteStorage_v016");
        LOG_TRACE("{} -> 'SteamAPI_SteamRemoteStorage_v016' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamScreenshots_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamScreenshots_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamScreenshots_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamTV_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamTV_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamTV_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamTimeline_v001");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamTimeline_v001");
        LOG_TRACE("{} -> 'SteamAPI_SteamTimeline_v001' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamTimeline_v004");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamTimeline_v004");
        LOG_TRACE("{} -> 'SteamAPI_SteamTimeline_v004' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v014");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v014");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v014' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v015");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v015");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v015' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v016");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v016");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v016' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v017");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v017");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v017' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v018");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v018");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v018' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v020");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v020");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v020' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUGC_v021");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUGC_v021");
        LOG_TRACE("{} -> 'SteamAPI_SteamUGC_v021' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUserStats_v011");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUserStats_v011");
        LOG_TRACE("{} -> 'SteamAPI_SteamUserStats_v011' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUserStats_v012");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUserStats_v012");
        LOG_TRACE("{} -> 'SteamAPI_SteamUserStats_v012' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUserStats_v013");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUserStats_v013");
        LOG_TRACE("{} -> 'SteamAPI_SteamUserStats_v013' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUser_v020");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUser_v020");
        LOG_TRACE("{} -> 'SteamAPI_SteamUser_v020' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUser_v021");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUser_v021");
        LOG_TRACE("{} -> 'SteamAPI_SteamUser_v021' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUser_v022");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUser_v022");
        LOG_TRACE("{} -> 'SteamAPI_SteamUser_v022' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUser_v023");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUser_v023");
        LOG_TRACE("{} -> 'SteamAPI_SteamUser_v023' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUtils_v009");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUtils_v009");
        LOG_TRACE("{} -> 'SteamAPI_SteamUtils_v009' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamUtils_v010");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamUtils_v010");
        LOG_TRACE("{} -> 'SteamAPI_SteamUtils_v010' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamVideo_v002");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamVideo_v002");
        LOG_TRACE("{} -> 'SteamAPI_SteamVideo_v002' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamVideo_v003");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamVideo_v003");
        LOG_TRACE("{} -> 'SteamAPI_SteamVideo_v003' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamVideo_v004");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamVideo_v004");
        LOG_TRACE("{} -> 'SteamAPI_SteamVideo_v004' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_SteamVideo_v007");
        src_address = dlsym(original_lib_handle, "SteamAPI_SteamVideo_v007");
        LOG_TRACE("{} -> 'SteamAPI_SteamVideo_v007' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_UnregisterCallResult");
        src_address = dlsym(original_lib_handle, "SteamAPI_UnregisterCallResult");
        LOG_TRACE("{} -> 'SteamAPI_UnregisterCallResult' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_UnregisterCallback");
        src_address = dlsym(original_lib_handle, "SteamAPI_UnregisterCallback");
        LOG_TRACE("{} -> 'SteamAPI_UnregisterCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_UseBreakpadCrashHandler");
        src_address = dlsym(original_lib_handle, "SteamAPI_UseBreakpadCrashHandler");
        LOG_TRACE("{} -> 'SteamAPI_UseBreakpadCrashHandler' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_WriteMiniDump");
        src_address = dlsym(original_lib_handle, "SteamAPI_WriteMiniDump");
        LOG_TRACE("{} -> 'SteamAPI_WriteMiniDump' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_gameserveritem_t_Construct");
        src_address = dlsym(original_lib_handle, "SteamAPI_gameserveritem_t_Construct");
        LOG_TRACE("{} -> 'SteamAPI_gameserveritem_t_Construct' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_gameserveritem_t_GetName");
        src_address = dlsym(original_lib_handle, "SteamAPI_gameserveritem_t_GetName");
        LOG_TRACE("{} -> 'SteamAPI_gameserveritem_t_GetName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_gameserveritem_t_SetName");
        src_address = dlsym(original_lib_handle, "SteamAPI_gameserveritem_t_SetName");
        LOG_TRACE("{} -> 'SteamAPI_gameserveritem_t_SetName' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_Assign");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_Assign");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_Assign' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_Construct");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_Construct");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_Construct' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_GetConnectionAddressString");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_GetConnectionAddressString");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_GetConnectionAddressString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_GetConnectionPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_GetConnectionPort");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_GetConnectionPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_GetIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_GetIP");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_GetIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_GetQueryAddressString");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_GetQueryAddressString");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_GetQueryAddressString' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_GetQueryPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_GetQueryPort");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_GetQueryPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_Init");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_Init");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_IsLessThan");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_IsLessThan");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_IsLessThan' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_SetConnectionPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_SetConnectionPort");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_SetConnectionPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_SetIP");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_SetIP");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_SetIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAPI_servernetadr_t_SetQueryPort");
        src_address = dlsym(original_lib_handle, "SteamAPI_servernetadr_t_SetQueryPort");
        LOG_TRACE("{} -> 'SteamAPI_servernetadr_t_SetQueryPort' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamAppList");
        src_address = dlsym(original_lib_handle, "SteamAppList");
        LOG_TRACE("{} -> 'SteamAppList' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamApps");
        src_address = dlsym(original_lib_handle, "SteamApps");
        LOG_TRACE("{} -> 'SteamApps' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamClient");
        src_address = dlsym(original_lib_handle, "SteamClient");
        LOG_TRACE("{} -> 'SteamClient' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamContentServer");
        src_address = dlsym(original_lib_handle, "SteamContentServer");
        LOG_TRACE("{} -> 'SteamContentServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamContentServerUtils");
        src_address = dlsym(original_lib_handle, "SteamContentServerUtils");
        LOG_TRACE("{} -> 'SteamContentServerUtils' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamContentServer_Init");
        src_address = dlsym(original_lib_handle, "SteamContentServer_Init");
        LOG_TRACE("{} -> 'SteamContentServer_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamContentServer_RunCallbacks");
        src_address = dlsym(original_lib_handle, "SteamContentServer_RunCallbacks");
        LOG_TRACE("{} -> 'SteamContentServer_RunCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamContentServer_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamContentServer_Shutdown");
        LOG_TRACE("{} -> 'SteamContentServer_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamController");
        src_address = dlsym(original_lib_handle, "SteamController");
        LOG_TRACE("{} -> 'SteamController' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamController_GetControllerState");
        src_address = dlsym(original_lib_handle, "SteamController_GetControllerState");
        LOG_TRACE("{} -> 'SteamController_GetControllerState' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamController_Init");
        src_address = dlsym(original_lib_handle, "SteamController_Init");
        LOG_TRACE("{} -> 'SteamController_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamController_SetOverrideMode");
        src_address = dlsym(original_lib_handle, "SteamController_SetOverrideMode");
        LOG_TRACE("{} -> 'SteamController_SetOverrideMode' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamController_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamController_Shutdown");
        LOG_TRACE("{} -> 'SteamController_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamController_TriggerHapticPulse");
        src_address = dlsym(original_lib_handle, "SteamController_TriggerHapticPulse");
        LOG_TRACE("{} -> 'SteamController_TriggerHapticPulse' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamFriends");
        src_address = dlsym(original_lib_handle, "SteamFriends");
        LOG_TRACE("{} -> 'SteamFriends' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer");
        src_address = dlsym(original_lib_handle, "SteamGameServer");
        LOG_TRACE("{} -> 'SteamGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerApps");
        src_address = dlsym(original_lib_handle, "SteamGameServerApps");
        LOG_TRACE("{} -> 'SteamGameServerApps' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerHTTP");
        src_address = dlsym(original_lib_handle, "SteamGameServerHTTP");
        LOG_TRACE("{} -> 'SteamGameServerHTTP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerInventory");
        src_address = dlsym(original_lib_handle, "SteamGameServerInventory");
        LOG_TRACE("{} -> 'SteamGameServerInventory' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerNetworking");
        src_address = dlsym(original_lib_handle, "SteamGameServerNetworking");
        LOG_TRACE("{} -> 'SteamGameServerNetworking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerStats");
        src_address = dlsym(original_lib_handle, "SteamGameServerStats");
        LOG_TRACE("{} -> 'SteamGameServerStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerUGC");
        src_address = dlsym(original_lib_handle, "SteamGameServerUGC");
        LOG_TRACE("{} -> 'SteamGameServerUGC' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServerUtils");
        src_address = dlsym(original_lib_handle, "SteamGameServerUtils");
        LOG_TRACE("{} -> 'SteamGameServerUtils' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_BSecure");
        src_address = dlsym(original_lib_handle, "SteamGameServer_BSecure");
        LOG_TRACE("{} -> 'SteamGameServer_BSecure' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_GetHSteamPipe");
        src_address = dlsym(original_lib_handle, "SteamGameServer_GetHSteamPipe");
        LOG_TRACE("{} -> 'SteamGameServer_GetHSteamPipe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_GetHSteamUser");
        src_address = dlsym(original_lib_handle, "SteamGameServer_GetHSteamUser");
        LOG_TRACE("{} -> 'SteamGameServer_GetHSteamUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_GetIPCCallCount");
        src_address = dlsym(original_lib_handle, "SteamGameServer_GetIPCCallCount");
        LOG_TRACE("{} -> 'SteamGameServer_GetIPCCallCount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_GetSteamID");
        src_address = dlsym(original_lib_handle, "SteamGameServer_GetSteamID");
        LOG_TRACE("{} -> 'SteamGameServer_GetSteamID' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_Init");
        src_address = dlsym(original_lib_handle, "SteamGameServer_Init");
        LOG_TRACE("{} -> 'SteamGameServer_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_InitSafe");
        src_address = dlsym(original_lib_handle, "SteamGameServer_InitSafe");
        LOG_TRACE("{} -> 'SteamGameServer_InitSafe' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_RunCallbacks");
        src_address = dlsym(original_lib_handle, "SteamGameServer_RunCallbacks");
        LOG_TRACE("{} -> 'SteamGameServer_RunCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamGameServer_Shutdown");
        src_address = dlsym(original_lib_handle, "SteamGameServer_Shutdown");
        LOG_TRACE("{} -> 'SteamGameServer_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamHTMLSurface");
        src_address = dlsym(original_lib_handle, "SteamHTMLSurface");
        LOG_TRACE("{} -> 'SteamHTMLSurface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamHTTP");
        src_address = dlsym(original_lib_handle, "SteamHTTP");
        LOG_TRACE("{} -> 'SteamHTTP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_ContextInit");
        src_address = dlsym(original_lib_handle, "SteamInternal_ContextInit");
        LOG_TRACE("{} -> 'SteamInternal_ContextInit' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_CreateInterface");
        src_address = dlsym(original_lib_handle, "SteamInternal_CreateInterface");
        LOG_TRACE("{} -> 'SteamInternal_CreateInterface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_FindOrCreateGameServerInterface");
        src_address = dlsym(original_lib_handle, "SteamInternal_FindOrCreateGameServerInterface");
        LOG_TRACE("{} -> 'SteamInternal_FindOrCreateGameServerInterface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_FindOrCreateUserInterface");
        src_address = dlsym(original_lib_handle, "SteamInternal_FindOrCreateUserInterface");
        LOG_TRACE("{} -> 'SteamInternal_FindOrCreateUserInterface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_GameServer_Init");
        src_address = dlsym(original_lib_handle, "SteamInternal_GameServer_Init");
        LOG_TRACE("{} -> 'SteamInternal_GameServer_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_GameServer_Init_V2");
        src_address = dlsym(original_lib_handle, "SteamInternal_GameServer_Init_V2");
        LOG_TRACE("{} -> 'SteamInternal_GameServer_Init_V2' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_GlobalContextGameServerPtr");
        src_address = dlsym(original_lib_handle, "SteamInternal_GlobalContextGameServerPtr");
        LOG_TRACE("{} -> 'SteamInternal_GlobalContextGameServerPtr' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInternal_SteamAPI_Init");
        src_address = dlsym(original_lib_handle, "SteamInternal_SteamAPI_Init");
        LOG_TRACE("{} -> 'SteamInternal_SteamAPI_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamInventory");
        src_address = dlsym(original_lib_handle, "SteamInventory");
        LOG_TRACE("{} -> 'SteamInventory' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamMasterServerUpdater");
        src_address = dlsym(original_lib_handle, "SteamMasterServerUpdater");
        LOG_TRACE("{} -> 'SteamMasterServerUpdater' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamMatchmaking");
        src_address = dlsym(original_lib_handle, "SteamMatchmaking");
        LOG_TRACE("{} -> 'SteamMatchmaking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamMatchmakingServers");
        src_address = dlsym(original_lib_handle, "SteamMatchmakingServers");
        LOG_TRACE("{} -> 'SteamMatchmakingServers' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamMusic");
        src_address = dlsym(original_lib_handle, "SteamMusic");
        LOG_TRACE("{} -> 'SteamMusic' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamMusicRemote");
        src_address = dlsym(original_lib_handle, "SteamMusicRemote");
        LOG_TRACE("{} -> 'SteamMusicRemote' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamNetworking");
        src_address = dlsym(original_lib_handle, "SteamNetworking");
        LOG_TRACE("{} -> 'SteamNetworking' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamRealPath");
        src_address = dlsym(original_lib_handle, "SteamRealPath");
        LOG_TRACE("{} -> 'SteamRealPath' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamRemoteStorage");
        src_address = dlsym(original_lib_handle, "SteamRemoteStorage");
        LOG_TRACE("{} -> 'SteamRemoteStorage' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamScreenshots");
        src_address = dlsym(original_lib_handle, "SteamScreenshots");
        LOG_TRACE("{} -> 'SteamScreenshots' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamUGC");
        src_address = dlsym(original_lib_handle, "SteamUGC");
        LOG_TRACE("{} -> 'SteamUGC' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamUnifiedMessages");
        src_address = dlsym(original_lib_handle, "SteamUnifiedMessages");
        LOG_TRACE("{} -> 'SteamUnifiedMessages' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamUser");
        src_address = dlsym(original_lib_handle, "SteamUser");
        LOG_TRACE("{} -> 'SteamUser' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamUserStats");
        src_address = dlsym(original_lib_handle, "SteamUserStats");
        LOG_TRACE("{} -> 'SteamUserStats' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamUtils");
        src_address = dlsym(original_lib_handle, "SteamUtils");
        LOG_TRACE("{} -> 'SteamUtils' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_ComputeDistortion");
        src_address = dlsym(original_lib_handle, "SteamVR_ComputeDistortion");
        LOG_TRACE("{} -> 'SteamVR_ComputeDistortion' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetD3D9AdapterIndex");
        src_address = dlsym(original_lib_handle, "SteamVR_GetD3D9AdapterIndex");
        LOG_TRACE("{} -> 'SteamVR_GetD3D9AdapterIndex' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetDisplayId");
        src_address = dlsym(original_lib_handle, "SteamVR_GetDisplayId");
        LOG_TRACE("{} -> 'SteamVR_GetDisplayId' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetDriverId");
        src_address = dlsym(original_lib_handle, "SteamVR_GetDriverId");
        LOG_TRACE("{} -> 'SteamVR_GetDriverId' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetEyeOutputViewport");
        src_address = dlsym(original_lib_handle, "SteamVR_GetEyeOutputViewport");
        LOG_TRACE("{} -> 'SteamVR_GetEyeOutputViewport' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetHeadFromEyePose");
        src_address = dlsym(original_lib_handle, "SteamVR_GetHeadFromEyePose");
        LOG_TRACE("{} -> 'SteamVR_GetHeadFromEyePose' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetLastTrackerFromHeadPose");
        src_address = dlsym(original_lib_handle, "SteamVR_GetLastTrackerFromHeadPose");
        LOG_TRACE("{} -> 'SteamVR_GetLastTrackerFromHeadPose' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetProjectionMatrix");
        src_address = dlsym(original_lib_handle, "SteamVR_GetProjectionMatrix");
        LOG_TRACE("{} -> 'SteamVR_GetProjectionMatrix' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetProjectionRaw");
        src_address = dlsym(original_lib_handle, "SteamVR_GetProjectionRaw");
        LOG_TRACE("{} -> 'SteamVR_GetProjectionRaw' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetRecommendedRenderTargetSize");
        src_address = dlsym(original_lib_handle, "SteamVR_GetRecommendedRenderTargetSize");
        LOG_TRACE("{} -> 'SteamVR_GetRecommendedRenderTargetSize' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetTrackerFromHeadPose");
        src_address = dlsym(original_lib_handle, "SteamVR_GetTrackerFromHeadPose");
        LOG_TRACE("{} -> 'SteamVR_GetTrackerFromHeadPose' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetTrackerZeroPose");
        src_address = dlsym(original_lib_handle, "SteamVR_GetTrackerZeroPose");
        LOG_TRACE("{} -> 'SteamVR_GetTrackerZeroPose' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetViewMatrix");
        src_address = dlsym(original_lib_handle, "SteamVR_GetViewMatrix");
        LOG_TRACE("{} -> 'SteamVR_GetViewMatrix' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_GetWindowBounds");
        src_address = dlsym(original_lib_handle, "SteamVR_GetWindowBounds");
        LOG_TRACE("{} -> 'SteamVR_GetWindowBounds' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_IHmd_Version");
        src_address = dlsym(original_lib_handle, "SteamVR_IHmd_Version");
        LOG_TRACE("{} -> 'SteamVR_IHmd_Version' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_WillDriftInYaw");
        src_address = dlsym(original_lib_handle, "SteamVR_WillDriftInYaw");
        LOG_TRACE("{} -> 'SteamVR_WillDriftInYaw' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVR_ZeroTracker");
        src_address = dlsym(original_lib_handle, "SteamVR_ZeroTracker");
        LOG_TRACE("{} -> 'SteamVR_ZeroTracker' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "SteamVideo");
        src_address = dlsym(original_lib_handle, "SteamVideo");
        LOG_TRACE("{} -> 'SteamVideo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "Steam_BGetCallback");
        src_address = dlsym(original_lib_handle, "Steam_BGetCallback");
        LOG_TRACE("{} -> 'Steam_BGetCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "Steam_FreeLastCallback");
        src_address = dlsym(original_lib_handle, "Steam_FreeLastCallback");
        LOG_TRACE("{} -> 'Steam_FreeLastCallback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "Steam_GetHSteamUserCurrent");
        src_address = dlsym(original_lib_handle, "Steam_GetHSteamUserCurrent");
        LOG_TRACE("{} -> 'Steam_GetHSteamUserCurrent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "Steam_RegisterInterfaceFuncs");
        src_address = dlsym(original_lib_handle, "Steam_RegisterInterfaceFuncs");
        LOG_TRACE("{} -> 'Steam_RegisterInterfaceFuncs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "Steam_RunCallbacks");
        src_address = dlsym(original_lib_handle, "Steam_RunCallbacks");
        LOG_TRACE("{} -> 'Steam_RunCallbacks' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "VR_GetControlPanel");
        src_address = dlsym(original_lib_handle, "VR_GetControlPanel");
        LOG_TRACE("{} -> 'VR_GetControlPanel' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "VR_GetGenericInterface");
        src_address = dlsym(original_lib_handle, "VR_GetGenericInterface");
        LOG_TRACE("{} -> 'VR_GetGenericInterface' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "VR_GetStringForHmdError");
        src_address = dlsym(original_lib_handle, "VR_GetStringForHmdError");
        LOG_TRACE("{} -> 'VR_GetStringForHmdError' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "VR_Init");
        src_address = dlsym(original_lib_handle, "VR_Init");
        LOG_TRACE("{} -> 'VR_Init' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "VR_IsHmdPresent");
        src_address = dlsym(original_lib_handle, "VR_IsHmdPresent");
        LOG_TRACE("{} -> 'VR_IsHmdPresent' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "VR_Shutdown");
        src_address = dlsym(original_lib_handle, "VR_Shutdown");
        LOG_TRACE("{} -> 'VR_Shutdown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_Backtrace");
        src_address = dlsym(original_lib_handle, "_Unwind_Backtrace");
        LOG_TRACE("{} -> '_Unwind_Backtrace' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_DeleteException");
        src_address = dlsym(original_lib_handle, "_Unwind_DeleteException");
        LOG_TRACE("{} -> '_Unwind_DeleteException' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_FindEnclosingFunction");
        src_address = dlsym(original_lib_handle, "_Unwind_FindEnclosingFunction");
        LOG_TRACE("{} -> '_Unwind_FindEnclosingFunction' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_Find_FDE");
        src_address = dlsym(original_lib_handle, "_Unwind_Find_FDE");
        LOG_TRACE("{} -> '_Unwind_Find_FDE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_ForcedUnwind");
        src_address = dlsym(original_lib_handle, "_Unwind_ForcedUnwind");
        LOG_TRACE("{} -> '_Unwind_ForcedUnwind' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetCFA");
        src_address = dlsym(original_lib_handle, "_Unwind_GetCFA");
        LOG_TRACE("{} -> '_Unwind_GetCFA' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetDataRelBase");
        src_address = dlsym(original_lib_handle, "_Unwind_GetDataRelBase");
        LOG_TRACE("{} -> '_Unwind_GetDataRelBase' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetGR");
        src_address = dlsym(original_lib_handle, "_Unwind_GetGR");
        LOG_TRACE("{} -> '_Unwind_GetGR' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetIP");
        src_address = dlsym(original_lib_handle, "_Unwind_GetIP");
        LOG_TRACE("{} -> '_Unwind_GetIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetLanguageSpecificData");
        src_address = dlsym(original_lib_handle, "_Unwind_GetLanguageSpecificData");
        LOG_TRACE("{} -> '_Unwind_GetLanguageSpecificData' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetRegionStart");
        src_address = dlsym(original_lib_handle, "_Unwind_GetRegionStart");
        LOG_TRACE("{} -> '_Unwind_GetRegionStart' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_GetTextRelBase");
        src_address = dlsym(original_lib_handle, "_Unwind_GetTextRelBase");
        LOG_TRACE("{} -> '_Unwind_GetTextRelBase' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_RaiseException");
        src_address = dlsym(original_lib_handle, "_Unwind_RaiseException");
        LOG_TRACE("{} -> '_Unwind_RaiseException' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_Resume");
        src_address = dlsym(original_lib_handle, "_Unwind_Resume");
        LOG_TRACE("{} -> '_Unwind_Resume' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_Resume_or_Rethrow");
        src_address = dlsym(original_lib_handle, "_Unwind_Resume_or_Rethrow");
        LOG_TRACE("{} -> '_Unwind_Resume_or_Rethrow' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_SetGR");
        src_address = dlsym(original_lib_handle, "_Unwind_SetGR");
        LOG_TRACE("{} -> '_Unwind_SetGR' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Unwind_SetIP");
        src_address = dlsym(original_lib_handle, "_Unwind_SetIP");
        LOG_TRACE("{} -> '_Unwind_SetIP' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv111__terminateEPFvvE");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv111__terminateEPFvvE");
        LOG_TRACE("{} -> '_ZN10__cxxabiv111__terminateEPFvvE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv112__unexpectedEPFvvE");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv112__unexpectedEPFvvE");
        LOG_TRACE("{} -> '_ZN10__cxxabiv112__unexpectedEPFvvE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv115__forced_unwindD0Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv115__forced_unwindD0Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv115__forced_unwindD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv115__forced_unwindD1Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv115__forced_unwindD1Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv115__forced_unwindD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv115__forced_unwindD2Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv115__forced_unwindD2Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv115__forced_unwindD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv117__class_type_infoD0Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv117__class_type_infoD0Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv117__class_type_infoD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv117__class_type_infoD1Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv117__class_type_infoD1Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv117__class_type_infoD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv117__class_type_infoD2Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv117__class_type_infoD2Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv117__class_type_infoD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv119__foreign_exceptionD0Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv119__foreign_exceptionD0Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv119__foreign_exceptionD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv119__foreign_exceptionD1Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv119__foreign_exceptionD1Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv119__foreign_exceptionD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv119__foreign_exceptionD2Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv119__foreign_exceptionD2Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv119__foreign_exceptionD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv119__terminate_handlerE");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv119__terminate_handlerE");
        LOG_TRACE("{} -> '_ZN10__cxxabiv119__terminate_handlerE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv120__si_class_type_infoD0Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv120__si_class_type_infoD0Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv120__si_class_type_infoD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv120__si_class_type_infoD1Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv120__si_class_type_infoD1Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv120__si_class_type_infoD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv120__si_class_type_infoD2Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv120__si_class_type_infoD2Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv120__si_class_type_infoD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv120__unexpected_handlerE");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv120__unexpected_handlerE");
        LOG_TRACE("{} -> '_ZN10__cxxabiv120__unexpected_handlerE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv121__vmi_class_type_infoD0Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv121__vmi_class_type_infoD0Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv121__vmi_class_type_infoD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv121__vmi_class_type_infoD1Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv121__vmi_class_type_infoD1Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv121__vmi_class_type_infoD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN10__cxxabiv121__vmi_class_type_infoD2Ev");
        src_address = dlsym(original_lib_handle, "_ZN10__cxxabiv121__vmi_class_type_infoD2Ev");
        LOG_TRACE("{} -> '_ZN10__cxxabiv121__vmi_class_type_infoD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN9__gnu_cxx20recursive_init_errorD0Ev");
        src_address = dlsym(original_lib_handle, "_ZN9__gnu_cxx20recursive_init_errorD0Ev");
        LOG_TRACE("{} -> '_ZN9__gnu_cxx20recursive_init_errorD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN9__gnu_cxx20recursive_init_errorD1Ev");
        src_address = dlsym(original_lib_handle, "_ZN9__gnu_cxx20recursive_init_errorD1Ev");
        LOG_TRACE("{} -> '_ZN9__gnu_cxx20recursive_init_errorD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN9__gnu_cxx20recursive_init_errorD2Ev");
        src_address = dlsym(original_lib_handle, "_ZN9__gnu_cxx20recursive_init_errorD2Ev");
        LOG_TRACE("{} -> '_ZN9__gnu_cxx20recursive_init_errorD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZN9__gnu_cxx27__verbose_terminate_handlerEv");
        src_address = dlsym(original_lib_handle, "_ZN9__gnu_cxx27__verbose_terminate_handlerEv");
        LOG_TRACE("{} -> '_ZN9__gnu_cxx27__verbose_terminate_handlerEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv117__class_type_info10__do_catchEPKSt9type_infoPPvj");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv117__class_type_info10__do_catchEPKSt9type_infoPPvj");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv117__class_type_info10__do_catchEPKSt9type_infoPPvj' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PKvRNS0_15__upcast_resultE");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PKvRNS0_15__upcast_resultE");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PKvRNS0_15__upcast_resultE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PPv");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PPv");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv117__class_type_info11__do_upcastEPKS0_PPv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv117__class_type_info12__do_dyncastEiNS0_10__sub_kindEPKS0_PKvS3_S5_RNS0_16__dyncast_resultE");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv117__class_type_info12__do_dyncastEiNS0_10__sub_kindEPKS0_PKvS3_S5_RNS0_16__dyncast_resultE");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv117__class_type_info12__do_dyncastEiNS0_10__sub_kindEPKS0_PKvS3_S5_RNS0_16__dyncast_resultE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv117__class_type_info20__do_find_public_srcEiPKvPKS0_S2_");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv117__class_type_info20__do_find_public_srcEiPKvPKS0_S2_");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv117__class_type_info20__do_find_public_srcEiPKvPKS0_S2_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv120__si_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv120__si_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv120__si_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv120__si_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv120__si_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv120__si_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv120__si_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv120__si_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv120__si_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv121__vmi_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv121__vmi_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv121__vmi_class_type_info11__do_upcastEPKNS_17__class_type_infoEPKvRNS1_15__upcast_resultE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv121__vmi_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv121__vmi_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv121__vmi_class_type_info12__do_dyncastEiNS_17__class_type_info10__sub_kindEPKS1_PKvS4_S6_RNS1_16__dyncast_resultE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNK10__cxxabiv121__vmi_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_");
        src_address = dlsym(original_lib_handle, "_ZNK10__cxxabiv121__vmi_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_");
        LOG_TRACE("{} -> '_ZNK10__cxxabiv121__vmi_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt10bad_typeid4whatEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt10bad_typeid4whatEv");
        LOG_TRACE("{} -> '_ZNKSt10bad_typeid4whatEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt13bad_exception4whatEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt13bad_exception4whatEv");
        LOG_TRACE("{} -> '_ZNKSt13bad_exception4whatEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt8bad_cast4whatEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt8bad_cast4whatEv");
        LOG_TRACE("{} -> '_ZNKSt8bad_cast4whatEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt9bad_alloc4whatEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt9bad_alloc4whatEv");
        LOG_TRACE("{} -> '_ZNKSt9bad_alloc4whatEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt9exception4whatEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt9exception4whatEv");
        LOG_TRACE("{} -> '_ZNKSt9exception4whatEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt9type_info10__do_catchEPKS_PPvj");
        src_address = dlsym(original_lib_handle, "_ZNKSt9type_info10__do_catchEPKS_PPvj");
        LOG_TRACE("{} -> '_ZNKSt9type_info10__do_catchEPKS_PPvj' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt9type_info11__do_upcastEPKN10__cxxabiv117__class_type_infoEPPv");
        src_address = dlsym(original_lib_handle, "_ZNKSt9type_info11__do_upcastEPKN10__cxxabiv117__class_type_infoEPPv");
        LOG_TRACE("{} -> '_ZNKSt9type_info11__do_upcastEPKN10__cxxabiv117__class_type_infoEPPv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt9type_info14__is_pointer_pEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt9type_info14__is_pointer_pEv");
        LOG_TRACE("{} -> '_ZNKSt9type_info14__is_pointer_pEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNKSt9type_info15__is_function_pEv");
        src_address = dlsym(original_lib_handle, "_ZNKSt9type_info15__is_function_pEv");
        LOG_TRACE("{} -> '_ZNKSt9type_info15__is_function_pEv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt10bad_typeidD0Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt10bad_typeidD0Ev");
        LOG_TRACE("{} -> '_ZNSt10bad_typeidD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt10bad_typeidD1Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt10bad_typeidD1Ev");
        LOG_TRACE("{} -> '_ZNSt10bad_typeidD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt10bad_typeidD2Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt10bad_typeidD2Ev");
        LOG_TRACE("{} -> '_ZNSt10bad_typeidD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt13bad_exceptionD0Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt13bad_exceptionD0Ev");
        LOG_TRACE("{} -> '_ZNSt13bad_exceptionD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt13bad_exceptionD1Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt13bad_exceptionD1Ev");
        LOG_TRACE("{} -> '_ZNSt13bad_exceptionD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt13bad_exceptionD2Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt13bad_exceptionD2Ev");
        LOG_TRACE("{} -> '_ZNSt13bad_exceptionD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt8bad_castD0Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt8bad_castD0Ev");
        LOG_TRACE("{} -> '_ZNSt8bad_castD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt8bad_castD1Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt8bad_castD1Ev");
        LOG_TRACE("{} -> '_ZNSt8bad_castD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt8bad_castD2Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt8bad_castD2Ev");
        LOG_TRACE("{} -> '_ZNSt8bad_castD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9bad_allocD0Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9bad_allocD0Ev");
        LOG_TRACE("{} -> '_ZNSt9bad_allocD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9bad_allocD1Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9bad_allocD1Ev");
        LOG_TRACE("{} -> '_ZNSt9bad_allocD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9bad_allocD2Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9bad_allocD2Ev");
        LOG_TRACE("{} -> '_ZNSt9bad_allocD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9exceptionD0Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9exceptionD0Ev");
        LOG_TRACE("{} -> '_ZNSt9exceptionD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9exceptionD1Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9exceptionD1Ev");
        LOG_TRACE("{} -> '_ZNSt9exceptionD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9exceptionD2Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9exceptionD2Ev");
        LOG_TRACE("{} -> '_ZNSt9exceptionD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9type_infoD0Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9type_infoD0Ev");
        LOG_TRACE("{} -> '_ZNSt9type_infoD0Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9type_infoD1Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9type_infoD1Ev");
        LOG_TRACE("{} -> '_ZNSt9type_infoD1Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZNSt9type_infoD2Ev");
        src_address = dlsym(original_lib_handle, "_ZNSt9type_infoD2Ev");
        LOG_TRACE("{} -> '_ZNSt9type_infoD2Ev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt10unexpectedv");
        src_address = dlsym(original_lib_handle, "_ZSt10unexpectedv");
        LOG_TRACE("{} -> '_ZSt10unexpectedv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt13set_terminatePFvvE");
        src_address = dlsym(original_lib_handle, "_ZSt13set_terminatePFvvE");
        LOG_TRACE("{} -> '_ZSt13set_terminatePFvvE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt14set_unexpectedPFvvE");
        src_address = dlsym(original_lib_handle, "_ZSt14set_unexpectedPFvvE");
        LOG_TRACE("{} -> '_ZSt14set_unexpectedPFvvE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt15set_new_handlerPFvvE");
        src_address = dlsym(original_lib_handle, "_ZSt15set_new_handlerPFvvE");
        LOG_TRACE("{} -> '_ZSt15set_new_handlerPFvvE' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base");
        src_address = dlsym(original_lib_handle, "_ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base");
        LOG_TRACE("{} -> '_ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base");
        src_address = dlsym(original_lib_handle, "_ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base");
        LOG_TRACE("{} -> '_ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base");
        src_address = dlsym(original_lib_handle, "_ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base");
        LOG_TRACE("{} -> '_ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base");
        src_address = dlsym(original_lib_handle, "_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base");
        LOG_TRACE("{} -> '_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt18uncaught_exceptionv");
        src_address = dlsym(original_lib_handle, "_ZSt18uncaught_exceptionv");
        LOG_TRACE("{} -> '_ZSt18uncaught_exceptionv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt20_Rb_tree_black_countPKSt18_Rb_tree_node_baseS1_");
        src_address = dlsym(original_lib_handle, "_ZSt20_Rb_tree_black_countPKSt18_Rb_tree_node_baseS1_");
        LOG_TRACE("{} -> '_ZSt20_Rb_tree_black_countPKSt18_Rb_tree_node_baseS1_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt20_Rb_tree_rotate_leftPSt18_Rb_tree_node_baseRS0_");
        src_address = dlsym(original_lib_handle, "_ZSt20_Rb_tree_rotate_leftPSt18_Rb_tree_node_baseRS0_");
        LOG_TRACE("{} -> '_ZSt20_Rb_tree_rotate_leftPSt18_Rb_tree_node_baseRS0_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_");
        src_address = dlsym(original_lib_handle, "_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_");
        LOG_TRACE("{} -> '_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt28_Rb_tree_rebalance_for_erasePSt18_Rb_tree_node_baseRS_");
        src_address = dlsym(original_lib_handle, "_ZSt28_Rb_tree_rebalance_for_erasePSt18_Rb_tree_node_baseRS_");
        LOG_TRACE("{} -> '_ZSt28_Rb_tree_rebalance_for_erasePSt18_Rb_tree_node_baseRS_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_");
        src_address = dlsym(original_lib_handle, "_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_");
        LOG_TRACE("{} -> '_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt7nothrow");
        src_address = dlsym(original_lib_handle, "_ZSt7nothrow");
        LOG_TRACE("{} -> '_ZSt7nothrow' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZSt9terminatev");
        src_address = dlsym(original_lib_handle, "_ZSt9terminatev");
        LOG_TRACE("{} -> '_ZSt9terminatev' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_ZdlPv");
        src_address = dlsym(original_lib_handle, "_ZdlPv");
        LOG_TRACE("{} -> '_ZdlPv' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "_Znwj");
        src_address = dlsym(original_lib_handle, "_Znwj");
        LOG_TRACE("{} -> '_Znwj' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__deregister_frame");
        src_address = dlsym(original_lib_handle, "__deregister_frame");
        LOG_TRACE("{} -> '__deregister_frame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__deregister_frame_info");
        src_address = dlsym(original_lib_handle, "__deregister_frame_info");
        LOG_TRACE("{} -> '__deregister_frame_info' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__deregister_frame_info_bases");
        src_address = dlsym(original_lib_handle, "__deregister_frame_info_bases");
        LOG_TRACE("{} -> '__deregister_frame_info_bases' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__dynamic_cast");
        src_address = dlsym(original_lib_handle, "__dynamic_cast");
        LOG_TRACE("{} -> '__dynamic_cast' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__frame_state_for");
        src_address = dlsym(original_lib_handle, "__frame_state_for");
        LOG_TRACE("{} -> '__frame_state_for' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__gcclibcxx_demangle_callback");
        src_address = dlsym(original_lib_handle, "__gcclibcxx_demangle_callback");
        LOG_TRACE("{} -> '__gcclibcxx_demangle_callback' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__gxx_personality_v0");
        src_address = dlsym(original_lib_handle, "__gxx_personality_v0");
        LOG_TRACE("{} -> '__gxx_personality_v0' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__new_handler");
        src_address = dlsym(original_lib_handle, "__new_handler");
        LOG_TRACE("{} -> '__new_handler' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__register_frame");
        src_address = dlsym(original_lib_handle, "__register_frame");
        LOG_TRACE("{} -> '__register_frame' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__register_frame_info");
        src_address = dlsym(original_lib_handle, "__register_frame_info");
        LOG_TRACE("{} -> '__register_frame_info' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__register_frame_info_bases");
        src_address = dlsym(original_lib_handle, "__register_frame_info_bases");
        LOG_TRACE("{} -> '__register_frame_info_bases' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__register_frame_info_table");
        src_address = dlsym(original_lib_handle, "__register_frame_info_table");
        LOG_TRACE("{} -> '__register_frame_info_table' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__register_frame_info_table_bases");
        src_address = dlsym(original_lib_handle, "__register_frame_info_table_bases");
        LOG_TRACE("{} -> '__register_frame_info_table_bases' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__register_frame_table");
        src_address = dlsym(original_lib_handle, "__register_frame_table");
        LOG_TRACE("{} -> '__register_frame_table' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap___lxstat");
        src_address = dlsym(original_lib_handle, "__wrap___lxstat");
        LOG_TRACE("{} -> '__wrap___lxstat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap___lxstat64");
        src_address = dlsym(original_lib_handle, "__wrap___lxstat64");
        LOG_TRACE("{} -> '__wrap___lxstat64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap___xstat");
        src_address = dlsym(original_lib_handle, "__wrap___xstat");
        LOG_TRACE("{} -> '__wrap___xstat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap___xstat64");
        src_address = dlsym(original_lib_handle, "__wrap___xstat64");
        LOG_TRACE("{} -> '__wrap___xstat64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_access");
        src_address = dlsym(original_lib_handle, "__wrap_access");
        LOG_TRACE("{} -> '__wrap_access' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_chdir");
        src_address = dlsym(original_lib_handle, "__wrap_chdir");
        LOG_TRACE("{} -> '__wrap_chdir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_chmod");
        src_address = dlsym(original_lib_handle, "__wrap_chmod");
        LOG_TRACE("{} -> '__wrap_chmod' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_chown");
        src_address = dlsym(original_lib_handle, "__wrap_chown");
        LOG_TRACE("{} -> '__wrap_chown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_dlmopen");
        src_address = dlsym(original_lib_handle, "__wrap_dlmopen");
        LOG_TRACE("{} -> '__wrap_dlmopen' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_dlopen");
        src_address = dlsym(original_lib_handle, "__wrap_dlopen");
        LOG_TRACE("{} -> '__wrap_dlopen' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_fopen");
        src_address = dlsym(original_lib_handle, "__wrap_fopen");
        LOG_TRACE("{} -> '__wrap_fopen' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_fopen64");
        src_address = dlsym(original_lib_handle, "__wrap_fopen64");
        LOG_TRACE("{} -> '__wrap_fopen64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_freopen");
        src_address = dlsym(original_lib_handle, "__wrap_freopen");
        LOG_TRACE("{} -> '__wrap_freopen' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_lchown");
        src_address = dlsym(original_lib_handle, "__wrap_lchown");
        LOG_TRACE("{} -> '__wrap_lchown' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_link");
        src_address = dlsym(original_lib_handle, "__wrap_link");
        LOG_TRACE("{} -> '__wrap_link' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_lstat");
        src_address = dlsym(original_lib_handle, "__wrap_lstat");
        LOG_TRACE("{} -> '__wrap_lstat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_lstat64");
        src_address = dlsym(original_lib_handle, "__wrap_lstat64");
        LOG_TRACE("{} -> '__wrap_lstat64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_mkdir");
        src_address = dlsym(original_lib_handle, "__wrap_mkdir");
        LOG_TRACE("{} -> '__wrap_mkdir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_mkfifo");
        src_address = dlsym(original_lib_handle, "__wrap_mkfifo");
        LOG_TRACE("{} -> '__wrap_mkfifo' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_mknod");
        src_address = dlsym(original_lib_handle, "__wrap_mknod");
        LOG_TRACE("{} -> '__wrap_mknod' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_mount");
        src_address = dlsym(original_lib_handle, "__wrap_mount");
        LOG_TRACE("{} -> '__wrap_mount' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_open");
        src_address = dlsym(original_lib_handle, "__wrap_open");
        LOG_TRACE("{} -> '__wrap_open' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_open64");
        src_address = dlsym(original_lib_handle, "__wrap_open64");
        LOG_TRACE("{} -> '__wrap_open64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_opendir");
        src_address = dlsym(original_lib_handle, "__wrap_opendir");
        LOG_TRACE("{} -> '__wrap_opendir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_rename");
        src_address = dlsym(original_lib_handle, "__wrap_rename");
        LOG_TRACE("{} -> '__wrap_rename' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_rmdir");
        src_address = dlsym(original_lib_handle, "__wrap_rmdir");
        LOG_TRACE("{} -> '__wrap_rmdir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_scandir");
        src_address = dlsym(original_lib_handle, "__wrap_scandir");
        LOG_TRACE("{} -> '__wrap_scandir' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_scandir64");
        src_address = dlsym(original_lib_handle, "__wrap_scandir64");
        LOG_TRACE("{} -> '__wrap_scandir64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_stat");
        src_address = dlsym(original_lib_handle, "__wrap_stat");
        LOG_TRACE("{} -> '__wrap_stat' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_stat64");
        src_address = dlsym(original_lib_handle, "__wrap_stat64");
        LOG_TRACE("{} -> '__wrap_stat64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_statfs");
        src_address = dlsym(original_lib_handle, "__wrap_statfs");
        LOG_TRACE("{} -> '__wrap_statfs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_statfs64");
        src_address = dlsym(original_lib_handle, "__wrap_statfs64");
        LOG_TRACE("{} -> '__wrap_statfs64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_statvfs");
        src_address = dlsym(original_lib_handle, "__wrap_statvfs");
        LOG_TRACE("{} -> '__wrap_statvfs' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_statvfs64");
        src_address = dlsym(original_lib_handle, "__wrap_statvfs64");
        LOG_TRACE("{} -> '__wrap_statvfs64' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_symlink");
        src_address = dlsym(original_lib_handle, "__wrap_symlink");
        LOG_TRACE("{} -> '__wrap_symlink' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_unlink");
        src_address = dlsym(original_lib_handle, "__wrap_unlink");
        LOG_TRACE("{} -> '__wrap_unlink' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_utime");
        src_address = dlsym(original_lib_handle, "__wrap_utime");
        LOG_TRACE("{} -> '__wrap_utime' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "__wrap_utimes");
        src_address = dlsym(original_lib_handle, "__wrap_utimes");
        LOG_TRACE("{} -> '__wrap_utimes' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        dest_address = dlsym(self_lib_handle, "g_pSteamClientGameServer");
        src_address = dlsym(original_lib_handle, "g_pSteamClientGameServer");
        LOG_TRACE("{} -> 'g_pSteamClientGameServer' src: {}, dest: {}", __func__, src_address, dest_address);
        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
        std::memcpy(static_cast<uint8_t*>(dest_address) + 1, &src_address, sizeof(void*));

        initialized = true;
        LOG_INFO("Proxy exports initialized");
    }
}
