winspool劫持

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 头文件
#include <Windows.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];

        BOOL  iswowo64;
        if (IsWow64Process((HANDLE)-1,&iswowo64))
        {
            if (iswowo64)
            {
                GetSystemWow64Directory(tzPath, MAX_PATH);
            }
            else
            {

                GetSystemDirectory(tzPath, MAX_PATH);
            }
        }

		lstrcat(tzPath, TEXT("\\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 ThreadPoc(_In_
	LPVOID lpParameter                                         // 线程函数参数
)
{
	byte byteRead = 0;
	while (true)
	{

		ReadProcessMemory((HANDLE)-1, (LPVOID)0x004010A9, &byteRead, 1, NULL);
		if (byteRead == 0x55)
		{
			byte writeBytes[] = { 0x90,0x90, 0x90, 0x90, 0x90, 0x90 };
			WriteProcessMemory((HANDLE)-1, (LPVOID)0x004010FD, writeBytes, 6, NULL);
			break;
		}
	}
	MessageBox(NULL, "破解成功", "标题", NULL);
	return TRUE;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 入口函数
BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
	if (dwReason == DLL_PROCESS_ATTACH)
	{
		 
		CreateThread(NULL,NULL, ThreadPoc,NULL,NULL,NULL);
		::MessageBoxA(0, "劫持补丁\n\n", "作业完成", 0);
		DisableThreadLibraryCalls(hModule);

		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];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////