逆向破解之破解补丁与劫持Dll

偏执的太偏执、 2023-10-06 23:41 18阅读 0赞

## 破解补丁 ##

### 前言 ###

破解补丁的作用是修改程序内存地址的硬编码，以此来实现破解软件

这是常见的JE跳转用来判断注册码是否正确，若`401108`位置的汇编指令给Nop掉就能实现破解

![请添加图片描述][8c2d7346a6854fa0bfdc301fa2dd4427.png]

### 编写代码 ###

#### 1.C语言 ####

运行程序后输入要破解的程序进程ID

#include <stdio.h>
    #include <windows.h>
    
    int main()
    {	
    	int pId;
    	printf("请输入要破解程序的进程ID:");
    	scanf("%d", &pId);
    	byte buff[] = { 0x90,0x90,0x90,0x90,0x90,0x90 };
    	HANDLE hHandle = OpenProcess(PROCESS_ALL_ACCESS, TRUE, pId);  //打开指定进程
    	WriteProcessMemory(hHandle, (LPVOID)0x00401108, buff, 6, NULL);  //修改程序内存地址的值
    	}

#### 2.E语言 ####

易语言相对C语言写破解补丁会显得更加方便，只需导入精易模块一条语句就能直接修改程序内存地址的值

在全局变量新建一个类依次来调用精易模块的函数

![请添加图片描述][48f87832314c43c8869aef6bad9b48d2.png]

通过调用精易模块的写字节集函数进行内存写入

![请添加图片描述][90dbe478dfb845ccb9d13387a5f7db8c.png]

## 劫持Dll ##

### 前言 ###

有些加了壳的程序会导致其在未完全解密完成的情况下出现如下汇编代码

![请添加图片描述][a05c9b18930441cc859f5230772ca326.png]

当软件运行后，其真正的汇编代码才会呈现出来，也就是我们常说的“吐壳”

![请添加图片描述][33310e04a3b04722a4e89571b58931d0.png]

在程序没有把壳完全吐出来前，我们需要通过代码来判断这个程序是否吐完壳了，最好的方法就是判断某个内存地址的值是否是解密完成后的值

这里我就选4010F0内存地址的值`53`来判断程序是否吐完壳了

![请添加图片描述][94b30249ab934dcd8156c2c5f8e668a3.png]

简单来说劫持dll就是劫持系统的dll，弄一个包含恶意代码的dll来伪装成系统dll，然后把这个dll和程序放在同一目录，程序会优先调用含有恶意代码的dll  
本次实例演示劫持系统的`winspool.drv`

### 编写代码 ###

#### 1.C语言 ####

这里推荐一个软件`AheadLib`，可以自动生成指定系统dll的C语言代码，后面可以在此代码自行添加要执行的功能

![请添加图片描述][d1c48139afd84bf8942ab1f91d586729.png]

将生成的代码复制到自己创建好的DLL项目，需要注意以下几点

在项目属性设置字符集为多字节字符集

![请添加图片描述][bfee91832ed34e26965ecb1ebe4511b4.png]

将项目设置为Release版本

![请添加图片描述][41df654e5b7b45bd9172d10b6d510c46.png]

![请添加图片描述][fceef5bc43ff4cb08bb59500f990c887.png]

在入口函数处可以编写自己的代码

![请添加图片描述][c6053ff05fce48b1a6e643279dd5ff42.png]

以下是可以实现破解功能的完整代码

// 头文件
    #include <Windows.h>
    #include "stdafx.h"
    
    
    
    
    
    // 导出函数
    #pragma comment(linker, "/EXPORT:Noname100=_AheadLib_Noname100,@100,NONAME")
    #pragma comment(linker, "/EXPORT:Noname101=_AheadLib_Noname101,@101,NONAME")
    #pragma comment(linker, "/EXPORT:Noname102=_AheadLib_Noname102,@102,NONAME")
    #pragma comment(linker, "/EXPORT:Noname103=_AheadLib_Noname103,@103,NONAME")
    #pragma comment(linker, "/EXPORT:ADVANCEDSETUPDIALOG=_AheadLib_ADVANCEDSETUPDIALOG,@104")
    #pragma comment(linker, "/EXPORT:AdvancedSetupDialog=_AheadLib_AdvancedSetupDialog,@105")
    #pragma comment(linker, "/EXPORT:ConvertAnsiDevModeToUnicodeDevmode=_AheadLib_ConvertAnsiDevModeToUnicodeDevmode,@106")
    #pragma comment(linker, "/EXPORT:ConvertUnicodeDevModeToAnsiDevmode=_AheadLib_ConvertUnicodeDevModeToAnsiDevmode,@107")
    #pragma comment(linker, "/EXPORT:DEVICEMODE=_AheadLib_DEVICEMODE,@108")
    #pragma comment(linker, "/EXPORT:DeviceMode=_AheadLib_DeviceMode,@109")
    #pragma comment(linker, "/EXPORT:DocumentEvent=_AheadLib_DocumentEvent,@110")
    #pragma comment(linker, "/EXPORT:PerfClose=_AheadLib_PerfClose,@111")
    #pragma comment(linker, "/EXPORT:PerfCollect=_AheadLib_PerfCollect,@112")
    #pragma comment(linker, "/EXPORT:PerfOpen=_AheadLib_PerfOpen,@113")
    #pragma comment(linker, "/EXPORT:QueryColorProfile=_AheadLib_QueryColorProfile,@114")
    #pragma comment(linker, "/EXPORT:QueryRemoteFonts=_AheadLib_QueryRemoteFonts,@115")
    #pragma comment(linker, "/EXPORT:QuerySpoolMode=_AheadLib_QuerySpoolMode,@116")
    #pragma comment(linker, "/EXPORT:SpoolerDevQueryPrintW=_AheadLib_SpoolerDevQueryPrintW,@117")
    #pragma comment(linker, "/EXPORT:StartDocDlgW=_AheadLib_StartDocDlgW,@118")
    #pragma comment(linker, "/EXPORT:AbortPrinter=_AheadLib_AbortPrinter,@119")
    #pragma comment(linker, "/EXPORT:AddFormA=_AheadLib_AddFormA,@120")
    #pragma comment(linker, "/EXPORT:AddFormW=_AheadLib_AddFormW,@121")
    #pragma comment(linker, "/EXPORT:AddJobA=_AheadLib_AddJobA,@122")
    #pragma comment(linker, "/EXPORT:AddJobW=_AheadLib_AddJobW,@123")
    #pragma comment(linker, "/EXPORT:AddMonitorA=_AheadLib_AddMonitorA,@124")
    #pragma comment(linker, "/EXPORT:AddMonitorW=_AheadLib_AddMonitorW,@125")
    #pragma comment(linker, "/EXPORT:AddPortA=_AheadLib_AddPortA,@126")
    #pragma comment(linker, "/EXPORT:AddPortExA=_AheadLib_AddPortExA,@127")
    #pragma comment(linker, "/EXPORT:AddPortExW=_AheadLib_AddPortExW,@128")
    #pragma comment(linker, "/EXPORT:AddPortW=_AheadLib_AddPortW,@129")
    #pragma comment(linker, "/EXPORT:AddPrintProcessorA=_AheadLib_AddPrintProcessorA,@130")
    #pragma comment(linker, "/EXPORT:AddPrintProcessorW=_AheadLib_AddPrintProcessorW,@131")
    #pragma comment(linker, "/EXPORT:AddPrintProvidorA=_AheadLib_AddPrintProvidorA,@132")
    #pragma comment(linker, "/EXPORT:AddPrintProvidorW=_AheadLib_AddPrintProvidorW,@133")
    #pragma comment(linker, "/EXPORT:AddPrinterA=_AheadLib_AddPrinterA,@134")
    #pragma comment(linker, "/EXPORT:AddPrinterConnection2A=_AheadLib_AddPrinterConnection2A,@135")
    #pragma comment(linker, "/EXPORT:AddPrinterConnection2W=_AheadLib_AddPrinterConnection2W,@136")
    #pragma comment(linker, "/EXPORT:AddPrinterConnectionA=_AheadLib_AddPrinterConnectionA,@137")
    #pragma comment(linker, "/EXPORT:AddPrinterConnectionW=_AheadLib_AddPrinterConnectionW,@138")
    #pragma comment(linker, "/EXPORT:AddPrinterDriverA=_AheadLib_AddPrinterDriverA,@139")
    #pragma comment(linker, "/EXPORT:AddPrinterDriverExA=_AheadLib_AddPrinterDriverExA,@140")
    #pragma comment(linker, "/EXPORT:AddPrinterDriverExW=_AheadLib_AddPrinterDriverExW,@141")
    #pragma comment(linker, "/EXPORT:AddPrinterDriverW=_AheadLib_AddPrinterDriverW,@142")
    #pragma comment(linker, "/EXPORT:AddPrinterW=_AheadLib_AddPrinterW,@143")
    #pragma comment(linker, "/EXPORT:AdvancedDocumentPropertiesA=_AheadLib_AdvancedDocumentPropertiesA,@144")
    #pragma comment(linker, "/EXPORT:AdvancedDocumentPropertiesW=_AheadLib_AdvancedDocumentPropertiesW,@145")
    #pragma comment(linker, "/EXPORT:ClosePrinter=_AheadLib_ClosePrinter,@146")
    #pragma comment(linker, "/EXPORT:CloseSpoolFileHandle=_AheadLib_CloseSpoolFileHandle,@147")
    #pragma comment(linker, "/EXPORT:CommitSpoolData=_AheadLib_CommitSpoolData,@148")
    #pragma comment(linker, "/EXPORT:ConfigurePortA=_AheadLib_ConfigurePortA,@149")
    #pragma comment(linker, "/EXPORT:ConfigurePortW=_AheadLib_ConfigurePortW,@150")
    #pragma comment(linker, "/EXPORT:ConnectToPrinterDlg=_AheadLib_ConnectToPrinterDlg,@151")
    #pragma comment(linker, "/EXPORT:CorePrinterDriverInstalledA=_AheadLib_CorePrinterDriverInstalledA,@152")
    #pragma comment(linker, "/EXPORT:CorePrinterDriverInstalledW=_AheadLib_CorePrinterDriverInstalledW,@153")
    #pragma comment(linker, "/EXPORT:CreatePrintAsyncNotifyChannel=_AheadLib_CreatePrintAsyncNotifyChannel,@154")
    #pragma comment(linker, "/EXPORT:CreatePrinterIC=_AheadLib_CreatePrinterIC,@155")
    #pragma comment(linker, "/EXPORT:DEVICECAPABILITIES=_AheadLib_DEVICECAPABILITIES,@156")
    #pragma comment(linker, "/EXPORT:DeleteFormA=_AheadLib_DeleteFormA,@157")
    #pragma comment(linker, "/EXPORT:DeleteFormW=_AheadLib_DeleteFormW,@158")
    #pragma comment(linker, "/EXPORT:DeleteMonitorA=_AheadLib_DeleteMonitorA,@159")
    #pragma comment(linker, "/EXPORT:DeleteMonitorW=_AheadLib_DeleteMonitorW,@160")
    #pragma comment(linker, "/EXPORT:DeletePortA=_AheadLib_DeletePortA,@161")
    #pragma comment(linker, "/EXPORT:DeletePortW=_AheadLib_DeletePortW,@162")
    #pragma comment(linker, "/EXPORT:DeletePrintProcessorA=_AheadLib_DeletePrintProcessorA,@163")
    #pragma comment(linker, "/EXPORT:DeletePrintProcessorW=_AheadLib_DeletePrintProcessorW,@164")
    #pragma comment(linker, "/EXPORT:DeletePrintProvidorA=_AheadLib_DeletePrintProvidorA,@165")
    #pragma comment(linker, "/EXPORT:DeletePrintProvidorW=_AheadLib_DeletePrintProvidorW,@166")
    #pragma comment(linker, "/EXPORT:DeletePrinter=_AheadLib_DeletePrinter,@167")
    #pragma comment(linker, "/EXPORT:DeletePrinterConnectionA=_AheadLib_DeletePrinterConnectionA,@168")
    #pragma comment(linker, "/EXPORT:DeletePrinterConnectionW=_AheadLib_DeletePrinterConnectionW,@169")
    #pragma comment(linker, "/EXPORT:DeletePrinterDataA=_AheadLib_DeletePrinterDataA,@170")
    #pragma comment(linker, "/EXPORT:DeletePrinterDataExA=_AheadLib_DeletePrinterDataExA,@171")
    #pragma comment(linker, "/EXPORT:DeletePrinterDataExW=_AheadLib_DeletePrinterDataExW,@172")
    #pragma comment(linker, "/EXPORT:DeletePrinterDataW=_AheadLib_DeletePrinterDataW,@173")
    #pragma comment(linker, "/EXPORT:DeletePrinterDriverA=_AheadLib_DeletePrinterDriverA,@174")
    #pragma comment(linker, "/EXPORT:DeletePrinterDriverExA=_AheadLib_DeletePrinterDriverExA,@175")
    #pragma comment(linker, "/EXPORT:DeletePrinterDriverExW=_AheadLib_DeletePrinterDriverExW,@176")
    #pragma comment(linker, "/EXPORT:DeletePrinterDriverPackageA=_AheadLib_DeletePrinterDriverPackageA,@177")
    #pragma comment(linker, "/EXPORT:DeletePrinterDriverPackageW=_AheadLib_DeletePrinterDriverPackageW,@178")
    #pragma comment(linker, "/EXPORT:DeletePrinterDriverW=_AheadLib_DeletePrinterDriverW,@179")
    #pragma comment(linker, "/EXPORT:DeletePrinterIC=_AheadLib_DeletePrinterIC,@180")
    #pragma comment(linker, "/EXPORT:DeletePrinterKeyA=_AheadLib_DeletePrinterKeyA,@181")
    #pragma comment(linker, "/EXPORT:DeletePrinterKeyW=_AheadLib_DeletePrinterKeyW,@182")
    #pragma comment(linker, "/EXPORT:DevQueryPrint=_AheadLib_DevQueryPrint,@183")
    #pragma comment(linker, "/EXPORT:DevQueryPrintEx=_AheadLib_DevQueryPrintEx,@184")
    #pragma comment(linker, "/EXPORT:DeviceCapabilities=_AheadLib_DeviceCapabilities,@185")
    #pragma comment(linker, "/EXPORT:DeviceCapabilitiesA=_AheadLib_DeviceCapabilitiesA,@186")
    #pragma comment(linker, "/EXPORT:DeviceCapabilitiesW=_AheadLib_DeviceCapabilitiesW,@187")
    #pragma comment(linker, "/EXPORT:DevicePropertySheets=_AheadLib_DevicePropertySheets,@188")
    #pragma comment(linker, "/EXPORT:DocumentPropertiesA=_AheadLib_DocumentPropertiesA,@189")
    #pragma comment(linker, "/EXPORT:DocumentPropertiesW=_AheadLib_DocumentPropertiesW,@190")
    #pragma comment(linker, "/EXPORT:DocumentPropertySheets=_AheadLib_DocumentPropertySheets,@191")
    #pragma comment(linker, "/EXPORT:EXTDEVICEMODE=_AheadLib_EXTDEVICEMODE,@192")
    #pragma comment(linker, "/EXPORT:EndDocPrinter=_AheadLib_EndDocPrinter,@193")
    #pragma comment(linker, "/EXPORT:EndPagePrinter=_AheadLib_EndPagePrinter,@194")
    #pragma comment(linker, "/EXPORT:EnumFormsA=_AheadLib_EnumFormsA,@195")
    #pragma comment(linker, "/EXPORT:EnumFormsW=_AheadLib_EnumFormsW,@196")
    #pragma comment(linker, "/EXPORT:EnumJobsA=_AheadLib_EnumJobsA,@197")
    #pragma comment(linker, "/EXPORT:EnumJobsW=_AheadLib_EnumJobsW,@198")
    #pragma comment(linker, "/EXPORT:EnumMonitorsA=_AheadLib_EnumMonitorsA,@199")
    #pragma comment(linker, "/EXPORT:EnumMonitorsW=_AheadLib_EnumMonitorsW,@200")
    #pragma comment(linker, "/EXPORT:GetDefaultPrinterA=_AheadLib_GetDefaultPrinterA,@201")
    #pragma comment(linker, "/EXPORT:SetDefaultPrinterA=_AheadLib_SetDefaultPrinterA,@202")
    #pragma comment(linker, "/EXPORT:GetDefaultPrinterW=_AheadLib_GetDefaultPrinterW,@203")
    #pragma comment(linker, "/EXPORT:SetDefaultPrinterW=_AheadLib_SetDefaultPrinterW,@204")
    #pragma comment(linker, "/EXPORT:Noname205=_AheadLib_Noname205,@205,NONAME")
    #pragma comment(linker, "/EXPORT:Noname206=_AheadLib_Noname206,@206,NONAME")
    #pragma comment(linker, "/EXPORT:Noname207=_AheadLib_Noname207,@207,NONAME")
    #pragma comment(linker, "/EXPORT:Noname208=_AheadLib_Noname208,@208,NONAME")
    #pragma comment(linker, "/EXPORT:Noname209=_AheadLib_Noname209,@209,NONAME")
    #pragma comment(linker, "/EXPORT:Noname210=_AheadLib_Noname210,@210,NONAME")
    #pragma comment(linker, "/EXPORT:Noname211=_AheadLib_Noname211,@211,NONAME")
    #pragma comment(linker, "/EXPORT:Noname212=_AheadLib_Noname212,@212,NONAME")
    #pragma comment(linker, "/EXPORT:Noname213=_AheadLib_Noname213,@213,NONAME")
    #pragma comment(linker, "/EXPORT:Noname214=_AheadLib_Noname214,@214,NONAME")
    #pragma comment(linker, "/EXPORT:Noname215=_AheadLib_Noname215,@215,NONAME")
    #pragma comment(linker, "/EXPORT:Noname216=_AheadLib_Noname216,@216,NONAME")
    #pragma comment(linker, "/EXPORT:Noname217=_AheadLib_Noname217,@217,NONAME")
    #pragma comment(linker, "/EXPORT:Noname218=_AheadLib_Noname218,@218,NONAME")
    #pragma comment(linker, "/EXPORT:Noname219=_AheadLib_Noname219,@219,NONAME")
    #pragma comment(linker, "/EXPORT:Noname220=_AheadLib_Noname220,@220,NONAME")
    #pragma comment(linker, "/EXPORT:Noname221=_AheadLib_Noname221,@221,NONAME")
    #pragma comment(linker, "/EXPORT:Noname222=_AheadLib_Noname222,@222,NONAME")
    #pragma comment(linker, "/EXPORT:Noname223=_AheadLib_Noname223,@223,NONAME")
    #pragma comment(linker, "/EXPORT:Noname224=_AheadLib_Noname224,@224,NONAME")
    #pragma comment(linker, "/EXPORT:EnumPortsA=_AheadLib_EnumPortsA,@225")
    #pragma comment(linker, "/EXPORT:Noname226=_AheadLib_Noname226,@226,NONAME")
    #pragma comment(linker, "/EXPORT:Noname227=_AheadLib_Noname227,@227,NONAME")
    #pragma comment(linker, "/EXPORT:Noname228=_AheadLib_Noname228,@228,NONAME")
    #pragma comment(linker, "/EXPORT:Noname229=_AheadLib_Noname229,@229,NONAME")
    #pragma comment(linker, "/EXPORT:Noname230=_AheadLib_Noname230,@230,NONAME")
    #pragma comment(linker, "/EXPORT:Noname231=_AheadLib_Noname231,@231,NONAME")
    #pragma comment(linker, "/EXPORT:EnumPortsW=_AheadLib_EnumPortsW,@232")
    #pragma comment(linker, "/EXPORT:Noname233=_AheadLib_Noname233,@233,NONAME")
    #pragma comment(linker, "/EXPORT:Noname234=_AheadLib_Noname234,@234,NONAME")
    #pragma comment(linker, "/EXPORT:EnumPrintProcessorDatatypesA=_AheadLib_EnumPrintProcessorDatatypesA,@235")
    #pragma comment(linker, "/EXPORT:EnumPrintProcessorDatatypesW=_AheadLib_EnumPrintProcessorDatatypesW,@236")
    #pragma comment(linker, "/EXPORT:EnumPrintProcessorsA=_AheadLib_EnumPrintProcessorsA,@237")
    #pragma comment(linker, "/EXPORT:EnumPrintProcessorsW=_AheadLib_EnumPrintProcessorsW,@238")
    #pragma comment(linker, "/EXPORT:EnumPrinterDataA=_AheadLib_EnumPrinterDataA,@239")
    #pragma comment(linker, "/EXPORT:EnumPrinterDataExA=_AheadLib_EnumPrinterDataExA,@240")
    #pragma comment(linker, "/EXPORT:EnumPrinterDataExW=_AheadLib_EnumPrinterDataExW,@241")
    #pragma comment(linker, "/EXPORT:EnumPrinterDataW=_AheadLib_EnumPrinterDataW,@242")
    #pragma comment(linker, "/EXPORT:EnumPrinterDriversA=_AheadLib_EnumPrinterDriversA,@243")
    #pragma comment(linker, "/EXPORT:EnumPrinterDriversW=_AheadLib_EnumPrinterDriversW,@244")
    #pragma comment(linker, "/EXPORT:EnumPrinterKeyA=_AheadLib_EnumPrinterKeyA,@245")
    #pragma comment(linker, "/EXPORT:EnumPrinterKeyW=_AheadLib_EnumPrinterKeyW,@246")
    #pragma comment(linker, "/EXPORT:EnumPrintersA=_AheadLib_EnumPrintersA,@247")
    #pragma comment(linker, "/EXPORT:EnumPrintersW=_AheadLib_EnumPrintersW,@248")
    #pragma comment(linker, "/EXPORT:ExtDeviceMode=_AheadLib_ExtDeviceMode,@249")
    #pragma comment(linker, "/EXPORT:Noname250=_AheadLib_Noname250,@250,NONAME")
    #pragma comment(linker, "/EXPORT:Noname251=_AheadLib_Noname251,@251,NONAME")
    #pragma comment(linker, "/EXPORT:Noname252=_AheadLib_Noname252,@252,NONAME")
    #pragma comment(linker, "/EXPORT:Noname253=_AheadLib_Noname253,@253,NONAME")
    #pragma comment(linker, "/EXPORT:Noname254=_AheadLib_Noname254,@254,NONAME")
    #pragma comment(linker, "/EXPORT:Noname255=_AheadLib_Noname255,@255,NONAME")
    #pragma comment(linker, "/EXPORT:Noname256=_AheadLib_Noname256,@256,NONAME")
    #pragma comment(linker, "/EXPORT:FindClosePrinterChangeNotification=_AheadLib_FindClosePrinterChangeNotification,@257")
    #pragma comment(linker, "/EXPORT:FindFirstPrinterChangeNotification=_AheadLib_FindFirstPrinterChangeNotification,@258")
    #pragma comment(linker, "/EXPORT:FindNextPrinterChangeNotification=_AheadLib_FindNextPrinterChangeNotification,@259")
    #pragma comment(linker, "/EXPORT:FlushPrinter=_AheadLib_FlushPrinter,@260")
    #pragma comment(linker, "/EXPORT:FreePrinterNotifyInfo=_AheadLib_FreePrinterNotifyInfo,@261")
    #pragma comment(linker, "/EXPORT:GetCorePrinterDriversA=_AheadLib_GetCorePrinterDriversA,@262")
    #pragma comment(linker, "/EXPORT:GetCorePrinterDriversW=_AheadLib_GetCorePrinterDriversW,@263")
    #pragma comment(linker, "/EXPORT:GetFormA=_AheadLib_GetFormA,@264")
    #pragma comment(linker, "/EXPORT:GetFormW=_AheadLib_GetFormW,@265")
    #pragma comment(linker, "/EXPORT:GetJobA=_AheadLib_GetJobA,@266")
    #pragma comment(linker, "/EXPORT:GetJobW=_AheadLib_GetJobW,@267")
    #pragma comment(linker, "/EXPORT:GetPrintExecutionData=_AheadLib_GetPrintExecutionData,@268")
    #pragma comment(linker, "/EXPORT:GetPrintProcessorDirectoryA=_AheadLib_GetPrintProcessorDirectoryA,@269")
    #pragma comment(linker, "/EXPORT:GetPrintProcessorDirectoryW=_AheadLib_GetPrintProcessorDirectoryW,@270")
    #pragma comment(linker, "/EXPORT:GetPrinterA=_AheadLib_GetPrinterA,@271")
    #pragma comment(linker, "/EXPORT:GetPrinterDataA=_AheadLib_GetPrinterDataA,@272")
    #pragma comment(linker, "/EXPORT:GetPrinterDataExA=_AheadLib_GetPrinterDataExA,@273")
    #pragma comment(linker, "/EXPORT:GetPrinterDataExW=_AheadLib_GetPrinterDataExW,@274")
    #pragma comment(linker, "/EXPORT:GetPrinterDataW=_AheadLib_GetPrinterDataW,@275")
    #pragma comment(linker, "/EXPORT:GetPrinterDriver2A=_AheadLib_GetPrinterDriver2A,@276")
    #pragma comment(linker, "/EXPORT:GetPrinterDriver2W=_AheadLib_GetPrinterDriver2W,@277")
    #pragma comment(linker, "/EXPORT:GetPrinterDriverA=_AheadLib_GetPrinterDriverA,@278")
    #pragma comment(linker, "/EXPORT:GetPrinterDriverDirectoryA=_AheadLib_GetPrinterDriverDirectoryA,@279")
    #pragma comment(linker, "/EXPORT:GetPrinterDriverDirectoryW=_AheadLib_GetPrinterDriverDirectoryW,@280")
    #pragma comment(linker, "/EXPORT:GetPrinterDriverPackagePathA=_AheadLib_GetPrinterDriverPackagePathA,@281")
    #pragma comment(linker, "/EXPORT:GetPrinterDriverPackagePathW=_AheadLib_GetPrinterDriverPackagePathW,@282")
    #pragma comment(linker, "/EXPORT:GetPrinterDriverW=_AheadLib_GetPrinterDriverW,@283")
    #pragma comment(linker, "/EXPORT:GetPrinterW=_AheadLib_GetPrinterW,@284")
    #pragma comment(linker, "/EXPORT:GetSpoolFileHandle=_AheadLib_GetSpoolFileHandle,@285")
    #pragma comment(linker, "/EXPORT:InstallPrinterDriverFromPackageA=_AheadLib_InstallPrinterDriverFromPackageA,@286")
    #pragma comment(linker, "/EXPORT:InstallPrinterDriverFromPackageW=_AheadLib_InstallPrinterDriverFromPackageW,@287")
    #pragma comment(linker, "/EXPORT:IsValidDevmodeA=_AheadLib_IsValidDevmodeA,@288")
    #pragma comment(linker, "/EXPORT:IsValidDevmodeW=_AheadLib_IsValidDevmodeW,@289")
    #pragma comment(linker, "/EXPORT:OpenPrinter2A=_AheadLib_OpenPrinter2A,@290")
    #pragma comment(linker, "/EXPORT:OpenPrinter2W=_AheadLib_OpenPrinter2W,@291")
    #pragma comment(linker, "/EXPORT:OpenPrinterA=_AheadLib_OpenPrinterA,@292")
    #pragma comment(linker, "/EXPORT:OpenPrinterW=_AheadLib_OpenPrinterW,@293")
    #pragma comment(linker, "/EXPORT:PlayGdiScriptOnPrinterIC=_AheadLib_PlayGdiScriptOnPrinterIC,@294")
    #pragma comment(linker, "/EXPORT:PrinterMessageBoxA=_AheadLib_PrinterMessageBoxA,@295")
    #pragma comment(linker, "/EXPORT:PrinterMessageBoxW=_AheadLib_PrinterMessageBoxW,@296")
    #pragma comment(linker, "/EXPORT:PrinterProperties=_AheadLib_PrinterProperties,@297")
    #pragma comment(linker, "/EXPORT:ReadPrinter=_AheadLib_ReadPrinter,@298")
    #pragma comment(linker, "/EXPORT:RegisterForPrintAsyncNotifications=_AheadLib_RegisterForPrintAsyncNotifications,@299")
    #pragma comment(linker, "/EXPORT:ReportJobProcessingProgress=_AheadLib_ReportJobProcessingProgress,@300")
    #pragma comment(linker, "/EXPORT:ResetPrinterA=_AheadLib_ResetPrinterA,@301")
    #pragma comment(linker, "/EXPORT:ResetPrinterW=_AheadLib_ResetPrinterW,@302")
    #pragma comment(linker, "/EXPORT:ScheduleJob=_AheadLib_ScheduleJob,@303")
    #pragma comment(linker, "/EXPORT:SeekPrinter=_AheadLib_SeekPrinter,@304")
    #pragma comment(linker, "/EXPORT:SetFormA=_AheadLib_SetFormA,@305")
    #pragma comment(linker, "/EXPORT:SetFormW=_AheadLib_SetFormW,@306")
    #pragma comment(linker, "/EXPORT:SetJobA=_AheadLib_SetJobA,@307")
    #pragma comment(linker, "/EXPORT:SetJobW=_AheadLib_SetJobW,@308")
    #pragma comment(linker, "/EXPORT:SetPortA=_AheadLib_SetPortA,@309")
    #pragma comment(linker, "/EXPORT:SetPortW=_AheadLib_SetPortW,@310")
    #pragma comment(linker, "/EXPORT:SetPrinterA=_AheadLib_SetPrinterA,@311")
    #pragma comment(linker, "/EXPORT:SetPrinterDataA=_AheadLib_SetPrinterDataA,@312")
    #pragma comment(linker, "/EXPORT:SetPrinterDataExA=_AheadLib_SetPrinterDataExA,@313")
    #pragma comment(linker, "/EXPORT:SetPrinterDataExW=_AheadLib_SetPrinterDataExW,@314")
    #pragma comment(linker, "/EXPORT:SetPrinterDataW=_AheadLib_SetPrinterDataW,@315")
    #pragma comment(linker, "/EXPORT:SetPrinterW=_AheadLib_SetPrinterW,@316")
    #pragma comment(linker, "/EXPORT:SplDriverUnloadComplete=_AheadLib_SplDriverUnloadComplete,@317")
    #pragma comment(linker, "/EXPORT:SpoolerPrinterEvent=_AheadLib_SpoolerPrinterEvent,@318")
    #pragma comment(linker, "/EXPORT:StartDocDlgA=_AheadLib_StartDocDlgA,@319")
    #pragma comment(linker, "/EXPORT:StartDocPrinterA=_AheadLib_StartDocPrinterA,@320")
    #pragma comment(linker, "/EXPORT:StartDocPrinterW=_AheadLib_StartDocPrinterW,@321")
    #pragma comment(linker, "/EXPORT:StartPagePrinter=_AheadLib_StartPagePrinter,@322")
    #pragma comment(linker, "/EXPORT:UnRegisterForPrintAsyncNotifications=_AheadLib_UnRegisterForPrintAsyncNotifications,@323")
    #pragma comment(linker, "/EXPORT:UploadPrinterDriverPackageA=_AheadLib_UploadPrinterDriverPackageA,@324")
    #pragma comment(linker, "/EXPORT:UploadPrinterDriverPackageW=_AheadLib_UploadPrinterDriverPackageW,@325")
    #pragma comment(linker, "/EXPORT:WaitForPrinterChange=_AheadLib_WaitForPrinterChange,@326")
    #pragma comment(linker, "/EXPORT:WritePrinter=_AheadLib_WritePrinter,@327")
    #pragma comment(linker, "/EXPORT:XcvDataW=_AheadLib_XcvDataW,@328")
    
    
    
    
    
    // 宏定义
    #define EXTERNC extern "C"
    #define NAKED __declspec(naked)
    #define EXPORT __declspec(dllexport)
    
    #define ALCPP EXPORT NAKED
    #define ALSTD EXTERNC EXPORT NAKED void __stdcall
    #define ALCFAST EXTERNC EXPORT NAKED void __fastcall
    #define ALCDECL EXTERNC NAKED void __cdecl
    
    
    
    
    
    // AheadLib 命名空间
    namespace AheadLib
    {
    	HMODULE m_hModule = NULL;	// 原始模块句柄
    	DWORD m_dwReturn[229] = {0};	// 原始函数返回地址
    
    
    	// 加载原始模块
    	inline BOOL WINAPI Load()
    	{
    		TCHAR tzPath[MAX_PATH] = {0};
    		TCHAR tzTemp[MAX_PATH * 2];
    		lstrcat(tzPath, TEXT("C:\\Windows\\SysWOW64\\winspool.drv"));
    		m_hModule = LoadLibrary(tzPath);
    		if (m_hModule == NULL)
    		{
    			wsprintf(tzTemp, TEXT("无法加载 %s，程序无法正常运行。"), tzPath);
    			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
    		}
    
    		return (m_hModule != NULL);	
    	}
    		
    	// 释放原始模块
    	inline VOID WINAPI Free()
    	{
    		if (m_hModule)
    		{
    			FreeLibrary(m_hModule);
    		}
    	}
    
    	// 获取原始函数地址
    	FARPROC WINAPI GetAddress(PCSTR pszProcName)
    	{
    		FARPROC fpAddress;
    		CHAR szProcName[16];
    		TCHAR tzTemp[MAX_PATH];
    
    		fpAddress = GetProcAddress(m_hModule, pszProcName);
    		if (fpAddress == NULL)
    		{
    			if (HIWORD(pszProcName) == 0)
    			{
    				wsprintf(szProcName, "%d", pszProcName);
    				pszProcName = szProcName;
    			}
    
    			wsprintf(tzTemp, TEXT("无法找到函数 %hs，程序无法正常运行。"), pszProcName);
    			MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
    			ExitProcess(-2);
    		}
    
    		return fpAddress;
    	}
    }
    using namespace AheadLib;
    
    
    
    DWORD WINAPI Thread(_In_ LPVOID lpParameter){
    	while (true)
    	{	
    		byte bytes = 0;
    		ReadProcessMemory((HANDLE)-1, (LPVOID)0x4010F0, &bytes, 1, NULL);
    		if (bytes == 0x53)
    		{	
    			byte byte_write[] = { 0x90,0x90, 0x90, 0x90, 0x90, 0x90 };
    			WriteProcessMemory((HANDLE)-1, (LPVOID)0x4010FD,byte_write, 6, NULL);
    			MessageBoxA(NULL,"破解成功","标题",NULL);
    			break;
    		}
    
    	}
    
    	return true;
    }
    
    
    
    // 入口函数
    BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
    {
    	if (dwReason == DLL_PROCESS_ATTACH)
    	{
    		CreateThread(NULL, 0, Thread, 0, 0, 0);
    
    		return Load();
    	}
    	else if (dwReason == DLL_PROCESS_DETACH)
    	{
    		Free();
    	}
    
    	return TRUE;
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname100(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[0 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(100))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[0 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname101(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[1 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(101))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[1 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname102(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[2 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(102))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[2 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname103(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[3 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(103))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[3 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ADVANCEDSETUPDIALOG(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[4 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ADVANCEDSETUPDIALOG")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[4 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AdvancedSetupDialog(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[5 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AdvancedSetupDialog")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[5 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ConvertAnsiDevModeToUnicodeDevmode(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[6 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ConvertAnsiDevModeToUnicodeDevmode")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[6 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ConvertUnicodeDevModeToAnsiDevmode(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[7 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ConvertUnicodeDevModeToAnsiDevmode")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[7 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DEVICEMODE(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[8 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DEVICEMODE")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[8 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeviceMode(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[9 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeviceMode")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[9 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DocumentEvent(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[10 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DocumentEvent")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[10 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PerfClose(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[11 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PerfClose")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[11 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PerfCollect(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[12 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PerfCollect")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[12 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PerfOpen(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[13 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PerfOpen")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[13 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_QueryColorProfile(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[14 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("QueryColorProfile")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[14 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_QueryRemoteFonts(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[15 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("QueryRemoteFonts")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[15 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_QuerySpoolMode(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[16 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("QuerySpoolMode")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[16 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SpoolerDevQueryPrintW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[17 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SpoolerDevQueryPrintW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[17 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_StartDocDlgW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[18 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("StartDocDlgW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[18 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AbortPrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[19 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AbortPrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[19 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddFormA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[20 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddFormA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[20 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddFormW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[21 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddFormW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[21 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddJobA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[22 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddJobA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[22 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddJobW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[23 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddJobW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[23 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddMonitorA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[24 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddMonitorA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[24 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddMonitorW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[25 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddMonitorW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[25 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPortA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[26 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPortA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[26 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPortExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[27 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPortExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[27 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPortExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[28 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPortExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[28 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPortW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[29 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPortW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[29 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrintProcessorA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[30 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrintProcessorA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[30 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrintProcessorW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[31 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrintProcessorW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[31 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrintProvidorA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[32 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrintProvidorA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[32 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrintProvidorW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[33 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrintProvidorW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[33 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[34 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[34 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterConnection2A(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[35 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterConnection2A")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[35 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterConnection2W(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[36 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterConnection2W")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[36 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterConnectionA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[37 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterConnectionA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[37 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterConnectionW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[38 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterConnectionW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[38 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterDriverA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[39 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterDriverA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[39 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterDriverExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[40 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterDriverExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[40 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterDriverExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[41 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterDriverExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[41 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterDriverW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[42 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterDriverW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[42 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AddPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[43 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AddPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[43 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AdvancedDocumentPropertiesA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[44 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AdvancedDocumentPropertiesA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[44 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_AdvancedDocumentPropertiesW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[45 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("AdvancedDocumentPropertiesW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[45 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ClosePrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[46 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ClosePrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[46 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_CloseSpoolFileHandle(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[47 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("CloseSpoolFileHandle")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[47 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_CommitSpoolData(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[48 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("CommitSpoolData")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[48 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ConfigurePortA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[49 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ConfigurePortA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[49 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ConfigurePortW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[50 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ConfigurePortW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[50 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ConnectToPrinterDlg(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[51 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ConnectToPrinterDlg")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[51 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_CorePrinterDriverInstalledA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[52 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("CorePrinterDriverInstalledA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[52 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_CorePrinterDriverInstalledW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[53 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("CorePrinterDriverInstalledW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[53 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_CreatePrintAsyncNotifyChannel(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[54 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("CreatePrintAsyncNotifyChannel")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[54 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_CreatePrinterIC(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[55 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("CreatePrinterIC")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[55 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DEVICECAPABILITIES(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[56 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DEVICECAPABILITIES")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[56 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeleteFormA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[57 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeleteFormA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[57 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeleteFormW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[58 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeleteFormW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[58 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeleteMonitorA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[59 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeleteMonitorA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[59 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeleteMonitorW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[60 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeleteMonitorW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[60 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePortA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[61 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePortA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[61 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePortW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[62 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePortW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[62 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrintProcessorA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[63 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrintProcessorA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[63 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrintProcessorW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[64 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrintProcessorW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[64 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrintProvidorA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[65 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrintProvidorA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[65 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrintProvidorW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[66 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrintProvidorW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[66 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[67 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[67 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterConnectionA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[68 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterConnectionA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[68 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterConnectionW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[69 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterConnectionW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[69 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDataA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[70 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDataA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[70 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDataExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[71 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDataExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[71 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDataExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[72 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDataExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[72 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDataW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[73 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDataW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[73 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDriverA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[74 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDriverA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[74 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDriverExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[75 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDriverExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[75 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDriverExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[76 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDriverExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[76 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDriverPackageA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[77 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDriverPackageA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[77 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDriverPackageW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[78 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDriverPackageW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[78 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterDriverW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[79 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterDriverW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[79 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterIC(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[80 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterIC")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[80 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterKeyA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[81 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterKeyA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[81 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeletePrinterKeyW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[82 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeletePrinterKeyW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[82 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DevQueryPrint(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[83 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DevQueryPrint")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[83 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DevQueryPrintEx(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[84 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DevQueryPrintEx")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[84 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeviceCapabilities(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[85 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeviceCapabilities")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[85 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeviceCapabilitiesA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[86 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeviceCapabilitiesA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[86 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DeviceCapabilitiesW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[87 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DeviceCapabilitiesW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[87 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DevicePropertySheets(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[88 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DevicePropertySheets")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[88 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DocumentPropertiesA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[89 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DocumentPropertiesA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[89 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DocumentPropertiesW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[90 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DocumentPropertiesW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[90 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_DocumentPropertySheets(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[91 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("DocumentPropertySheets")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[91 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EXTDEVICEMODE(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[92 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EXTDEVICEMODE")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[92 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EndDocPrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[93 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EndDocPrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[93 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EndPagePrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[94 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EndPagePrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[94 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumFormsA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[95 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumFormsA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[95 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumFormsW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[96 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumFormsW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[96 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumJobsA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[97 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumJobsA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[97 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumJobsW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[98 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumJobsW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[98 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumMonitorsA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[99 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumMonitorsA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[99 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumMonitorsW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[100 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumMonitorsW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[100 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetDefaultPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[101 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetDefaultPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[101 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetDefaultPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[102 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetDefaultPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[102 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetDefaultPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[103 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetDefaultPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[103 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetDefaultPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[104 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetDefaultPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[104 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname205(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[105 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(205))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[105 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname206(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[106 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(206))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[106 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname207(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[107 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(207))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[107 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname208(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[108 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(208))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[108 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname209(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[109 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(209))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[109 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname210(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[110 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(210))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[110 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname211(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[111 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(211))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[111 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname212(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[112 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(212))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[112 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname213(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[113 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(213))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[113 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname214(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[114 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(214))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[114 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname215(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[115 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(215))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[115 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname216(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[116 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(216))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[116 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname217(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[117 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(217))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[117 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname218(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[118 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(218))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[118 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname219(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[119 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(219))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[119 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname220(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[120 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(220))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[120 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname221(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[121 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(221))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[121 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname222(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[122 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(222))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[122 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname223(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[123 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(223))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[123 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname224(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[124 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(224))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[124 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPortsA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[125 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPortsA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[125 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname226(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[126 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(226))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[126 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname227(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[127 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(227))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[127 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname228(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[128 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(228))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[128 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname229(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[129 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(229))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[129 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname230(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[130 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(230))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[130 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname231(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[131 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(231))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[131 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPortsW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[132 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPortsW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[132 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname233(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[133 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(233))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[133 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname234(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[134 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(234))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[134 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrintProcessorDatatypesA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[135 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrintProcessorDatatypesA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[135 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrintProcessorDatatypesW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[136 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrintProcessorDatatypesW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[136 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrintProcessorsA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[137 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrintProcessorsA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[137 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrintProcessorsW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[138 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrintProcessorsW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[138 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterDataA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[139 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterDataA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[139 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterDataExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[140 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterDataExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[140 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterDataExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[141 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterDataExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[141 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterDataW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[142 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterDataW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[142 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterDriversA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[143 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterDriversA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[143 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterDriversW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[144 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterDriversW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[144 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterKeyA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[145 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterKeyA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[145 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrinterKeyW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[146 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrinterKeyW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[146 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrintersA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[147 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrintersA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[147 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_EnumPrintersW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[148 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("EnumPrintersW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[148 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ExtDeviceMode(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[149 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ExtDeviceMode")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[149 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname250(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[150 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(250))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[150 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname251(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[151 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(251))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[151 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname252(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[152 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(252))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[152 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname253(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[153 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(253))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[153 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname254(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[154 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(254))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[154 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname255(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[155 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(255))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[155 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_Noname256(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[156 * TYPE long];
    
    	// 调用原始函数
    	GetAddress(MAKEINTRESOURCE(256))();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[156 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_FindClosePrinterChangeNotification(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[157 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("FindClosePrinterChangeNotification")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[157 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_FindFirstPrinterChangeNotification(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[158 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("FindFirstPrinterChangeNotification")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[158 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_FindNextPrinterChangeNotification(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[159 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("FindNextPrinterChangeNotification")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[159 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_FlushPrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[160 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("FlushPrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[160 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_FreePrinterNotifyInfo(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[161 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("FreePrinterNotifyInfo")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[161 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetCorePrinterDriversA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[162 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetCorePrinterDriversA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[162 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetCorePrinterDriversW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[163 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetCorePrinterDriversW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[163 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetFormA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[164 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetFormA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[164 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetFormW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[165 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetFormW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[165 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetJobA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[166 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetJobA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[166 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetJobW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[167 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetJobW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[167 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrintExecutionData(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[168 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrintExecutionData")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[168 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrintProcessorDirectoryA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[169 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrintProcessorDirectoryA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[169 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrintProcessorDirectoryW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[170 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrintProcessorDirectoryW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[170 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[171 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[171 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDataA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[172 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDataA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[172 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDataExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[173 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDataExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[173 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDataExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[174 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDataExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[174 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDataW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[175 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDataW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[175 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriver2A(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[176 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriver2A")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[176 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriver2W(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[177 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriver2W")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[177 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriverA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[178 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriverA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[178 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriverDirectoryA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[179 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriverDirectoryA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[179 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriverDirectoryW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[180 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriverDirectoryW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[180 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriverPackagePathA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[181 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriverPackagePathA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[181 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriverPackagePathW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[182 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriverPackagePathW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[182 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterDriverW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[183 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterDriverW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[183 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[184 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[184 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_GetSpoolFileHandle(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[185 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("GetSpoolFileHandle")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[185 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_InstallPrinterDriverFromPackageA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[186 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("InstallPrinterDriverFromPackageA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[186 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_InstallPrinterDriverFromPackageW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[187 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("InstallPrinterDriverFromPackageW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[187 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_IsValidDevmodeA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[188 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("IsValidDevmodeA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[188 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_IsValidDevmodeW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[189 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("IsValidDevmodeW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[189 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_OpenPrinter2A(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[190 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("OpenPrinter2A")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[190 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_OpenPrinter2W(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[191 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("OpenPrinter2W")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[191 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_OpenPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[192 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("OpenPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[192 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_OpenPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[193 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("OpenPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[193 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PlayGdiScriptOnPrinterIC(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[194 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PlayGdiScriptOnPrinterIC")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[194 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PrinterMessageBoxA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[195 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PrinterMessageBoxA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[195 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PrinterMessageBoxW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[196 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PrinterMessageBoxW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[196 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_PrinterProperties(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[197 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("PrinterProperties")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[197 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ReadPrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[198 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ReadPrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[198 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_RegisterForPrintAsyncNotifications(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[199 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("RegisterForPrintAsyncNotifications")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[199 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ReportJobProcessingProgress(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[200 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ReportJobProcessingProgress")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[200 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ResetPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[201 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ResetPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[201 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ResetPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[202 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ResetPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[202 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_ScheduleJob(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[203 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("ScheduleJob")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[203 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SeekPrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[204 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SeekPrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[204 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetFormA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[205 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetFormA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[205 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetFormW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[206 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetFormW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[206 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetJobA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[207 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetJobA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[207 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetJobW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[208 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetJobW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[208 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPortA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[209 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPortA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[209 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPortW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[210 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPortW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[210 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[211 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[211 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPrinterDataA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[212 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPrinterDataA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[212 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPrinterDataExA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[213 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPrinterDataExA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[213 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPrinterDataExW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[214 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPrinterDataExW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[214 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPrinterDataW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[215 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPrinterDataW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[215 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SetPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[216 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SetPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[216 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SplDriverUnloadComplete(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[217 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SplDriverUnloadComplete")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[217 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_SpoolerPrinterEvent(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[218 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("SpoolerPrinterEvent")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[218 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_StartDocDlgA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[219 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("StartDocDlgA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[219 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_StartDocPrinterA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[220 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("StartDocPrinterA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[220 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_StartDocPrinterW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[221 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("StartDocPrinterW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[221 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_StartPagePrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[222 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("StartPagePrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[222 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_UnRegisterForPrintAsyncNotifications(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[223 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("UnRegisterForPrintAsyncNotifications")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[223 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_UploadPrinterDriverPackageA(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[224 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("UploadPrinterDriverPackageA")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[224 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_UploadPrinterDriverPackageW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[225 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("UploadPrinterDriverPackageW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[225 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_WaitForPrinterChange(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[226 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("WaitForPrinterChange")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[226 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_WritePrinter(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[227 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("WritePrinter")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[227 * TYPE long];
    }
    
    
    
    
    
    // 导出函数
    ALCDECL AheadLib_XcvDataW(void)
    {
    	// 保存返回地址
    	__asm POP m_dwReturn[228 * TYPE long];
    
    	// 调用原始函数
    	GetAddress("XcvDataW")();
    
    	// 转跳到返回地址
    	__asm JMP m_dwReturn[228 * TYPE long];
    }

#### 2.E语言 ####

E语言也有编写好的代码,只需在后面添加上自己的代码即可

链接：https://pan.baidu.com/s/1ktvB7bmChWEzVMXU2QNTbQ 提取码：cmzj

![请添加图片描述][5084b99c03124ce9b096f88a90285ed5.png]

## 补丁生成工具 ##

使用**XH补丁制作工具**更加方便破解, 将程序拖入XH并选择右下角的EXE

![请添加图片描述][3424cdea5f5c44aab808587cc31404d4.png]

输入要修改的内存地址以及对应的值，点击添加

![请添加图片描述][f927d470b4444136a5df834049d9b5ec.png]

![请添加图片描述][901135a3eb414fe483d5ab78593c39fe.png]

添加完后点击生成补丁,生成的补丁与原程序放在同一目录

![请添加图片描述][60d1161b1d094a81a1771eaef0363843.png]

![请添加图片描述][596b098f5bbd4adb895cab98e157dcce.png]

运行补丁程序点击破解,随后会弹出原程序

![请添加图片描述][85be0a6d302f486087013dc31cbf26ee.png]

![请添加图片描述][49723dfa15504a549ec84818c2e2b462.png]

[8c2d7346a6854fa0bfdc301fa2dd4427.png]: https://img-blog.csdnimg.cn/8c2d7346a6854fa0bfdc301fa2dd4427.png
[48f87832314c43c8869aef6bad9b48d2.png]: https://img-blog.csdnimg.cn/48f87832314c43c8869aef6bad9b48d2.png
[90dbe478dfb845ccb9d13387a5f7db8c.png]: https://img-blog.csdnimg.cn/90dbe478dfb845ccb9d13387a5f7db8c.png
[a05c9b18930441cc859f5230772ca326.png]: https://img-blog.csdnimg.cn/a05c9b18930441cc859f5230772ca326.png
[33310e04a3b04722a4e89571b58931d0.png]: https://img-blog.csdnimg.cn/33310e04a3b04722a4e89571b58931d0.png
[94b30249ab934dcd8156c2c5f8e668a3.png]: https://img-blog.csdnimg.cn/94b30249ab934dcd8156c2c5f8e668a3.png
[d1c48139afd84bf8942ab1f91d586729.png]: https://img-blog.csdnimg.cn/d1c48139afd84bf8942ab1f91d586729.png
[bfee91832ed34e26965ecb1ebe4511b4.png]: https://img-blog.csdnimg.cn/bfee91832ed34e26965ecb1ebe4511b4.png
[41df654e5b7b45bd9172d10b6d510c46.png]: https://img-blog.csdnimg.cn/41df654e5b7b45bd9172d10b6d510c46.png
[fceef5bc43ff4cb08bb59500f990c887.png]: https://img-blog.csdnimg.cn/fceef5bc43ff4cb08bb59500f990c887.png
[c6053ff05fce48b1a6e643279dd5ff42.png]: https://img-blog.csdnimg.cn/c6053ff05fce48b1a6e643279dd5ff42.png
[5084b99c03124ce9b096f88a90285ed5.png]: https://img-blog.csdnimg.cn/5084b99c03124ce9b096f88a90285ed5.png
[3424cdea5f5c44aab808587cc31404d4.png]: https://img-blog.csdnimg.cn/3424cdea5f5c44aab808587cc31404d4.png
[f927d470b4444136a5df834049d9b5ec.png]: https://img-blog.csdnimg.cn/f927d470b4444136a5df834049d9b5ec.png
[901135a3eb414fe483d5ab78593c39fe.png]: https://img-blog.csdnimg.cn/901135a3eb414fe483d5ab78593c39fe.png
[60d1161b1d094a81a1771eaef0363843.png]: https://img-blog.csdnimg.cn/60d1161b1d094a81a1771eaef0363843.png
[596b098f5bbd4adb895cab98e157dcce.png]: https://img-blog.csdnimg.cn/596b098f5bbd4adb895cab98e157dcce.png
[85be0a6d302f486087013dc31cbf26ee.png]: https://img-blog.csdnimg.cn/85be0a6d302f486087013dc31cbf26ee.png
[49723dfa15504a549ec84818c2e2b462.png]: https://img-blog.csdnimg.cn/49723dfa15504a549ec84818c2e2b462.png