Temp_ALL HOOK API KERNEL32

 
ALL  KERNEL32.dll
[code=C/C++]
struct _String{
    public:
    WINAPI _String(){
    };
    int WINAPI ReverseFind(CString DaData, CString DaCompare){
        int Result = 0;
        int HaFind = -1;
        bool HaTrue = false;
        CString HaData = DaData;
        while(HaFind = HaData.Find(DaCompare), HaFind != -1){
            Result += (HaTrue) ? HaFind + 1 : HaFind;
            HaTrue = true;
            HaData = HaData.Mid(HaFind + 1);
        }
        return Result;
    };
    CString WINAPI MakeUpper(CString DaData){
        CString Result;
        Result.Format("%s", DaData);
        return Result.MakeUpper();
    }

};
_String String = _String();



int IniKERNEL32_dll = 0;
HOOK_ITEM HookItem_GetModuleFileNameA = {0};
typedef DWORD  (WINAPI* PFN_GetModuleFileNameA)( HMODULE hModule,LPTSTR lpFilename,DWORD nSize );
DWORD WINAPI NEW_GetModuleFileNameA( HMODULE hModule,LPTSTR lpFilename,DWORD nSize ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetModuleFileNameA.txt", Change.String(IniKERNEL32_dll++) + " lpFilename: " + ((CString)lpFilename) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetModuleFileNameA.txt", Change.String(IniKERNEL32_dll++) + " nSize: " + Change.String((int)nSize) + "/n");
    DWORD Result = ((PFN_GetModuleFileNameA)HookItem_GetModuleFileNameA.dwOldValue)( hModule,lpFilename,nSize );
    return Result;
}

void WINAPI KEEP_GetModuleFileNameA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetModuleFileNameA", (DWORD)NEW_GetModuleFileNameA, &HookItem_GetModuleFileNameA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetModuleFileNameA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetModuleFileNameA.txt", "成功！/n");
}

HOOK_ITEM HookItem_MultiByteToWideChar = {0};
typedef int  (WINAPI* PFN_MultiByteToWideChar)( UINT CodePage,DWORD dwFlags,LPCSTR lpMultiByteStr,int cbMultiByte,LPWSTR lpWideCharStr,int cchWideChar );
int WINAPI NEW_MultiByteToWideChar( UINT CodePage,DWORD dwFlags,LPCSTR lpMultiByteStr,int cbMultiByte,LPWSTR lpWideCharStr,int cchWideChar ){
    File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", Change.String(IniKERNEL32_dll++) + " CodePage: " + Change.String((int)CodePage) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", Change.String(IniKERNEL32_dll++) + " dwFlags: " + Change.String((int)dwFlags) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", Change.String(IniKERNEL32_dll++) + " lpMultiByteStr: " + ((CString)lpMultiByteStr) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", Change.String(IniKERNEL32_dll++) + " cbMultiByte: " + Change.String((int)cbMultiByte) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", Change.String(IniKERNEL32_dll++) + " cchWideChar: " + Change.String((int)cchWideChar) + "/n");
    int Result = ((PFN_MultiByteToWideChar)HookItem_MultiByteToWideChar.dwOldValue)( CodePage,dwFlags,lpMultiByteStr,cbMultiByte,lpWideCharStr,cchWideChar );
    return Result;
}

void WINAPI KEEP_MultiByteToWideChar(){
    if ( !RedirectApi ( "KERNEL32.dll", "MultiByteToWideChar", (DWORD)NEW_MultiByteToWideChar, &HookItem_MultiByteToWideChar ) )
        File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_MultiByteToWideChar.txt", "成功！/n");
}

HOOK_ITEM HookItem_Sleep = {0};
typedef VOID  (WINAPI* PFN_Sleep)( DWORD dwMilliseconds );
VOID WINAPI NEW_Sleep( DWORD dwMilliseconds ){
    File.PlusString("C://ini//result//KERNEL32.dll_Sleep.txt", Change.String(IniKERNEL32_dll++) + " dwMilliseconds: " + Change.String((int)dwMilliseconds) + "/n");
    ((PFN_Sleep)HookItem_Sleep.dwOldValue)( dwMilliseconds );
}

void WINAPI KEEP_Sleep(){
    if ( !RedirectApi ( "KERNEL32.dll", "Sleep", (DWORD)NEW_Sleep, &HookItem_Sleep ) )
        File.PlusString("C://ini//result//KERNEL32.dll_Sleep.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_Sleep.txt", "成功！/n");
}

HOOK_ITEM HookItem_WaitForSingleObject = {0};
typedef DWORD  (WINAPI* PFN_WaitForSingleObject)( HANDLE hHandle,DWORD dwMilliseconds );
DWORD WINAPI NEW_WaitForSingleObject( HANDLE hHandle,DWORD dwMilliseconds ){
    File.PlusString("C://ini//result//KERNEL32.dll_WaitForSingleObject.txt", Change.String(IniKERNEL32_dll++) + " dwMilliseconds: " + Change.String((int)dwMilliseconds) + "/n");
    DWORD Result = ((PFN_WaitForSingleObject)HookItem_WaitForSingleObject.dwOldValue)( hHandle,dwMilliseconds );
    return Result;
}

void WINAPI KEEP_WaitForSingleObject(){
    if ( !RedirectApi ( "KERNEL32.dll", "WaitForSingleObject", (DWORD)NEW_WaitForSingleObject, &HookItem_WaitForSingleObject ) )
        File.PlusString("C://ini//result//KERNEL32.dll_WaitForSingleObject.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_WaitForSingleObject.txt", "成功！/n");
}

HOOK_ITEM HookItem_lstrcpyA = {0};
typedef LPTSTR  (WINAPI* PFN_lstrcpyA)( LPTSTR lpString1,LPTSTR lpString2 );
LPTSTR WINAPI NEW_lstrcpyA( LPTSTR lpString1,LPTSTR lpString2 ){
    File.PlusString("C://ini//result//KERNEL32.dll_lstrcpyA.txt", Change.String(IniKERNEL32_dll++) + " lpString1: " + ((CString)lpString1) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_lstrcpyA.txt", Change.String(IniKERNEL32_dll++) + " lpString2: " + ((CString)lpString2) + "/n");
    LPTSTR Result = ((PFN_lstrcpyA)HookItem_lstrcpyA.dwOldValue)( lpString1,lpString2 );
    return Result;
}

void WINAPI KEEP_lstrcpyA(){
    if ( !RedirectApi ( "KERNEL32.dll", "lstrcpyA", (DWORD)NEW_lstrcpyA, &HookItem_lstrcpyA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_lstrcpyA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_lstrcpyA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetWindowsDirectoryA = {0};
typedef UINT  (WINAPI* PFN_GetWindowsDirectoryA)( LPTSTR lpBuffer,UINT uSize );
UINT WINAPI NEW_GetWindowsDirectoryA( LPTSTR lpBuffer,UINT uSize ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetWindowsDirectoryA.txt", Change.String(IniKERNEL32_dll++) + " lpBuffer: " + ((CString)lpBuffer) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetWindowsDirectoryA.txt", Change.String(IniKERNEL32_dll++) + " uSize: " + Change.String((int)uSize) + "/n");
    UINT Result = ((PFN_GetWindowsDirectoryA)HookItem_GetWindowsDirectoryA.dwOldValue)( lpBuffer,uSize );
    return Result;
}

void WINAPI KEEP_GetWindowsDirectoryA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetWindowsDirectoryA", (DWORD)NEW_GetWindowsDirectoryA, &HookItem_GetWindowsDirectoryA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetWindowsDirectoryA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetWindowsDirectoryA.txt", "成功！/n");
}

HOOK_ITEM HookItem_LoadLibraryA = {0};
typedef HMODULE  (WINAPI* PFN_LoadLibraryA)( LPCTSTR lpFileName,HANDLE hFile,DWORD dwFlags );
HMODULE WINAPI NEW_LoadLibraryA( LPCTSTR lpFileName,HANDLE hFile,DWORD dwFlags ){
    File.PlusString("C://ini//result//KERNEL32.dll_LoadLibraryA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_LoadLibraryA.txt", Change.String(IniKERNEL32_dll++) + " dwFlags: " + Change.String((int)dwFlags) + "/n");
    HMODULE Result = ((PFN_LoadLibraryA)HookItem_LoadLibraryA.dwOldValue)( lpFileName,hFile,dwFlags );
    return Result;
}

void WINAPI KEEP_LoadLibraryA(){
    if ( !RedirectApi ( "KERNEL32.dll", "LoadLibraryA", (DWORD)NEW_LoadLibraryA, &HookItem_LoadLibraryA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_LoadLibraryA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_LoadLibraryA.txt", "成功！/n");
}

HOOK_ITEM HookItem_FreeLibrary = {0};
typedef BOOL  (WINAPI* PFN_FreeLibrary)( HMODULE hModule );
BOOL WINAPI NEW_FreeLibrary( HMODULE hModule ){
    BOOL Result = ((PFN_FreeLibrary)HookItem_FreeLibrary.dwOldValue)( hModule );
    return Result;
}

void WINAPI KEEP_FreeLibrary(){
    if ( !RedirectApi ( "KERNEL32.dll", "FreeLibrary", (DWORD)NEW_FreeLibrary, &HookItem_FreeLibrary ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FreeLibrary.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FreeLibrary.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetPrivateProfileStringA = {0};
typedef DWORD  (WINAPI* PFN_GetPrivateProfileStringA)( LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString,DWORD nSize,LPCTSTR lpFileName );
DWORD WINAPI NEW_GetPrivateProfileStringA( LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString,DWORD nSize,LPCTSTR lpFileName ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpAppName: " + ((CString)lpAppName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpKeyName: " + ((CString)lpKeyName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpDefault: " + ((CString)lpDefault) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpReturnedString: " + ((CString)lpReturnedString) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " nSize: " + Change.String((int)nSize) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    DWORD Result = ((PFN_GetPrivateProfileStringA)HookItem_GetPrivateProfileStringA.dwOldValue)( lpAppName,lpKeyName,lpDefault,lpReturnedString,nSize,lpFileName );
    return Result;
}

void WINAPI KEEP_GetPrivateProfileStringA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetPrivateProfileStringA", (DWORD)NEW_GetPrivateProfileStringA, &HookItem_GetPrivateProfileStringA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileStringA.txt", "成功！/n");
}

HOOK_ITEM HookItem_lstrlenA = {0};
typedef int  (WINAPI* PFN_lstrlenA)( LPCTSTR lpString );
int WINAPI NEW_lstrlenA( LPCTSTR lpString ){
    File.PlusString("C://ini//result//KERNEL32.dll_lstrlenA.txt", Change.String(IniKERNEL32_dll++) + " lpString: " + ((CString)lpString) + "/n");
    int Result = ((PFN_lstrlenA)HookItem_lstrlenA.dwOldValue)( lpString );
    return Result;
}

void WINAPI KEEP_lstrlenA(){
    if ( !RedirectApi ( "KERNEL32.dll", "lstrlenA", (DWORD)NEW_lstrlenA, &HookItem_lstrlenA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_lstrlenA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_lstrlenA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetFileAttributesA = {0};
typedef DWORD  (WINAPI* PFN_GetFileAttributesA)( LPCTSTR lpFileName );
DWORD WINAPI NEW_GetFileAttributesA( LPCTSTR lpFileName ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetFileAttributesA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    DWORD Result = ((PFN_GetFileAttributesA)HookItem_GetFileAttributesA.dwOldValue)( lpFileName );
    return Result;
}

void WINAPI KEEP_GetFileAttributesA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetFileAttributesA", (DWORD)NEW_GetFileAttributesA, &HookItem_GetFileAttributesA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetFileAttributesA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetFileAttributesA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetDriveTypeA = {0};
typedef UINT  (WINAPI* PFN_GetDriveTypeA)( LPCTSTR lpRootPathName );
UINT WINAPI NEW_GetDriveTypeA( LPCTSTR lpRootPathName ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetDriveTypeA.txt", Change.String(IniKERNEL32_dll++) + " lpRootPathName: " + ((CString)lpRootPathName) + "/n");
    UINT Result = ((PFN_GetDriveTypeA)HookItem_GetDriveTypeA.dwOldValue)( lpRootPathName );
    return Result;
}

void WINAPI KEEP_GetDriveTypeA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetDriveTypeA", (DWORD)NEW_GetDriveTypeA, &HookItem_GetDriveTypeA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetDriveTypeA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetDriveTypeA.txt", "成功！/n");
}

HOOK_ITEM HookItem_InitializeCriticalSection = {0};
typedef void  (WINAPI* PFN_InitializeCriticalSection)( LPCRITICAL_SECTION lpCriticalSection );
void WINAPI NEW_InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection ){
    ((PFN_InitializeCriticalSection)HookItem_InitializeCriticalSection.dwOldValue)( lpCriticalSection );
}

void WINAPI KEEP_InitializeCriticalSection(){
    if ( !RedirectApi ( "KERNEL32.dll", "InitializeCriticalSection", (DWORD)NEW_InitializeCriticalSection, &HookItem_InitializeCriticalSection ) )
        File.PlusString("C://ini//result//KERNEL32.dll_InitializeCriticalSection.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_InitializeCriticalSection.txt", "成功！/n");
}

HOOK_ITEM HookItem_DeleteCriticalSection = {0};
typedef void  (WINAPI* PFN_DeleteCriticalSection)( LPCRITICAL_SECTION lpCriticalSection );
void WINAPI NEW_DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection ){
    ((PFN_DeleteCriticalSection)HookItem_DeleteCriticalSection.dwOldValue)( lpCriticalSection );
}

void WINAPI KEEP_DeleteCriticalSection(){
    if ( !RedirectApi ( "KERNEL32.dll", "DeleteCriticalSection", (DWORD)NEW_DeleteCriticalSection, &HookItem_DeleteCriticalSection ) )
        File.PlusString("C://ini//result//KERNEL32.dll_DeleteCriticalSection.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_DeleteCriticalSection.txt", "成功！/n");
}

HOOK_ITEM HookItem_LeaveCriticalSection = {0};
typedef void  (WINAPI* PFN_LeaveCriticalSection)( LPCRITICAL_SECTION lpCriticalSection );
void WINAPI NEW_LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection ){
    ((PFN_LeaveCriticalSection)HookItem_LeaveCriticalSection.dwOldValue)( lpCriticalSection );
}

void WINAPI KEEP_LeaveCriticalSection(){
    if ( !RedirectApi ( "KERNEL32.dll", "LeaveCriticalSection", (DWORD)NEW_LeaveCriticalSection, &HookItem_LeaveCriticalSection ) )
        File.PlusString("C://ini//result//KERNEL32.dll_LeaveCriticalSection.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_LeaveCriticalSection.txt", "成功！/n");
}

HOOK_ITEM HookItem_EnterCriticalSection = {0};
typedef void  (WINAPI* PFN_EnterCriticalSection)( LPCRITICAL_SECTION lpCriticalSection );
void WINAPI NEW_EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection ){
    ((PFN_EnterCriticalSection)HookItem_EnterCriticalSection.dwOldValue)( lpCriticalSection );
}

void WINAPI KEEP_EnterCriticalSection(){
    if ( !RedirectApi ( "KERNEL32.dll", "EnterCriticalSection", (DWORD)NEW_EnterCriticalSection, &HookItem_EnterCriticalSection ) )
        File.PlusString("C://ini//result//KERNEL32.dll_EnterCriticalSection.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_EnterCriticalSection.txt", "成功！/n");
}

HOOK_ITEM HookItem_MulDiv = {0};
typedef int  (WINAPI* PFN_MulDiv)( int nNumber,int nNumerator,int nDenominator );
int WINAPI NEW_MulDiv( int nNumber,int nNumerator,int nDenominator ){
    File.PlusString("C://ini//result//KERNEL32.dll_MulDiv.txt", Change.String(IniKERNEL32_dll++) + " nNumber: " + Change.String((int)nNumber) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MulDiv.txt", Change.String(IniKERNEL32_dll++) + " nNumerator: " + Change.String((int)nNumerator) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MulDiv.txt", Change.String(IniKERNEL32_dll++) + " nDenominator: " + Change.String((int)nDenominator) + "/n");
    int Result = ((PFN_MulDiv)HookItem_MulDiv.dwOldValue)( nNumber,nNumerator,nDenominator );
    return Result;
}

void WINAPI KEEP_MulDiv(){
    if ( !RedirectApi ( "KERNEL32.dll", "MulDiv", (DWORD)NEW_MulDiv, &HookItem_MulDiv ) )
        File.PlusString("C://ini//result//KERNEL32.dll_MulDiv.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_MulDiv.txt", "成功！/n");
}

HOOK_ITEM HookItem_ResumeThread = {0};
typedef DWORD  (WINAPI* PFN_ResumeThread)( HANDLE hThread );
DWORD WINAPI NEW_ResumeThread( HANDLE hThread ){
    DWORD Result = ((PFN_ResumeThread)HookItem_ResumeThread.dwOldValue)( hThread );
    return Result;
}

void WINAPI KEEP_ResumeThread(){
    if ( !RedirectApi ( "KERNEL32.dll", "ResumeThread", (DWORD)NEW_ResumeThread, &HookItem_ResumeThread ) )
        File.PlusString("C://ini//result//KERNEL32.dll_ResumeThread.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_ResumeThread.txt", "成功！/n");
}

HOOK_ITEM HookItem_LockResource = {0};
typedef LPVOID  (WINAPI* PFN_LockResource)( HGLOBAL hResData );
LPVOID WINAPI NEW_LockResource( HGLOBAL hResData ){
    LPVOID Result = ((PFN_LockResource)HookItem_LockResource.dwOldValue)( hResData );
    return Result;
}

void WINAPI KEEP_LockResource(){
    if ( !RedirectApi ( "KERNEL32.dll", "LockResource", (DWORD)NEW_LockResource, &HookItem_LockResource ) )
        File.PlusString("C://ini//result//KERNEL32.dll_LockResource.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_LockResource.txt", "成功！/n");
}

HOOK_ITEM HookItem_SizeofResource = {0};
typedef DWORD  (WINAPI* PFN_SizeofResource)( HMODULE hModule,HRSRC hResInfo );
DWORD WINAPI NEW_SizeofResource( HMODULE hModule,HRSRC hResInfo ){
    DWORD Result = ((PFN_SizeofResource)HookItem_SizeofResource.dwOldValue)( hModule,hResInfo );
    return Result;
}

void WINAPI KEEP_SizeofResource(){
    if ( !RedirectApi ( "KERNEL32.dll", "SizeofResource", (DWORD)NEW_SizeofResource, &HookItem_SizeofResource ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SizeofResource.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SizeofResource.txt", "成功！/n");
}

HOOK_ITEM HookItem_LoadResource = {0};
typedef HGLOBAL  (WINAPI* PFN_LoadResource)( HMODULE hModule,HRSRC hResInfo );
HGLOBAL WINAPI NEW_LoadResource( HMODULE hModule,HRSRC hResInfo ){
    HGLOBAL Result = ((PFN_LoadResource)HookItem_LoadResource.dwOldValue)( hModule,hResInfo );
    return Result;
}

void WINAPI KEEP_LoadResource(){
    if ( !RedirectApi ( "KERNEL32.dll", "LoadResource", (DWORD)NEW_LoadResource, &HookItem_LoadResource ) )
        File.PlusString("C://ini//result//KERNEL32.dll_LoadResource.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_LoadResource.txt", "成功！/n");
}

HOOK_ITEM HookItem_FindResourceA = {0};
typedef HRSRC  (WINAPI* PFN_FindResourceA)( HMODULE hModule,LPCTSTR lpName,LPCTSTR lpType );
HRSRC WINAPI NEW_FindResourceA( HMODULE hModule,LPCTSTR lpName,LPCTSTR lpType ){
    File.PlusString("C://ini//result//KERNEL32.dll_FindResourceA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_FindResourceA.txt", Change.String(IniKERNEL32_dll++) + " lpType: " + ((CString)lpType) + "/n");
    HRSRC Result = ((PFN_FindResourceA)HookItem_FindResourceA.dwOldValue)( hModule,lpName,lpType );
    return Result;
}

void WINAPI KEEP_FindResourceA(){
    if ( !RedirectApi ( "KERNEL32.dll", "FindResourceA", (DWORD)NEW_FindResourceA, &HookItem_FindResourceA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FindResourceA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FindResourceA.txt", "成功！/n");
}

HOOK_ITEM HookItem_ResetEvent = {0};
typedef BOOL  (WINAPI* PFN_ResetEvent)( HANDLE hEvent );
BOOL WINAPI NEW_ResetEvent( HANDLE hEvent ){
    BOOL Result = ((PFN_ResetEvent)HookItem_ResetEvent.dwOldValue)( hEvent );
    return Result;
}

void WINAPI KEEP_ResetEvent(){
    if ( !RedirectApi ( "KERNEL32.dll", "ResetEvent", (DWORD)NEW_ResetEvent, &HookItem_ResetEvent ) )
        File.PlusString("C://ini//result//KERNEL32.dll_ResetEvent.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_ResetEvent.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetLongPathNameA = {0};
typedef DWORD  (WINAPI* PFN_GetLongPathNameA)( LPCTSTR lpszShortPath,LPTSTR lpszLongPath,DWORD cchBuffer );
DWORD WINAPI NEW_GetLongPathNameA( LPCTSTR lpszShortPath,LPTSTR lpszLongPath,DWORD cchBuffer ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetLongPathNameA.txt", Change.String(IniKERNEL32_dll++) + " lpszShortPath: " + ((CString)lpszShortPath) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetLongPathNameA.txt", Change.String(IniKERNEL32_dll++) + " lpszLongPath: " + ((CString)lpszLongPath) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetLongPathNameA.txt", Change.String(IniKERNEL32_dll++) + " cchBuffer: " + Change.String((int)cchBuffer) + "/n");
    DWORD Result = ((PFN_GetLongPathNameA)HookItem_GetLongPathNameA.dwOldValue)( lpszShortPath,lpszLongPath,cchBuffer );
    return Result;
}

void WINAPI KEEP_GetLongPathNameA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetLongPathNameA", (DWORD)NEW_GetLongPathNameA, &HookItem_GetLongPathNameA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetLongPathNameA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetLongPathNameA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetShortPathNameA = {0};
typedef DWORD  (WINAPI* PFN_GetShortPathNameA)( LPCTSTR lpszLongPath,LPTSTR lpszShortPath,DWORD cchBuffer );
DWORD WINAPI NEW_GetShortPathNameA( LPCTSTR lpszLongPath,LPTSTR lpszShortPath,DWORD cchBuffer ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetShortPathNameA.txt", Change.String(IniKERNEL32_dll++) + " lpszLongPath: " + ((CString)lpszLongPath) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetShortPathNameA.txt", Change.String(IniKERNEL32_dll++) + " lpszShortPath: " + ((CString)lpszShortPath) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetShortPathNameA.txt", Change.String(IniKERNEL32_dll++) + " cchBuffer: " + Change.String((int)cchBuffer) + "/n");
    DWORD Result = ((PFN_GetShortPathNameA)HookItem_GetShortPathNameA.dwOldValue)( lpszLongPath,lpszShortPath,cchBuffer );
    return Result;
}

void WINAPI KEEP_GetShortPathNameA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetShortPathNameA", (DWORD)NEW_GetShortPathNameA, &HookItem_GetShortPathNameA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetShortPathNameA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetShortPathNameA.txt", "成功！/n");
}

HOOK_ITEM HookItem_CloseHandle = {0};
typedef BOOL  (WINAPI* PFN_CloseHandle)( HANDLE hObject );
BOOL WINAPI NEW_CloseHandle( HANDLE hObject ){
    BOOL Result = ((PFN_CloseHandle)HookItem_CloseHandle.dwOldValue)( hObject );
    return Result;
}

void WINAPI KEEP_CloseHandle(){
    if ( !RedirectApi ( "KERNEL32.dll", "CloseHandle", (DWORD)NEW_CloseHandle, &HookItem_CloseHandle ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CloseHandle.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CloseHandle.txt", "成功！/n");
}

HOOK_ITEM HookItem_ReadFile = {0};
typedef BOOL  (WINAPI* PFN_ReadFile)( HANDLE hFile,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead,LPOVERLAPPED lpOverlapped );
BOOL WINAPI NEW_ReadFile( HANDLE hFile,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead,LPOVERLAPPED lpOverlapped ){
    File.PlusString("C://ini//result//KERNEL32.dll_ReadFile.txt", Change.String(IniKERNEL32_dll++) + " nNumberOfBytesToRead: " + Change.String((int)nNumberOfBytesToRead) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_ReadFile.txt", Change.String(IniKERNEL32_dll++) + " lpNumberOfBytesRead: " + Change.String((int)lpNumberOfBytesRead) + "/n");
    BOOL Result = ((PFN_ReadFile)HookItem_ReadFile.dwOldValue)( hFile,lpBuffer,nNumberOfBytesToRead,lpNumberOfBytesRead,lpOverlapped );
    return Result;
}

void WINAPI KEEP_ReadFile(){
    if ( !RedirectApi ( "KERNEL32.dll", "ReadFile", (DWORD)NEW_ReadFile, &HookItem_ReadFile ) )
        File.PlusString("C://ini//result//KERNEL32.dll_ReadFile.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_ReadFile.txt", "成功！/n");
}

HOOK_ITEM HookItem_OpenFileMappingA = {0};
typedef HANDLE  (WINAPI* PFN_OpenFileMappingA)( DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName );
HANDLE WINAPI NEW_OpenFileMappingA( DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName ){
    File.PlusString("C://ini//result//KERNEL32.dll_OpenFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " dwDesiredAccess: " + Change.String((int)dwDesiredAccess) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_OpenFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " bInheritHandle: " + Change.String((int)bInheritHandle) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_OpenFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    HANDLE Result = ((PFN_OpenFileMappingA)HookItem_OpenFileMappingA.dwOldValue)( dwDesiredAccess,bInheritHandle,lpName );
    return Result;
}

void WINAPI KEEP_OpenFileMappingA(){
    if ( !RedirectApi ( "KERNEL32.dll", "OpenFileMappingA", (DWORD)NEW_OpenFileMappingA, &HookItem_OpenFileMappingA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_OpenFileMappingA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_OpenFileMappingA.txt", "成功！/n");
}

HOOK_ITEM HookItem_SetFilePointer = {0};
typedef DWORD  (WINAPI* PFN_SetFilePointer)( HANDLE hFile,LONG lDistanceToMove,PLONG lpDistanceToMoveHigh,DWORD dwMoveMethod );
DWORD WINAPI NEW_SetFilePointer( HANDLE hFile,LONG lDistanceToMove,PLONG lpDistanceToMoveHigh,DWORD dwMoveMethod ){
    File.PlusString("C://ini//result//KERNEL32.dll_SetFilePointer.txt", Change.String(IniKERNEL32_dll++) + " dwMoveMethod: " + Change.String((int)dwMoveMethod) + "/n");
    DWORD Result = ((PFN_SetFilePointer)HookItem_SetFilePointer.dwOldValue)( hFile,lDistanceToMove,lpDistanceToMoveHigh,dwMoveMethod );
    return Result;
}

void WINAPI KEEP_SetFilePointer(){
    if ( !RedirectApi ( "KERNEL32.dll", "SetFilePointer", (DWORD)NEW_SetFilePointer, &HookItem_SetFilePointer ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SetFilePointer.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SetFilePointer.txt", "成功！/n");
}

HOOK_ITEM HookItem_SystemTimeToFileTime = {0};
typedef BOOL  (WINAPI* PFN_SystemTimeToFileTime)( const SYSTEMTIME* lpSystemTime,LPFILETIME lpFileTime );
BOOL WINAPI NEW_SystemTimeToFileTime( const SYSTEMTIME* lpSystemTime,LPFILETIME lpFileTime ){
    BOOL Result = ((PFN_SystemTimeToFileTime)HookItem_SystemTimeToFileTime.dwOldValue)( lpSystemTime,lpFileTime );
    return Result;
}

void WINAPI KEEP_SystemTimeToFileTime(){
    if ( !RedirectApi ( "KERNEL32.dll", "SystemTimeToFileTime", (DWORD)NEW_SystemTimeToFileTime, &HookItem_SystemTimeToFileTime ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SystemTimeToFileTime.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SystemTimeToFileTime.txt", "成功！/n");
}

HOOK_ITEM HookItem_LocalFileTimeToFileTime = {0};
typedef BOOL  (WINAPI* PFN_LocalFileTimeToFileTime)( const FILETIME* lpLocalFileTime,LPFILETIME lpFileTime );
BOOL WINAPI NEW_LocalFileTimeToFileTime( const FILETIME* lpLocalFileTime,LPFILETIME lpFileTime ){
    BOOL Result = ((PFN_LocalFileTimeToFileTime)HookItem_LocalFileTimeToFileTime.dwOldValue)( lpLocalFileTime,lpFileTime );
    return Result;
}

void WINAPI KEEP_LocalFileTimeToFileTime(){
    if ( !RedirectApi ( "KERNEL32.dll", "LocalFileTimeToFileTime", (DWORD)NEW_LocalFileTimeToFileTime, &HookItem_LocalFileTimeToFileTime ) )
        File.PlusString("C://ini//result//KERNEL32.dll_LocalFileTimeToFileTime.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_LocalFileTimeToFileTime.txt", "成功！/n");
}

HOOK_ITEM HookItem_SetFileTime = {0};
typedef BOOL  (WINAPI* PFN_SetFileTime)( HANDLE hFile,const FILETIME* lpCreationTime,const FILETIME* lpLastAccessTime,const FILETIME* lpLastWriteTime );
BOOL WINAPI NEW_SetFileTime( HANDLE hFile,const FILETIME* lpCreationTime,const FILETIME* lpLastAccessTime,const FILETIME* lpLastWriteTime ){
    BOOL Result = ((PFN_SetFileTime)HookItem_SetFileTime.dwOldValue)( hFile,lpCreationTime,lpLastAccessTime,lpLastWriteTime );
    return Result;
}

void WINAPI KEEP_SetFileTime(){
    if ( !RedirectApi ( "KERNEL32.dll", "SetFileTime", (DWORD)NEW_SetFileTime, &HookItem_SetFileTime ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SetFileTime.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SetFileTime.txt", "成功！/n");
}

HOOK_ITEM HookItem_GlobalSize = {0};
typedef SIZE_T  (WINAPI* PFN_GlobalSize)( HGLOBAL hMem );
SIZE_T WINAPI NEW_GlobalSize( HGLOBAL hMem ){
    SIZE_T Result = ((PFN_GlobalSize)HookItem_GlobalSize.dwOldValue)( hMem );
    return Result;
}

void WINAPI KEEP_GlobalSize(){
    if ( !RedirectApi ( "KERNEL32.dll", "GlobalSize", (DWORD)NEW_GlobalSize, &HookItem_GlobalSize ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalSize.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalSize.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetCurrentThreadId = {0};
typedef DWORD  (WINAPI* PFN_GetCurrentThreadId)(  );
DWORD WINAPI NEW_GetCurrentThreadId(  ){
    DWORD Result = ((PFN_GetCurrentThreadId)HookItem_GetCurrentThreadId.dwOldValue)(  );
    return Result;
}

void WINAPI KEEP_GetCurrentThreadId(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetCurrentThreadId", (DWORD)NEW_GetCurrentThreadId, &HookItem_GetCurrentThreadId ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentThreadId.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentThreadId.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetStartupInfoA = {0};
typedef VOID  (WINAPI* PFN_GetStartupInfoA)( LPSTARTUPINFO lpStartupInfo );
VOID WINAPI NEW_GetStartupInfoA( LPSTARTUPINFO lpStartupInfo ){
    ((PFN_GetStartupInfoA)HookItem_GetStartupInfoA.dwOldValue)( lpStartupInfo );
}

void WINAPI KEEP_GetStartupInfoA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetStartupInfoA", (DWORD)NEW_GetStartupInfoA, &HookItem_GetStartupInfoA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetStartupInfoA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetStartupInfoA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetCurrentDirectoryA = {0};
typedef DWORD  (WINAPI* PFN_GetCurrentDirectoryA)( DWORD nBufferLength,LPTSTR lpBuffer );
DWORD WINAPI NEW_GetCurrentDirectoryA( DWORD nBufferLength,LPTSTR lpBuffer ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentDirectoryA.txt", Change.String(IniKERNEL32_dll++) + " nBufferLength: " + Change.String((int)nBufferLength) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentDirectoryA.txt", Change.String(IniKERNEL32_dll++) + " lpBuffer: " + ((CString)lpBuffer) + "/n");
    DWORD Result = ((PFN_GetCurrentDirectoryA)HookItem_GetCurrentDirectoryA.dwOldValue)( nBufferLength,lpBuffer );
    return Result;
}

void WINAPI KEEP_GetCurrentDirectoryA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetCurrentDirectoryA", (DWORD)NEW_GetCurrentDirectoryA, &HookItem_GetCurrentDirectoryA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentDirectoryA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentDirectoryA.txt", "成功！/n");
}

HOOK_ITEM HookItem_WaitForMultipleObjects = {0};
typedef DWORD  (WINAPI* PFN_WaitForMultipleObjects)( DWORD nCount,const HANDLE* lpHandles,BOOL bWaitAll,DWORD dwMilliseconds );
DWORD WINAPI NEW_WaitForMultipleObjects( DWORD nCount,const HANDLE* lpHandles,BOOL bWaitAll,DWORD dwMilliseconds ){
    File.PlusString("C://ini//result//KERNEL32.dll_WaitForMultipleObjects.txt", Change.String(IniKERNEL32_dll++) + " nCount: " + Change.String((int)nCount) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WaitForMultipleObjects.txt", Change.String(IniKERNEL32_dll++) + " bWaitAll: " + Change.String((int)bWaitAll) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WaitForMultipleObjects.txt", Change.String(IniKERNEL32_dll++) + " dwMilliseconds: " + Change.String((int)dwMilliseconds) + "/n");
    DWORD Result = ((PFN_WaitForMultipleObjects)HookItem_WaitForMultipleObjects.dwOldValue)( nCount,lpHandles,bWaitAll,dwMilliseconds );
    return Result;
}

void WINAPI KEEP_WaitForMultipleObjects(){
    if ( !RedirectApi ( "KERNEL32.dll", "WaitForMultipleObjects", (DWORD)NEW_WaitForMultipleObjects, &HookItem_WaitForMultipleObjects ) )
        File.PlusString("C://ini//result//KERNEL32.dll_WaitForMultipleObjects.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_WaitForMultipleObjects.txt", "成功！/n");
}

HOOK_ITEM HookItem_SetEvent = {0};
typedef BOOL  (WINAPI* PFN_SetEvent)( HANDLE hEvent );
BOOL WINAPI NEW_SetEvent( HANDLE hEvent ){
    BOOL Result = ((PFN_SetEvent)HookItem_SetEvent.dwOldValue)( hEvent );
    return Result;
}

void WINAPI KEEP_SetEvent(){
    if ( !RedirectApi ( "KERNEL32.dll", "SetEvent", (DWORD)NEW_SetEvent, &HookItem_SetEvent ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SetEvent.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SetEvent.txt", "成功！/n");
}

HOOK_ITEM HookItem_ReleaseMutex = {0};
typedef BOOL  (WINAPI* PFN_ReleaseMutex)( HANDLE hMutex );
BOOL WINAPI NEW_ReleaseMutex( HANDLE hMutex ){
    BOOL Result = ((PFN_ReleaseMutex)HookItem_ReleaseMutex.dwOldValue)( hMutex );
    return Result;
}

void WINAPI KEEP_ReleaseMutex(){
    if ( !RedirectApi ( "KERNEL32.dll", "ReleaseMutex", (DWORD)NEW_ReleaseMutex, &HookItem_ReleaseMutex ) )
        File.PlusString("C://ini//result//KERNEL32.dll_ReleaseMutex.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_ReleaseMutex.txt", "成功！/n");
}

HOOK_ITEM HookItem_CopyFileA = {0};
typedef BOOL  (WINAPI* PFN_CopyFileA)( LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,LPPROGRESS_ROUTINE lpProgressRoutine,LPVOID lpData,LPBOOL pbCancel,DWORD dwCopyFlags );
BOOL WINAPI NEW_CopyFileA( LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,LPPROGRESS_ROUTINE lpProgressRoutine,LPVOID lpData,LPBOOL pbCancel,DWORD dwCopyFlags ){
    File.PlusString("C://ini//result//KERNEL32.dll_CopyFileA.txt", Change.String(IniKERNEL32_dll++) + " lpExistingFileName: " + ((CString)lpExistingFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CopyFileA.txt", Change.String(IniKERNEL32_dll++) + " lpNewFileName: " + ((CString)lpNewFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CopyFileA.txt", Change.String(IniKERNEL32_dll++) + " pbCancel: " + Change.String((int)pbCancel) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CopyFileA.txt", Change.String(IniKERNEL32_dll++) + " dwCopyFlags: " + Change.String((int)dwCopyFlags) + "/n");
    BOOL Result = ((PFN_CopyFileA)HookItem_CopyFileA.dwOldValue)( lpExistingFileName,lpNewFileName,lpProgressRoutine,lpData,pbCancel,dwCopyFlags );
    return Result;
}

void WINAPI KEEP_CopyFileA(){
    if ( !RedirectApi ( "KERNEL32.dll", "CopyFileA", (DWORD)NEW_CopyFileA, &HookItem_CopyFileA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CopyFileA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CopyFileA.txt", "成功！/n");
}

HOOK_ITEM HookItem_FileTimeToSystemTime = {0};
typedef BOOL  (WINAPI* PFN_FileTimeToSystemTime)( const FILETIME* lpFileTime,LPSYSTEMTIME lpSystemTime );
BOOL WINAPI NEW_FileTimeToSystemTime( const FILETIME* lpFileTime,LPSYSTEMTIME lpSystemTime ){
    BOOL Result = ((PFN_FileTimeToSystemTime)HookItem_FileTimeToSystemTime.dwOldValue)( lpFileTime,lpSystemTime );
    return Result;
}

void WINAPI KEEP_FileTimeToSystemTime(){
    if ( !RedirectApi ( "KERNEL32.dll", "FileTimeToSystemTime", (DWORD)NEW_FileTimeToSystemTime, &HookItem_FileTimeToSystemTime ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FileTimeToSystemTime.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FileTimeToSystemTime.txt", "成功！/n");
}

HOOK_ITEM HookItem_FileTimeToLocalFileTime = {0};
typedef BOOL  (WINAPI* PFN_FileTimeToLocalFileTime)( const FILETIME* lpFileTime,LPFILETIME lpLocalFileTime );
BOOL WINAPI NEW_FileTimeToLocalFileTime( const FILETIME* lpFileTime,LPFILETIME lpLocalFileTime ){
    BOOL Result = ((PFN_FileTimeToLocalFileTime)HookItem_FileTimeToLocalFileTime.dwOldValue)( lpFileTime,lpLocalFileTime );
    return Result;
}

void WINAPI KEEP_FileTimeToLocalFileTime(){
    if ( !RedirectApi ( "KERNEL32.dll", "FileTimeToLocalFileTime", (DWORD)NEW_FileTimeToLocalFileTime, &HookItem_FileTimeToLocalFileTime ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FileTimeToLocalFileTime.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FileTimeToLocalFileTime.txt", "成功！/n");
}

HOOK_ITEM HookItem_CreateEventA = {0};
typedef HANDLE  (WINAPI* PFN_CreateEventA)( LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName );
HANDLE WINAPI NEW_CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName ){
    File.PlusString("C://ini//result//KERNEL32.dll_CreateEventA.txt", Change.String(IniKERNEL32_dll++) + " bManualReset: " + Change.String((int)bManualReset) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateEventA.txt", Change.String(IniKERNEL32_dll++) + " bInitialState: " + Change.String((int)bInitialState) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateEventA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    HANDLE Result = ((PFN_CreateEventA)HookItem_CreateEventA.dwOldValue)( lpEventAttributes,bManualReset,bInitialState,lpName );
    return Result;
}

void WINAPI KEEP_CreateEventA(){
    if ( !RedirectApi ( "KERNEL32.dll", "CreateEventA", (DWORD)NEW_CreateEventA, &HookItem_CreateEventA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CreateEventA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CreateEventA.txt", "成功！/n");
}

HOOK_ITEM HookItem_CreateSemaphoreA = {0};
typedef HANDLE  (WINAPI* PFN_CreateSemaphoreA)( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName );
HANDLE WINAPI NEW_CreateSemaphoreA( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName ){
    File.PlusString("C://ini//result//KERNEL32.dll_CreateSemaphoreA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    HANDLE Result = ((PFN_CreateSemaphoreA)HookItem_CreateSemaphoreA.dwOldValue)( lpSemaphoreAttributes,lInitialCount,lMaximumCount,lpName );
    return Result;
}

void WINAPI KEEP_CreateSemaphoreA(){
    if ( !RedirectApi ( "KERNEL32.dll", "CreateSemaphoreA", (DWORD)NEW_CreateSemaphoreA, &HookItem_CreateSemaphoreA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CreateSemaphoreA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CreateSemaphoreA.txt", "成功！/n");
}

HOOK_ITEM HookItem_WideCharToMultiByte = {0};
typedef int  (WINAPI* PFN_WideCharToMultiByte)( UINT CodePage,DWORD dwFlags,LPCWSTR lpWideCharStr,int cchWideChar,LPSTR lpMultiByteStr,int cbMultiByte,LPCSTR lpDefaultChar,LPBOOL lpUsedDefaultChar );
int WINAPI NEW_WideCharToMultiByte( UINT CodePage,DWORD dwFlags,LPCWSTR lpWideCharStr,int cchWideChar,LPSTR lpMultiByteStr,int cbMultiByte,LPCSTR lpDefaultChar,LPBOOL lpUsedDefaultChar ){
    File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", Change.String(IniKERNEL32_dll++) + " CodePage: " + Change.String((int)CodePage) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", Change.String(IniKERNEL32_dll++) + " dwFlags: " + Change.String((int)dwFlags) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", Change.String(IniKERNEL32_dll++) + " cchWideChar: " + Change.String((int)cchWideChar) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", Change.String(IniKERNEL32_dll++) + " cbMultiByte: " + Change.String((int)cbMultiByte) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", Change.String(IniKERNEL32_dll++) + " lpDefaultChar: " + ((CString)lpDefaultChar) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", Change.String(IniKERNEL32_dll++) + " lpUsedDefaultChar: " + Change.String((int)lpUsedDefaultChar) + "/n");
    int Result = ((PFN_WideCharToMultiByte)HookItem_WideCharToMultiByte.dwOldValue)( CodePage,dwFlags,lpWideCharStr,cchWideChar,lpMultiByteStr,cbMultiByte,lpDefaultChar,lpUsedDefaultChar );
    return Result;
}

void WINAPI KEEP_WideCharToMultiByte(){
    if ( !RedirectApi ( "KERNEL32.dll", "WideCharToMultiByte", (DWORD)NEW_WideCharToMultiByte, &HookItem_WideCharToMultiByte ) )
        File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_WideCharToMultiByte.txt", "成功！/n");
}

HOOK_ITEM HookItem_lstrcmpiA = {0};
typedef int  (WINAPI* PFN_lstrcmpiA)( LPCTSTR lpString1,LPCTSTR lpString2 );
int WINAPI NEW_lstrcmpiA( LPCTSTR lpString1,LPCTSTR lpString2 ){
    File.PlusString("C://ini//result//KERNEL32.dll_lstrcmpiA.txt", Change.String(IniKERNEL32_dll++) + " lpString1: " + ((CString)lpString1) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_lstrcmpiA.txt", Change.String(IniKERNEL32_dll++) + " lpString2: " + ((CString)lpString2) + "/n");
    int Result = ((PFN_lstrcmpiA)HookItem_lstrcmpiA.dwOldValue)( lpString1,lpString2 );
    return Result;
}

void WINAPI KEEP_lstrcmpiA(){
    if ( !RedirectApi ( "KERNEL32.dll", "lstrcmpiA", (DWORD)NEW_lstrcmpiA, &HookItem_lstrcmpiA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_lstrcmpiA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_lstrcmpiA.txt", "成功！/n");
}

HOOK_ITEM HookItem_WriteFile = {0};
typedef BOOL  (WINAPI* PFN_WriteFile)( HANDLE hFile,LPCVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped );
BOOL WINAPI NEW_WriteFile( HANDLE hFile,LPCVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped ){
    File.PlusString("C://ini//result//KERNEL32.dll_WriteFile.txt", Change.String(IniKERNEL32_dll++) + " nNumberOfBytesToWrite: " + Change.String((int)nNumberOfBytesToWrite) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WriteFile.txt", Change.String(IniKERNEL32_dll++) + " lpNumberOfBytesWritten: " + Change.String((int)lpNumberOfBytesWritten) + "/n");
    BOOL Result = ((PFN_WriteFile)HookItem_WriteFile.dwOldValue)( hFile,lpBuffer,nNumberOfBytesToWrite,lpNumberOfBytesWritten,lpOverlapped );
    return Result;
}

void WINAPI KEEP_WriteFile(){
    if ( !RedirectApi ( "KERNEL32.dll", "WriteFile", (DWORD)NEW_WriteFile, &HookItem_WriteFile ) )
        File.PlusString("C://ini//result//KERNEL32.dll_WriteFile.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_WriteFile.txt", "成功！/n");
}

HOOK_ITEM HookItem_CreateFileA = {0};
typedef HANDLE  (WINAPI* PFN_CreateFileA)( LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile );
HANDLE WINAPI NEW_CreateFileA( LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile ){
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", Change.String(IniKERNEL32_dll++) + " dwDesiredAccess: " + Change.String((int)dwDesiredAccess) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", Change.String(IniKERNEL32_dll++) + " dwShareMode: " + Change.String((int)dwShareMode) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", Change.String(IniKERNEL32_dll++) + " dwCreationDisposition: " + Change.String((int)dwCreationDisposition) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", Change.String(IniKERNEL32_dll++) + " dwFlagsAndAttributes: " + Change.String((int)dwFlagsAndAttributes) + "/n");
    HANDLE Result = ((PFN_CreateFileA)HookItem_CreateFileA.dwOldValue)( lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDisposition,dwFlagsAndAttributes,hTemplateFile );
    return Result;
}

void WINAPI KEEP_CreateFileA(){
    if ( !RedirectApi ( "KERNEL32.dll", "CreateFileA", (DWORD)NEW_CreateFileA, &HookItem_CreateFileA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CreateFileA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetVersion = {0};
typedef DWORD  (WINAPI* PFN_GetVersion)(  );
DWORD WINAPI NEW_GetVersion(  ){
    DWORD Result = ((PFN_GetVersion)HookItem_GetVersion.dwOldValue)(  );
    return Result;
}

void WINAPI KEEP_GetVersion(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetVersion", (DWORD)NEW_GetVersion, &HookItem_GetVersion ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetVersion.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetVersion.txt", "成功！/n");
}

HOOK_ITEM HookItem_Process32Next = {0};
typedef BOOL  (WINAPI* PFN_Process32Next)( HANDLE hSnapshot,LPPROCESSENTRY32 lppe );
BOOL WINAPI NEW_Process32Next( HANDLE hSnapshot,LPPROCESSENTRY32 lppe ){
    BOOL Result = ((PFN_Process32Next)HookItem_Process32Next.dwOldValue)( hSnapshot,lppe );
    return Result;
}

void WINAPI KEEP_Process32Next(){
    if ( !RedirectApi ( "KERNEL32.dll", "Process32Next", (DWORD)NEW_Process32Next, &HookItem_Process32Next ) )
        File.PlusString("C://ini//result//KERNEL32.dll_Process32Next.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_Process32Next.txt", "成功！/n");
}

HOOK_ITEM HookItem_Process32First = {0};
typedef BOOL  (WINAPI* PFN_Process32First)( HANDLE hSnapshot,LPPROCESSENTRY32 lppe );
BOOL WINAPI NEW_Process32First( HANDLE hSnapshot,LPPROCESSENTRY32 lppe ){
    BOOL Result = ((PFN_Process32First)HookItem_Process32First.dwOldValue)( hSnapshot,lppe );
    return Result;
}

void WINAPI KEEP_Process32First(){
    if ( !RedirectApi ( "KERNEL32.dll", "Process32First", (DWORD)NEW_Process32First, &HookItem_Process32First ) )
        File.PlusString("C://ini//result//KERNEL32.dll_Process32First.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_Process32First.txt", "成功！/n");
}

HOOK_ITEM HookItem_CreateToolhelp32Snapshot = {0};
typedef HANDLE  (WINAPI* PFN_CreateToolhelp32Snapshot)( DWORD dwFlags,DWORD th32ProcessID );
HANDLE WINAPI NEW_CreateToolhelp32Snapshot( DWORD dwFlags,DWORD th32ProcessID ){
    File.PlusString("C://ini//result//KERNEL32.dll_CreateToolhelp32Snapshot.txt", Change.String(IniKERNEL32_dll++) + " dwFlags: " + Change.String((int)dwFlags) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateToolhelp32Snapshot.txt", Change.String(IniKERNEL32_dll++) + " th32ProcessID: " + Change.String((int)th32ProcessID) + "/n");
    HANDLE Result = ((PFN_CreateToolhelp32Snapshot)HookItem_CreateToolhelp32Snapshot.dwOldValue)( dwFlags,th32ProcessID );
    return Result;
}

void WINAPI KEEP_CreateToolhelp32Snapshot(){
    if ( !RedirectApi ( "KERNEL32.dll", "CreateToolhelp32Snapshot", (DWORD)NEW_CreateToolhelp32Snapshot, &HookItem_CreateToolhelp32Snapshot ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CreateToolhelp32Snapshot.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CreateToolhelp32Snapshot.txt", "成功！/n");
}

HOOK_ITEM HookItem_TerminateProcess = {0};
typedef BOOL  (WINAPI* PFN_TerminateProcess)( HANDLE hProcess,UINT uExitCode );
BOOL WINAPI NEW_TerminateProcess( HANDLE hProcess,UINT uExitCode ){
    File.PlusString("C://ini//result//KERNEL32.dll_TerminateProcess.txt", Change.String(IniKERNEL32_dll++) + " uExitCode: " + Change.String((int)uExitCode) + "/n");
    BOOL Result = ((PFN_TerminateProcess)HookItem_TerminateProcess.dwOldValue)( hProcess,uExitCode );
    return Result;
}

void WINAPI KEEP_TerminateProcess(){
    if ( !RedirectApi ( "KERNEL32.dll", "TerminateProcess", (DWORD)NEW_TerminateProcess, &HookItem_TerminateProcess ) )
        File.PlusString("C://ini//result//KERNEL32.dll_TerminateProcess.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_TerminateProcess.txt", "成功！/n");
}

HOOK_ITEM HookItem_SetFileAttributesA = {0};
typedef BOOL  (WINAPI* PFN_SetFileAttributesA)( LPCTSTR lpFileName,DWORD dwFileAttributes );
BOOL WINAPI NEW_SetFileAttributesA( LPCTSTR lpFileName,DWORD dwFileAttributes ){
    File.PlusString("C://ini//result//KERNEL32.dll_SetFileAttributesA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_SetFileAttributesA.txt", Change.String(IniKERNEL32_dll++) + " dwFileAttributes: " + Change.String((int)dwFileAttributes) + "/n");
    BOOL Result = ((PFN_SetFileAttributesA)HookItem_SetFileAttributesA.dwOldValue)( lpFileName,dwFileAttributes );
    return Result;
}

void WINAPI KEEP_SetFileAttributesA(){
    if ( !RedirectApi ( "KERNEL32.dll", "SetFileAttributesA", (DWORD)NEW_SetFileAttributesA, &HookItem_SetFileAttributesA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SetFileAttributesA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SetFileAttributesA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetExitCodeProcess = {0};
typedef BOOL  (WINAPI* PFN_GetExitCodeProcess)( HANDLE hProcess,LPDWORD lpExitCode );
BOOL WINAPI NEW_GetExitCodeProcess( HANDLE hProcess,LPDWORD lpExitCode ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetExitCodeProcess.txt", Change.String(IniKERNEL32_dll++) + " lpExitCode: " + Change.String((int)lpExitCode) + "/n");
    BOOL Result = ((PFN_GetExitCodeProcess)HookItem_GetExitCodeProcess.dwOldValue)( hProcess,lpExitCode );
    return Result;
}

void WINAPI KEEP_GetExitCodeProcess(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetExitCodeProcess", (DWORD)NEW_GetExitCodeProcess, &HookItem_GetExitCodeProcess ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetExitCodeProcess.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetExitCodeProcess.txt", "成功！/n");
}

HOOK_ITEM HookItem_OpenProcess = {0};
typedef HANDLE  (WINAPI* PFN_OpenProcess)( DWORD dwDesiredAccess,BOOL bInheritHandle,DWORD dwProcessId );
HANDLE WINAPI NEW_OpenProcess( DWORD dwDesiredAccess,BOOL bInheritHandle,DWORD dwProcessId ){
    File.PlusString("C://ini//result//KERNEL32.dll_OpenProcess.txt", Change.String(IniKERNEL32_dll++) + " dwDesiredAccess: " + Change.String((int)dwDesiredAccess) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_OpenProcess.txt", Change.String(IniKERNEL32_dll++) + " bInheritHandle: " + Change.String((int)bInheritHandle) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_OpenProcess.txt", Change.String(IniKERNEL32_dll++) + " dwProcessId: " + Change.String((int)dwProcessId) + "/n");
    HANDLE Result = ((PFN_OpenProcess)HookItem_OpenProcess.dwOldValue)( dwDesiredAccess,bInheritHandle,dwProcessId );
    return Result;
}

void WINAPI KEEP_OpenProcess(){
    if ( !RedirectApi ( "KERNEL32.dll", "OpenProcess", (DWORD)NEW_OpenProcess, &HookItem_OpenProcess ) )
        File.PlusString("C://ini//result//KERNEL32.dll_OpenProcess.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_OpenProcess.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetCurrentProcess = {0};
typedef HANDLE  (WINAPI* PFN_GetCurrentProcess)(  );
HANDLE WINAPI NEW_GetCurrentProcess(  ){
    HANDLE Result = ((PFN_GetCurrentProcess)HookItem_GetCurrentProcess.dwOldValue)(  );
    return Result;
}

void WINAPI KEEP_GetCurrentProcess(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetCurrentProcess", (DWORD)NEW_GetCurrentProcess, &HookItem_GetCurrentProcess ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentProcess.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentProcess.txt", "成功！/n");
}

HOOK_ITEM HookItem_FindClose = {0};
typedef BOOL  (WINAPI* PFN_FindClose)( HANDLE hFindFile );
BOOL WINAPI NEW_FindClose( HANDLE hFindFile ){
    BOOL Result = ((PFN_FindClose)HookItem_FindClose.dwOldValue)( hFindFile );
    return Result;
}

void WINAPI KEEP_FindClose(){
    if ( !RedirectApi ( "KERNEL32.dll", "FindClose", (DWORD)NEW_FindClose, &HookItem_FindClose ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FindClose.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FindClose.txt", "成功！/n");
}

HOOK_ITEM HookItem_FindFirstFileA = {0};
typedef HANDLE  (WINAPI* PFN_FindFirstFileA)( LPCTSTR lpFileName,LPWIN32_FIND_DATA lpFindFileData );
HANDLE WINAPI NEW_FindFirstFileA( LPCTSTR lpFileName,LPWIN32_FIND_DATA lpFindFileData ){
    File.PlusString("C://ini//result//KERNEL32.dll_FindFirstFileA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    HANDLE Result = ((PFN_FindFirstFileA)HookItem_FindFirstFileA.dwOldValue)( lpFileName,lpFindFileData );
    return Result;
}

void WINAPI KEEP_FindFirstFileA(){
    if ( !RedirectApi ( "KERNEL32.dll", "FindFirstFileA", (DWORD)NEW_FindFirstFileA, &HookItem_FindFirstFileA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FindFirstFileA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FindFirstFileA.txt", "成功！/n");
}

void WINAPI KEEP_FindFirstFileA(){


}

HOOK_ITEM HookItem_GetProcAddress = {0};
typedef FARPROC  (WINAPI* PFN_GetProcAddress)( HMODULE hModule,LPCSTR lpProcName );
FARPROC WINAPI NEW_GetProcAddress( HMODULE hModule,LPCSTR lpProcName ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetProcAddress.txt", Change.String(IniKERNEL32_dll++) + " lpProcName: " + ((CString)lpProcName) + "/n");
    FARPROC Result = ((PFN_GetProcAddress)HookItem_GetProcAddress.dwOldValue)( hModule,lpProcName );
    return Result;
}

void WINAPI KEEP_GetProcAddress(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetProcAddress", (DWORD)NEW_GetProcAddress, &HookItem_GetProcAddress ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetProcAddress.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetProcAddress.txt", "成功！/n");
}

HOOK_ITEM HookItem_WritePrivateProfileStringA = {0};
typedef BOOL  (WINAPI* PFN_WritePrivateProfileStringA)( LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString,LPCTSTR lpFileName );
BOOL WINAPI NEW_WritePrivateProfileStringA( LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString,LPCTSTR lpFileName ){
    File.PlusString("C://ini//result//KERNEL32.dll_WritePrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpAppName: " + ((CString)lpAppName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WritePrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpKeyName: " + ((CString)lpKeyName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WritePrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpString: " + ((CString)lpString) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WritePrivateProfileStringA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    BOOL Result = ((PFN_WritePrivateProfileStringA)HookItem_WritePrivateProfileStringA.dwOldValue)( lpAppName,lpKeyName,lpString,lpFileName );
    return Result;
}

void WINAPI KEEP_WritePrivateProfileStringA(){
    if ( !RedirectApi ( "KERNEL32.dll", "WritePrivateProfileStringA", (DWORD)NEW_WritePrivateProfileStringA, &HookItem_WritePrivateProfileStringA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_WritePrivateProfileStringA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_WritePrivateProfileStringA.txt", "成功！/n");
}

HOOK_ITEM HookItem_TerminateThread = {0};
typedef BOOL  (WINAPI* PFN_TerminateThread)( HANDLE hThread,DWORD dwExitCode );
BOOL WINAPI NEW_TerminateThread( HANDLE hThread,DWORD dwExitCode ){
    File.PlusString("C://ini//result//KERNEL32.dll_TerminateThread.txt", Change.String(IniKERNEL32_dll++) + " dwExitCode: " + Change.String((int)dwExitCode) + "/n");
    BOOL Result = ((PFN_TerminateThread)HookItem_TerminateThread.dwOldValue)( hThread,dwExitCode );
    return Result;
}

void WINAPI KEEP_TerminateThread(){
    if ( !RedirectApi ( "KERNEL32.dll", "TerminateThread", (DWORD)NEW_TerminateThread, &HookItem_TerminateThread ) )
        File.PlusString("C://ini//result//KERNEL32.dll_TerminateThread.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_TerminateThread.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetExitCodeThread = {0};
typedef BOOL  (WINAPI* PFN_GetExitCodeThread)( HANDLE hThread,LPDWORD lpExitCode );
BOOL WINAPI NEW_GetExitCodeThread( HANDLE hThread,LPDWORD lpExitCode ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetExitCodeThread.txt", Change.String(IniKERNEL32_dll++) + " lpExitCode: " + Change.String((int)lpExitCode) + "/n");
    BOOL Result = ((PFN_GetExitCodeThread)HookItem_GetExitCodeThread.dwOldValue)( hThread,lpExitCode );
    return Result;
}

void WINAPI KEEP_GetExitCodeThread(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetExitCodeThread", (DWORD)NEW_GetExitCodeThread, &HookItem_GetExitCodeThread ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetExitCodeThread.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetExitCodeThread.txt", "成功！/n");
}

HOOK_ITEM HookItem_SetThreadPriority = {0};
typedef BOOL  (WINAPI* PFN_SetThreadPriority)( HANDLE hThread,int nPriority );
BOOL WINAPI NEW_SetThreadPriority( HANDLE hThread,int nPriority ){
    File.PlusString("C://ini//result//KERNEL32.dll_SetThreadPriority.txt", Change.String(IniKERNEL32_dll++) + " nPriority: " + Change.String((int)nPriority) + "/n");
    BOOL Result = ((PFN_SetThreadPriority)HookItem_SetThreadPriority.dwOldValue)( hThread,nPriority );
    return Result;
}

void WINAPI KEEP_SetThreadPriority(){
    if ( !RedirectApi ( "KERNEL32.dll", "SetThreadPriority", (DWORD)NEW_SetThreadPriority, &HookItem_SetThreadPriority ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SetThreadPriority.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SetThreadPriority.txt", "成功！/n");
}

HOOK_ITEM HookItem_OutputDebugStringA = {0};
typedef void  (WINAPI* PFN_OutputDebugStringA)( LPCTSTR lpOutputString );
void WINAPI NEW_OutputDebugStringA( LPCTSTR lpOutputString ){
    File.PlusString("C://ini//result//KERNEL32.dll_OutputDebugStringA.txt", Change.String(IniKERNEL32_dll++) + " lpOutputString: " + ((CString)lpOutputString) + "/n");
    ((PFN_OutputDebugStringA)HookItem_OutputDebugStringA.dwOldValue)( lpOutputString );
}

void WINAPI KEEP_OutputDebugStringA(){
    if ( !RedirectApi ( "KERNEL32.dll", "OutputDebugStringA", (DWORD)NEW_OutputDebugStringA, &HookItem_OutputDebugStringA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_OutputDebugStringA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_OutputDebugStringA.txt", "成功！/n");
}

//Ini KERNEL32.dll;CreateThread
//Ini KERNEL32.dll;CreateDirectoryA
HOOK_ITEM HookItem_GlobalFree = {0};
typedef HGLOBAL  (WINAPI* PFN_GlobalFree)( HGLOBAL hMem );
HGLOBAL WINAPI NEW_GlobalFree( HGLOBAL hMem ){
    HGLOBAL Result = ((PFN_GlobalFree)HookItem_GlobalFree.dwOldValue)( hMem );
    return Result;
}

void WINAPI KEEP_GlobalFree(){
    if ( !RedirectApi ( "KERNEL32.dll", "GlobalFree", (DWORD)NEW_GlobalFree, &HookItem_GlobalFree ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalFree.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalFree.txt", "成功！/n");
}

HOOK_ITEM HookItem_GlobalUnlock = {0};
typedef BOOL  (WINAPI* PFN_GlobalUnlock)( HGLOBAL hMem );
BOOL WINAPI NEW_GlobalUnlock( HGLOBAL hMem ){
    BOOL Result = ((PFN_GlobalUnlock)HookItem_GlobalUnlock.dwOldValue)( hMem );
    return Result;
}

void WINAPI KEEP_GlobalUnlock(){
    if ( !RedirectApi ( "KERNEL32.dll", "GlobalUnlock", (DWORD)NEW_GlobalUnlock, &HookItem_GlobalUnlock ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalUnlock.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalUnlock.txt", "成功！/n");
}

HOOK_ITEM HookItem_GlobalLock = {0};
typedef LPVOID  (WINAPI* PFN_GlobalLock)( HGLOBAL hMem );
LPVOID WINAPI NEW_GlobalLock( HGLOBAL hMem ){
    LPVOID Result = ((PFN_GlobalLock)HookItem_GlobalLock.dwOldValue)( hMem );
    return Result;
}

void WINAPI KEEP_GlobalLock(){
    if ( !RedirectApi ( "KERNEL32.dll", "GlobalLock", (DWORD)NEW_GlobalLock, &HookItem_GlobalLock ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalLock.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalLock.txt", "成功！/n");
}

HOOK_ITEM HookItem_GlobalAlloc = {0};
typedef HGLOBAL  (WINAPI* PFN_GlobalAlloc)( UINT uFlags,SIZE_T dwBytes );
HGLOBAL WINAPI NEW_GlobalAlloc( UINT uFlags,SIZE_T dwBytes ){
    File.PlusString("C://ini//result//KERNEL32.dll_GlobalAlloc.txt", Change.String(IniKERNEL32_dll++) + " uFlags: " + Change.String((int)uFlags) + "/n");
    HGLOBAL Result = ((PFN_GlobalAlloc)HookItem_GlobalAlloc.dwOldValue)( uFlags,dwBytes );
    return Result;
}

void WINAPI KEEP_GlobalAlloc(){
    if ( !RedirectApi ( "KERNEL32.dll", "GlobalAlloc", (DWORD)NEW_GlobalAlloc, &HookItem_GlobalAlloc ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalAlloc.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GlobalAlloc.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetLastError = {0};
typedef DWORD  (WINAPI* PFN_GetLastError)(  );
DWORD WINAPI NEW_GetLastError(  ){
    DWORD Result = ((PFN_GetLastError)HookItem_GetLastError.dwOldValue)(  );
    return Result;
}

void WINAPI KEEP_GetLastError(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetLastError", (DWORD)NEW_GetLastError, &HookItem_GetLastError ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetLastError.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetLastError.txt", "成功！/n");
}

HOOK_ITEM HookItem_MoveFileA = {0};
typedef BOOL  (WINAPI* PFN_MoveFileA)( LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,DWORD dwFlags );
BOOL WINAPI NEW_MoveFileA( LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,DWORD dwFlags ){
    File.PlusString("C://ini//result//KERNEL32.dll_MoveFileA.txt", Change.String(IniKERNEL32_dll++) + " lpExistingFileName: " + ((CString)lpExistingFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MoveFileA.txt", Change.String(IniKERNEL32_dll++) + " lpNewFileName: " + ((CString)lpNewFileName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MoveFileA.txt", Change.String(IniKERNEL32_dll++) + " dwFlags: " + Change.String((int)dwFlags) + "/n");
    BOOL Result = ((PFN_MoveFileA)HookItem_MoveFileA.dwOldValue)( lpExistingFileName,lpNewFileName,dwFlags );
    return Result;
}

void WINAPI KEEP_MoveFileA(){
    if ( !RedirectApi ( "KERNEL32.dll", "MoveFileA", (DWORD)NEW_MoveFileA, &HookItem_MoveFileA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_MoveFileA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_MoveFileA.txt", "成功！/n");
}

HOOK_ITEM HookItem_DeleteFileA = {0};
typedef BOOL  (WINAPI* PFN_DeleteFileA)( LPCTSTR lpFileName );
BOOL WINAPI NEW_DeleteFileA( LPCTSTR lpFileName ){
    File.PlusString("C://ini//result//KERNEL32.dll_DeleteFileA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    BOOL Result = ((PFN_DeleteFileA)HookItem_DeleteFileA.dwOldValue)( lpFileName );
    return Result;
}

void WINAPI KEEP_DeleteFileA(){
    if ( !RedirectApi ( "KERNEL32.dll", "DeleteFileA", (DWORD)NEW_DeleteFileA, &HookItem_DeleteFileA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_DeleteFileA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_DeleteFileA.txt", "成功！/n");
}

HOOK_ITEM HookItem_FindNextFileA = {0};
typedef BOOL  (WINAPI* PFN_FindNextFileA)( HANDLE hFindFile,LPWIN32_FIND_DATA lpFindFileData );
BOOL WINAPI NEW_FindNextFileA( HANDLE hFindFile,LPWIN32_FIND_DATA lpFindFileData ){
    BOOL Result = ((PFN_FindNextFileA)HookItem_FindNextFileA.dwOldValue)( hFindFile,lpFindFileData );
    return Result;
}

void WINAPI KEEP_FindNextFileA(){
    if ( !RedirectApi ( "KERNEL32.dll", "FindNextFileA", (DWORD)NEW_FindNextFileA, &HookItem_FindNextFileA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_FindNextFileA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_FindNextFileA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetVersionExA = {0};
typedef BOOL  (WINAPI* PFN_GetVersionExA)( LPOSVERSIONINFO lpVersionInfo );
BOOL WINAPI NEW_GetVersionExA( LPOSVERSIONINFO lpVersionInfo ){
    BOOL Result = ((PFN_GetVersionExA)HookItem_GetVersionExA.dwOldValue)( lpVersionInfo );
    return Result;
}

void WINAPI KEEP_GetVersionExA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetVersionExA", (DWORD)NEW_GetVersionExA, &HookItem_GetVersionExA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetVersionExA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetVersionExA.txt", "成功！/n");
}

HOOK_ITEM HookItem_WinExec = {0};
typedef UINT  (WINAPI* PFN_WinExec)( LPCSTR lpCmdLine,UINT uCmdShow );
UINT WINAPI NEW_WinExec( LPCSTR lpCmdLine,UINT uCmdShow ){
    File.PlusString("C://ini//result//KERNEL32.dll_WinExec.txt", Change.String(IniKERNEL32_dll++) + " lpCmdLine: " + ((CString)lpCmdLine) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_WinExec.txt", Change.String(IniKERNEL32_dll++) + " uCmdShow: " + Change.String((int)uCmdShow) + "/n");
    UINT Result = ((PFN_WinExec)HookItem_WinExec.dwOldValue)( lpCmdLine,uCmdShow );
    return Result;
}

void WINAPI KEEP_WinExec(){
    if ( !RedirectApi ( "KERNEL32.dll", "WinExec", (DWORD)NEW_WinExec, &HookItem_WinExec ) )
        File.PlusString("C://ini//result//KERNEL32.dll_WinExec.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_WinExec.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetTickCount = {0};
typedef DWORD  (WINAPI* PFN_GetTickCount)(  );
DWORD WINAPI NEW_GetTickCount(  ){
    DWORD Result = ((PFN_GetTickCount)HookItem_GetTickCount.dwOldValue)(  );
    return Result;
}

void WINAPI KEEP_GetTickCount(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetTickCount", (DWORD)NEW_GetTickCount, &HookItem_GetTickCount ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetTickCount.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetTickCount.txt", "成功！/n");
}

HOOK_ITEM HookItem_UnmapViewOfFile = {0};
typedef BOOL  (WINAPI* PFN_UnmapViewOfFile)( LPCVOID lpBaseAddress );
BOOL WINAPI NEW_UnmapViewOfFile( LPCVOID lpBaseAddress ){
    BOOL Result = ((PFN_UnmapViewOfFile)HookItem_UnmapViewOfFile.dwOldValue)( lpBaseAddress );
    return Result;
}

void WINAPI KEEP_UnmapViewOfFile(){
    if ( !RedirectApi ( "KERNEL32.dll", "UnmapViewOfFile", (DWORD)NEW_UnmapViewOfFile, &HookItem_UnmapViewOfFile ) )
        File.PlusString("C://ini//result//KERNEL32.dll_UnmapViewOfFile.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_UnmapViewOfFile.txt", "成功！/n");
}

HOOK_ITEM HookItem_MapViewOfFile = {0};
typedef LPVOID  (WINAPI* PFN_MapViewOfFile)( HANDLE hFileMappingObject,DWORD dwDesiredAccess,DWORD dwFileOffsetHigh,DWORD dwFileOffsetLow,SIZE_T dwNumberOfBytesToMap );
LPVOID WINAPI NEW_MapViewOfFile( HANDLE hFileMappingObject,DWORD dwDesiredAccess,DWORD dwFileOffsetHigh,DWORD dwFileOffsetLow,SIZE_T dwNumberOfBytesToMap ){
    File.PlusString("C://ini//result//KERNEL32.dll_MapViewOfFile.txt", Change.String(IniKERNEL32_dll++) + " dwDesiredAccess: " + Change.String((int)dwDesiredAccess) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MapViewOfFile.txt", Change.String(IniKERNEL32_dll++) + " dwFileOffsetHigh: " + Change.String((int)dwFileOffsetHigh) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_MapViewOfFile.txt", Change.String(IniKERNEL32_dll++) + " dwFileOffsetLow: " + Change.String((int)dwFileOffsetLow) + "/n");
    LPVOID Result = ((PFN_MapViewOfFile)HookItem_MapViewOfFile.dwOldValue)( hFileMappingObject,dwDesiredAccess,dwFileOffsetHigh,dwFileOffsetLow,dwNumberOfBytesToMap );
    return Result;
}

void WINAPI KEEP_MapViewOfFile(){
    if ( !RedirectApi ( "KERNEL32.dll", "MapViewOfFile", (DWORD)NEW_MapViewOfFile, &HookItem_MapViewOfFile ) )
        File.PlusString("C://ini//result//KERNEL32.dll_MapViewOfFile.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_MapViewOfFile.txt", "成功！/n");
}

HOOK_ITEM HookItem_CreateFileMappingA = {0};
typedef HANDLE  (WINAPI* PFN_CreateFileMappingA)( HANDLE hFile,LPSECURITY_ATTRIBUTES lpAttributes,DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName );
HANDLE WINAPI NEW_CreateFileMappingA( HANDLE hFile,LPSECURITY_ATTRIBUTES lpAttributes,DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName ){
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " flProtect: " + Change.String((int)flProtect) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " dwMaximumSizeHigh: " + Change.String((int)dwMaximumSizeHigh) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " dwMaximumSizeLow: " + Change.String((int)dwMaximumSizeLow) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateFileMappingA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    HANDLE Result = ((PFN_CreateFileMappingA)HookItem_CreateFileMappingA.dwOldValue)( hFile,lpAttributes,flProtect,dwMaximumSizeHigh,dwMaximumSizeLow,lpName );
    return Result;
}

void WINAPI KEEP_CreateFileMappingA(){
    if ( !RedirectApi ( "KERNEL32.dll", "CreateFileMappingA", (DWORD)NEW_CreateFileMappingA, &HookItem_CreateFileMappingA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CreateFileMappingA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CreateFileMappingA.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetPrivateProfileIntA = {0};
typedef UINT  (WINAPI* PFN_GetPrivateProfileIntA)( LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault,LPCTSTR lpFileName );
UINT WINAPI NEW_GetPrivateProfileIntA( LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault,LPCTSTR lpFileName ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileIntA.txt", Change.String(IniKERNEL32_dll++) + " lpAppName: " + ((CString)lpAppName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileIntA.txt", Change.String(IniKERNEL32_dll++) + " lpKeyName: " + ((CString)lpKeyName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileIntA.txt", Change.String(IniKERNEL32_dll++) + " nDefault: " + Change.String((int)nDefault) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileIntA.txt", Change.String(IniKERNEL32_dll++) + " lpFileName: " + ((CString)lpFileName) + "/n");
    UINT Result = ((PFN_GetPrivateProfileIntA)HookItem_GetPrivateProfileIntA.dwOldValue)( lpAppName,lpKeyName,nDefault,lpFileName );
    return Result;
}

void WINAPI KEEP_GetPrivateProfileIntA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetPrivateProfileIntA", (DWORD)NEW_GetPrivateProfileIntA, &HookItem_GetPrivateProfileIntA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileIntA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetPrivateProfileIntA.txt", "成功！/n");
}

HOOK_ITEM HookItem_CreateMutexA = {0};
typedef HANDLE  (WINAPI* PFN_CreateMutexA)( LPSECURITY_ATTRIBUTES lpMutexAttributes,BOOL bInitialOwner,LPCTSTR lpName );
HANDLE WINAPI NEW_CreateMutexA( LPSECURITY_ATTRIBUTES lpMutexAttributes,BOOL bInitialOwner,LPCTSTR lpName ){
    File.PlusString("C://ini//result//KERNEL32.dll_CreateMutexA.txt", Change.String(IniKERNEL32_dll++) + " bInitialOwner: " + Change.String((int)bInitialOwner) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_CreateMutexA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    HANDLE Result = ((PFN_CreateMutexA)HookItem_CreateMutexA.dwOldValue)( lpMutexAttributes,bInitialOwner,lpName );
    return Result;
}

void WINAPI KEEP_CreateMutexA(){
    if ( !RedirectApi ( "KERNEL32.dll", "CreateMutexA", (DWORD)NEW_CreateMutexA, &HookItem_CreateMutexA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_CreateMutexA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_CreateMutexA.txt", "成功！/n");
}

HOOK_ITEM HookItem_OpenMutexA = {0};
typedef HANDLE  (WINAPI* PFN_OpenMutexA)( DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName );
HANDLE WINAPI NEW_OpenMutexA( DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName ){
    File.PlusString("C://ini//result//KERNEL32.dll_OpenMutexA.txt", Change.String(IniKERNEL32_dll++) + " dwDesiredAccess: " + Change.String((int)dwDesiredAccess) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_OpenMutexA.txt", Change.String(IniKERNEL32_dll++) + " bInheritHandle: " + Change.String((int)bInheritHandle) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_OpenMutexA.txt", Change.String(IniKERNEL32_dll++) + " lpName: " + ((CString)lpName) + "/n");
    HANDLE Result = ((PFN_OpenMutexA)HookItem_OpenMutexA.dwOldValue)( dwDesiredAccess,bInheritHandle,lpName );
    return Result;
}

void WINAPI KEEP_OpenMutexA(){
    if ( !RedirectApi ( "KERNEL32.dll", "OpenMutexA", (DWORD)NEW_OpenMutexA, &HookItem_OpenMutexA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_OpenMutexA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_OpenMutexA.txt", "成功！/n");
}

//Ini KERNEL32.dll;CreateProcessA
//Ini KERNEL32.dll;GetModuleHandleA
HOOK_ITEM HookItem_GetCurrentProcessId = {0};
typedef DWORD  (WINAPI* PFN_GetCurrentProcessId)(  );
DWORD WINAPI NEW_GetCurrentProcessId(  ){
    DWORD Result = ((PFN_GetCurrentProcessId)HookItem_GetCurrentProcessId.dwOldValue)(  );
    return Result;
}

void WINAPI KEEP_GetCurrentProcessId(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetCurrentProcessId", (DWORD)NEW_GetCurrentProcessId, &HookItem_GetCurrentProcessId ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentProcessId.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetCurrentProcessId.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetTempPathA = {0};
typedef DWORD  (WINAPI* PFN_GetTempPathA)( DWORD nBufferLength,LPTSTR lpBuffer );
DWORD WINAPI NEW_GetTempPathA( DWORD nBufferLength,LPTSTR lpBuffer ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetTempPathA.txt", Change.String(IniKERNEL32_dll++) + " nBufferLength: " + Change.String((int)nBufferLength) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetTempPathA.txt", Change.String(IniKERNEL32_dll++) + " lpBuffer: " + ((CString)lpBuffer) + "/n");
    DWORD Result = ((PFN_GetTempPathA)HookItem_GetTempPathA.dwOldValue)( nBufferLength,lpBuffer );
    return Result;
}

void WINAPI KEEP_GetTempPathA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetTempPathA", (DWORD)NEW_GetTempPathA, &HookItem_GetTempPathA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetTempPathA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetTempPathA.txt", "成功！/n");
}

HOOK_ITEM HookItem_lstrcatA = {0};
typedef LPTSTR  (WINAPI* PFN_lstrcatA)( LPTSTR lpString1,LPTSTR lpString2 );
LPTSTR WINAPI NEW_lstrcatA( LPTSTR lpString1,LPTSTR lpString2 ){
    File.PlusString("C://ini//result//KERNEL32.dll_lstrcatA.txt", Change.String(IniKERNEL32_dll++) + " lpString1: " + ((CString)lpString1) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_lstrcatA.txt", Change.String(IniKERNEL32_dll++) + " lpString2: " + ((CString)lpString2) + "/n");
    LPTSTR Result = ((PFN_lstrcatA)HookItem_lstrcatA.dwOldValue)( lpString1,lpString2 );
    return Result;
}

void WINAPI KEEP_lstrcatA(){
    if ( !RedirectApi ( "KERNEL32.dll", "lstrcatA", (DWORD)NEW_lstrcatA, &HookItem_lstrcatA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_lstrcatA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_lstrcatA.txt", "成功！/n");
}

HOOK_ITEM HookItem_DebugBreak = {0};
typedef void  (WINAPI* PFN_DebugBreak)(  );
void WINAPI NEW_DebugBreak(  ){
    ((PFN_DebugBreak)HookItem_DebugBreak.dwOldValue)(  );
}

void WINAPI KEEP_DebugBreak(){
    if ( !RedirectApi ( "KERNEL32.dll", "DebugBreak", (DWORD)NEW_DebugBreak, &HookItem_DebugBreak ) )
        File.PlusString("C://ini//result//KERNEL32.dll_DebugBreak.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_DebugBreak.txt", "成功！/n");
}

HOOK_ITEM HookItem_GetTempFileNameA = {0};
typedef UINT  (WINAPI* PFN_GetTempFileNameA)( LPCTSTR lpPathName,LPCTSTR lpPrefixString,UINT uUnique,LPTSTR lpTempFileName );
UINT WINAPI NEW_GetTempFileNameA( LPCTSTR lpPathName,LPCTSTR lpPrefixString,UINT uUnique,LPTSTR lpTempFileName ){
    File.PlusString("C://ini//result//KERNEL32.dll_GetTempFileNameA.txt", Change.String(IniKERNEL32_dll++) + " lpPathName: " + ((CString)lpPathName) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetTempFileNameA.txt", Change.String(IniKERNEL32_dll++) + " lpPrefixString: " + ((CString)lpPrefixString) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetTempFileNameA.txt", Change.String(IniKERNEL32_dll++) + " uUnique: " + Change.String((int)uUnique) + "/n");
    File.PlusString("C://ini//result//KERNEL32.dll_GetTempFileNameA.txt", Change.String(IniKERNEL32_dll++) + " lpTempFileName: " + ((CString)lpTempFileName) + "/n");
    UINT Result = ((PFN_GetTempFileNameA)HookItem_GetTempFileNameA.dwOldValue)( lpPathName,lpPrefixString,uUnique,lpTempFileName );
    return Result;
}

void WINAPI KEEP_GetTempFileNameA(){
    if ( !RedirectApi ( "KERNEL32.dll", "GetTempFileNameA", (DWORD)NEW_GetTempFileNameA, &HookItem_GetTempFileNameA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_GetTempFileNameA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_GetTempFileNameA.txt", "成功！/n");
}

HOOK_ITEM HookItem_SetCurrentDirectoryA = {0};
typedef BOOL  (WINAPI* PFN_SetCurrentDirectoryA)( LPCTSTR lpPathName );
BOOL WINAPI NEW_SetCurrentDirectoryA( LPCTSTR lpPathName ){
    File.PlusString("C://ini//result//KERNEL32.dll_SetCurrentDirectoryA.txt", Change.String(IniKERNEL32_dll++) + " lpPathName: " + ((CString)lpPathName) + "/n");
    BOOL Result = ((PFN_SetCurrentDirectoryA)HookItem_SetCurrentDirectoryA.dwOldValue)( lpPathName );
    return Result;
}

void WINAPI KEEP_SetCurrentDirectoryA(){
    if ( !RedirectApi ( "KERNEL32.dll", "SetCurrentDirectoryA", (DWORD)NEW_SetCurrentDirectoryA, &HookItem_SetCurrentDirectoryA ) )
        File.PlusString("C://ini//result//KERNEL32.dll_SetCurrentDirectoryA.txt", "失败！/n");
    else
        File.PlusString("C://ini//result//KERNEL32.dll_SetCurrentDirectoryA.txt", "成功！/n");
}

void WINAPI KEEP_KERNEL32_dll(){
    KEEP_GetModuleFileNameA();
    KEEP_MultiByteToWideChar();
    KEEP_Sleep();
    KEEP_WaitForSingleObject();
    KEEP_lstrcpyA();
    KEEP_GetWindowsDirectoryA();
    //KEEP_LoadLibraryA();
    //KEEP_FreeLibrary();
    KEEP_GetPrivateProfileStringA();
    KEEP_lstrlenA();
    KEEP_GetFileAttributesA();
    KEEP_GetDriveTypeA();
    KEEP_InitializeCriticalSection();
    KEEP_DeleteCriticalSection();
    KEEP_LeaveCriticalSection();
    KEEP_EnterCriticalSection();
    KEEP_MulDiv();
    KEEP_ResumeThread();
    KEEP_LockResource();
    KEEP_SizeofResource();
    KEEP_LoadResource();
    KEEP_FindResourceA();
    KEEP_ResetEvent();
    KEEP_GetLongPathNameA();
    KEEP_GetShortPathNameA();
    KEEP_CloseHandle();
    KEEP_ReadFile();
    KEEP_OpenFileMappingA();
    KEEP_SetFilePointer();
    KEEP_SystemTimeToFileTime();
    KEEP_LocalFileTimeToFileTime();
    KEEP_SetFileTime();
    KEEP_GlobalSize();
    KEEP_GetCurrentThreadId();
    KEEP_GetStartupInfoA();
    KEEP_GetCurrentDirectoryA();
    KEEP_WaitForMultipleObjects();
    KEEP_SetEvent();
    KEEP_ReleaseMutex();
    KEEP_CopyFileA();
    KEEP_FileTimeToSystemTime();
    KEEP_FileTimeToLocalFileTime();
    KEEP_CreateEventA();
    KEEP_CreateSemaphoreA();
    KEEP_WideCharToMultiByte();
    KEEP_lstrcmpiA();
    KEEP_WriteFile();
    KEEP_CreateFileA();
    KEEP_GetVersion();
    KEEP_Process32Next();
    KEEP_Process32First();
    KEEP_CreateToolhelp32Snapshot();
    KEEP_TerminateProcess();
    KEEP_SetFileAttributesA();
    KEEP_GetExitCodeProcess();
    KEEP_OpenProcess();
    KEEP_GetCurrentProcess();
    KEEP_FindClose();
    KEEP_FindFirstFileA();
    KEEP_GetProcAddress();
    KEEP_WritePrivateProfileStringA();
    KEEP_TerminateThread();
    KEEP_GetExitCodeThread();
    KEEP_SetThreadPriority();
    KEEP_OutputDebugStringA();
    KEEP_GlobalFree();
    KEEP_GlobalUnlock();
    KEEP_GlobalLock();
    KEEP_GlobalAlloc();
    KEEP_GetLastError();
    KEEP_MoveFileA();
    KEEP_DeleteFileA();
    KEEP_FindNextFileA();
    KEEP_GetVersionExA();
    KEEP_WinExec();
    KEEP_GetTickCount();
    KEEP_UnmapViewOfFile();
    KEEP_MapViewOfFile();
    KEEP_CreateFileMappingA();
    KEEP_GetPrivateProfileIntA();
    KEEP_CreateMutexA();
    KEEP_OpenMutexA();
    KEEP_GetCurrentProcessId();
    KEEP_GetTempPathA();
    KEEP_lstrcatA();
    KEEP_DebugBreak();
    KEEP_GetTempFileNameA();
    KEEP_SetCurrentDirectoryA();
}

[/code]