----------------------------------------------------------------------------------
--                                                                              --
-- Windows Base Services API interface Unit for Object Pascal                   --
--                                                                              --
-- Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          --
-- Corporation. All Rights Reserved.                                            --
--                                                                              --
-- The original file is: winbase.h, released August 2001. The original Pascal   --
-- code is: WinBase.pas, released December 2000. The initial developer of the   --
-- Pascal code is Marcel van Brakel (brakelm att chello dott nl).               --
--                                                                              --
-- Portions created by Marcel van Brakel are Copyright (C) 1999-2001            --
-- Marcel van Brakel. All Rights Reserved.                                      --
--                                                                              --
-- Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        --
--                                                                              --
-- You may retrieve the latest version of this file at the Project JEDI         --
-- APILIB home page, located at http://jedi-apilib.sourceforge.net              --
--                                                                              --
-- The contents of this file are used with permission, subject to the Mozilla   --
-- Public License Version 1.1 (the "License"); you may not use this file except --
-- in compliance with the License. You may obtain a copy of the License at      --
-- http://www.mozilla.org/MPL/MPL-1.1.html                                      --
--                                                                              --
-- Software distributed under the License is distributed on an "AS IS" basis,   --
-- WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for --
-- the specific language governing rights and limitations under the License.    --
--                                                                              --
-- Alternatively, the contents of this file may be used under the terms of the  --
-- GNU Lesser General Public License (the  "LGPL License"), in which case the   --
-- provisions of the LGPL License are applicable instead of those above.        --
-- If you wish to allow use of your version of this file only under the terms   --
-- of the LGPL License and not to allow others to use your version of this file --
-- under the MPL, indicate your decision by deleting  the provisions above and  --
-- replace  them with the notice and other provisions required by the LGPL      --
-- License.  If you do not delete the provisions above, a recipient may use     --
-- your version of this file under either the MPL or the LGPL License.          --
--                                                                              --
-- For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html --
--                                                                              --
----------------------------------------------------------------------------------

--  $Id: Jwa.Win_Base.ads,v 1.17 2007/09/14 06:48:47 marquardt Exp $

with
  Interfaces, System, Jwa.Utils,
  Jwa.NT_Status, Jwa.Win_NT, Jwa.Win_Type;

use
  Interfaces, Jwa.Utils,
  Jwa.NT_Status, Jwa.Win_NT, Jwa.Win_Type;

package Jwa.Win_Base is

--%%   INVALID_HANDLE_VALUE     = HANDLE(-1);
--%%   {$EXTERNALSYM INVALID_HANDLE_VALUE}
   Invalid_File_Size        : constant := 16#FFFF_FFFF#;
   Invalid_Set_File_Pointer : constant := 16#FFFF_FFFF#;
   Invalid_File_Attributes  : constant := 16#FFFF_FFFF#;

   File_Begin   : constant := 0;
   File_Current : constant := 1;
   File_End     : constant := 2;

   Time_Zone_Id_Invalid : constant := 16#FFFF_FFFF#;

   Wait_Failed   : constant := 16#FFFF_FFFF#;
   Wait_Object_0 : constant := Status_Wait_0 + 0;

   Wait_Abandoned   : constant := Status_Abandoned_Wait_0 + 0;
   Wait_Abandoned_0 : constant := Status_Abandoned_Wait_0 + 0;

   Wait_IO_Completion                 : constant := Status_User_APC;
   Still_Active                       : constant := Status_Pending;
   Exception_Access_Violation         : constant := Status_Access_Violation;
   Exception_Datatype_Misalignment    : constant := Status_Datatype_Misalignment;
   Exception_Breakpoint               : constant := Status_Breakpoint;
   Exception_Single_Step              : constant := Status_Single_Step;
   Exception_Array_Bounds_Exceeded    : constant := Status_Array_Bounds_Exceeded;
   Exception_Flt_Denormal_Operand     : constant := Status_Float_Denormal_Operand;
   Exception_Flt_Divide_By_Zero       : constant := Status_Float_Divide_By_Zero;
   Exception_Flt_Inexact_Result       : constant := Status_Float_Inexact_Result;
   Exception_Flt_Invalid_Operation    : constant := Status_Float_Invalid_Operation;
   Exception_Flt_Overflow             : constant := Status_Float_Overflow;
   Exception_Flt_Stack_Check          : constant := Status_Float_Stack_Check;
   Exception_Flt_Underflow            : constant := Status_Float_Underflow;
   Exception_Int_Divide_By_Zero       : constant := Status_Integer_Divide_By_Zero;
   Exception_Int_Overflow             : constant := Status_Integer_Overflow;
   Exception_Priv_Instruction         : constant := Status_Privileged_Instruction;
   Exception_In_Page_Error            : constant := Status_In_Page_Error;
   Exception_Illegal_Instruction      : constant := Status_Illegal_Instruction;
   Exception_Noncontinuable_Exception : constant := Status_Noncontinuable_Exception;
   Exception_Stack_Overflow           : constant := Status_Stack_Overflow;
   Exception_Invalid_Disposition      : constant := Status_Invalid_Disposition;
   Exception_Guard_Page               : constant := Status_Guard_Page_Violation;
   Exception_Invalid_Handle           : constant := Status_Invalid_Handle;
   Exception_Possible_Deadlock        : constant := Status_Possible_Deadlock;
   Control_C_Exit                     : constant := Status_Control_C_Exit;

--%% procedure MoveMemory(Destination, Source: PVOID; Length: SIZE_T);
--%% {$EXTERNALSYM MoveMemory}
--%% procedure CopyMemory(Destination, Source: PVOID; Length: SIZE_T);
--%% {$EXTERNALSYM CopyMemory}
--%% procedure FillMemory(Destination: PVOID; Length: SIZE_T; Fill: BYTE);
--%% {$EXTERNALSYM FillMemory}
--%% procedure ZeroMemory(Destination: PVOID; Length: SIZE_T);
--%% {$EXTERNALSYM ZeroMemory}
-- #define SecureZeroMemory RtlSecureZeroMemory TODO

--
-- File creation flags must start at the high end since they
-- are combined with the attributes
--

   File_Flag_Write_Through      : constant := 16#8000_0000#;
   File_Flag_Overlapped         : constant := 16#4000_0000#;
   File_Flag_No_Buffering       : constant := 16#2000_0000#;
   File_Flag_Random_Access      : constant := 16#1000_0000#;
   File_Flag_Sequential_Scan    : constant := 16#0800_0000#;
   File_Flag_Delete_On_Close    : constant := 16#0400_0000#;
   File_Flag_Backup_Semantics   : constant := 16#0200_0000#;
   File_Flag_Posix_Semantics    : constant := 16#0100_0000#;
   File_Flag_Open_Reparse_Point : constant := 16#0020_0000#;
   File_Flag_Open_No_Recall     : constant := 16#0010_0000#;
   File_Flag_First_Pipe_Instance : constant := 16#0008_0000#;

   Create_New        : constant := 1;
   Create_Always     : constant := 2;
   Open_Existing     : constant := 3;
   Open_Always       : constant := 4;
   Truncate_Existing : constant := 5;

--
-- Define possible return codes from the CopyFileEx callback routine
--

   Progress_Continue : constant := 0;
   Progress_Cancel   : constant := 1;
   Progress_Stop     : constant := 2;
   Progress_Quiet    : constant := 3;

--
-- Define CopyFileEx callback routine state change values
--

   Callback_Chunk_Finished : constant := 16#0000_0000#;
   Callback_Stream_Switch  : constant := 16#0000_0001#;

--
-- Define CopyFileEx option flags
--

   Copy_File_Fail_If_Exists        : constant := 16#0000_0001#;
   Copy_File_Restartable           : constant := 16#0000_0002#;
   Copy_File_Open_Source_For_Write : constant := 16#0000_0004#;
   Copy_File_Allow_Decrypted_Destination : constant := 16#0000_0008#;

--
-- Define ReplaceFile option flags
--

   Replacefile_Write_Through       : constant := 16#0000_0001#;
   Replacefile_Ignore_Merge_Errors : constant := 16#0000_0002#;

--
-- Define the NamedPipe definitions
--

--
-- Define the dwOpenMode values for CreateNamedPipe
--

   Pipe_Access_Inbound  : constant := 16#0000_0001#;
   Pipe_Access_Outbound : constant := 16#0000_0002#;
   Pipe_Access_Duplex   : constant := 16#0000_0003#;

--
-- Define the Named Pipe End flags for GetNamedPipeInfo
--

   Pipe_Client_End : constant := 16#0000_0000#;
   Pipe_Server_End : constant := 16#0000_0001#;

--
-- Define the dwPipeMode values for CreateNamedPipe
--

   Pipe_Wait             : constant := 16#0000_0000#;
   Pipe_Nowait           : constant := 16#0000_0001#;
   Pipe_Readmode_Byte    : constant := 16#0000_0000#;
   Pipe_Readmode_Message : constant := 16#0000_0002#;
   Pipe_Type_Byte        : constant := 16#0000_0000#;
   Pipe_Type_Message     : constant := 16#0000_0004#;

--
-- Define the well known values for CreateNamedPipe nMaxInstances
--

   Pipe_Unlimited_Instances : constant := 255;

--
-- Define the Security Quality of Service bits to be passed
-- into CreateFile
--

--%%   SECURITY_ANONYMOUS      = Ord(SecurityAnonymous) shl 16;
--%%   {$EXTERNALSYM SECURITY_ANONYMOUS}
--%%   SECURITY_IDENTIFICATION = Ord(SecurityIdentification) shl 16;
--%%   {$EXTERNALSYM SECURITY_IDENTIFICATION}
--%%   SECURITY_IMPERSONATION  = Ord(SecurityImpersonation) shl 16;
--%%   {$EXTERNALSYM SECURITY_IMPERSONATION}
--%%   SECURITY_DELEGATION     = Ord(SecurityDelegation) shl 16;
--%%   {$EXTERNALSYM SECURITY_DELEGATION}

   Security_Context_Tracking : constant := 16#0004_0000#;
   Security_Effective_Only   : constant := 16#0008_0000#;

   Security_Sqos_Present     : constant := 16#0010_0000#;
   Security_Valid_Sqos_Flags : constant := 16#001F_0000#;

--
--  File structures
--

--%%   LPOVERLAPPED = ^OVERLAPPED;
--%%   {$EXTERNALSYM LPOVERLAPPED}
--%%   _OVERLAPPED = record
--%%     Internal: ULONG_PTR;
--%%     InternalHigh: ULONG_PTR;
--%%     Union: record
--%%     case Integer of
--%%       0: (
--%%         Offset: DWORD;
--%%         OffsetHigh: DWORD);
--%%       1: (
--%%         Pointer: PVOID);
--%%     end;
--%%     hEvent: HANDLE;
--%%   end;
--%%   {$EXTERNALSYM _OVERLAPPED}
--%%   OVERLAPPED = _OVERLAPPED;
--%%   {$EXTERNALSYM OVERLAPPED}
--%%   TOverlapped = OVERLAPPED;
--%%   POverlapped = LPOVERLAPPED;

   type Security_Attributes_Type;
   type Security_Attributes_Ptr is access all Security_Attributes_Type;
   type Security_Attributes_CPtr is access constant Security_Attributes_Type;
   type Security_Attributes_Type is record
      Length : Unsigned_32;
      Security_Descriptor : LPVOID;
      Inherit_Handle : Boolean_32;
   end record;

   type Process_Information_Type;
   type Process_Information_Ptr is access all Process_Information_Type;
   type Process_Information_CPtr is access constant Process_Information_Type;
   type Process_Information_Type is record
      Process : Handle_Type;
      Thread : Handle_Type;
      Process_Id : Unsigned_32;
      Thread_Id : Unsigned_32;
   end record;

--
--  File System time stamps are represented with the following structure:
--
--%%   {$IFNDEF JWA_INCLUDEMODE}
   type File_Time_Type;
   type File_Time_Ptr is access all File_Time_Type;
   type File_Time_CPtr is access constant File_Time_Type;
   type File_Time_Type is record
      Low_Date_Time : Unsigned_32;
      High_Date_Time : Unsigned_32;
   end record;
--%%   {$ENDIF JWA_INCLUDEMODE}

--
-- System time is represented with the following structure:
--

--%%   LPSYSTEMTIME = ^SYSTEMTIME;
--%%   {$EXTERNALSYM LPSYSTEMTIME}
--%%   {$IFDEF USE_DELPHI_TYPES}
--%%   _SYSTEMTIME = Windows._SYSTEMTIME;
--%%   SYSTEMTIME = Windows.SYSTEMTIME;
--%%   TSystemTime = Windows.TSystemTime;
--%%   PSystemtime = Windows.PSystemTime;
--%%   {$ELSE}
--%%   _SYSTEMTIME = record
--%%     wYear: Word;
--%%     wMonth: Word;
--%%     wDayOfWeek: Word;
--%%     wDay: Word;
--%%     wHour: Word;
--%%     wMinute: Word;
--%%     wSecond: Word;
--%%     wMilliseconds: Word;
--%%   end;
--%%   {$EXTERNALSYM _SYSTEMTIME}
--%%   SYSTEMTIME = _SYSTEMTIME;
--%%   {$EXTERNALSYM SYSTEMTIME}
--%%   TSystemTime = SYSTEMTIME;
--%%   PSystemTime = LPSYSTEMTIME;
--%%   {$ENDIF USE_DELPHI_TYPES}

--%%   PTHREAD_START_ROUTINE = function(lpThreadParameter: LPVOID): DWORD; stdcall;
--%%   {$EXTERNALSYM PTHREAD_START_ROUTINE}
--%%   LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
--%%   {$EXTERNALSYM LPTHREAD_START_ROUTINE}
--%%   TThreadStartRoutine = PTHREAD_START_ROUTINE;

--%%   PFIBER_START_ROUTINE = procedure(lpFiberParameter: LPVOID); stdcall;
--%%   {$EXTERNALSYM PFIBER_START_ROUTINE}
--%%   LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE;
--%%   {$EXTERNALSYM LPFIBER_START_ROUTINE}
--%%   TFiberStartRoutine = PFIBER_START_ROUTINE;

--%%   CRITICAL_SECTION = RTL_CRITICAL_SECTION;
--%%   {$EXTERNALSYM CRITICAL_SECTION}
--%%   PCRITICAL_SECTION = PRTL_CRITICAL_SECTION;
--%%   {$EXTERNALSYM PCRITICAL_SECTION}
--%%   LPCRITICAL_SECTION = PRTL_CRITICAL_SECTION;
--%%   {$EXTERNALSYM LPCRITICAL_SECTION}
--%%   TCriticalSection = CRITICAL_SECTION;
--%%   PCriticalSection = PCRITICAL_SECTION;

--%%   CRITICAL_SECTION_DEBUG = RTL_CRITICAL_SECTION_DEBUG;
--%%   {$EXTERNALSYM CRITICAL_SECTION_DEBUG}
--%%   PCRITICAL_SECTION_DEBUG = PRTL_CRITICAL_SECTION_DEBUG;
--%%   {$EXTERNALSYM PCRITICAL_SECTION_DEBUG}
--%%   LPCRITICAL_SECTION_DEBUG = PRTL_CRITICAL_SECTION_DEBUG;
--%%   {$EXTERNALSYM LPCRITICAL_SECTION_DEBUG}
--%%   TCriticalSectionDebug = CRITICAL_SECTION_DEBUG;
--%%   PCriticalSectionDebug = PCRITICAL_SECTION_DEBUG;  

   subtype Lpldt_Entry_Type is Ldt_Entry_Ptr;
   type Lpldt_Entry_Ptr is access all Ldt_Entry_Ptr;
   type Lpldt_Entry_CPtr is access constant Ldt_Entry_Ptr;

--%%   {$IFNDEF JWA_INCLUDEMODE}
--%%   PLdtEntry = LPLDT_ENTRY;
--%%   {$ENDIF JWA_INCLUDEMODE}

   Mutex_Modify_State : constant := Mutant_Query_State;
   Mutex_All_Access   : constant := Mutant_All_Access;

--
-- Serial provider type.
--

   Sp_Serialcomm : constant := 16#0000_0001#;

--
-- Provider SubTypes
--

   Pst_Unspecified    : constant := 16#0000_0000#;
   Pst_Rs232          : constant := 16#0000_0001#;
   Pst_Parallelport   : constant := 16#0000_0002#;
   Pst_Rs422          : constant := 16#0000_0003#;
   Pst_Rs423          : constant := 16#0000_0004#;
   Pst_Rs449          : constant := 16#0000_0005#;
   Pst_Modem          : constant := 16#0000_0006#;
   Pst_Fax            : constant := 16#0000_0021#;
   Pst_Scanner        : constant := 16#0000_0022#;
   Pst_Network_Bridge : constant := 16#0000_0100#;
   Pst_Lat            : constant := 16#0000_0101#;
   Pst_Tcpip_Telnet   : constant := 16#0000_0102#;
   Pst_X25            : constant := 16#0000_0103#;

--
-- Provider capabilities flags.
--

   Pcf_Dtrdsr        : constant := 16#0001#;
   Pcf_Rtscts        : constant := 16#0002#;
   Pcf_Rlsd          : constant := 16#0004#;
   Pcf_Parity_Check  : constant := 16#0008#;
   Pcf_Xonxoff       : constant := 16#0010#;
   Pcf_Setxchar      : constant := 16#0020#;
   Pcf_Totaltimeouts : constant := 16#0040#;
   Pcf_Inttimeouts   : constant := 16#0080#;
   Pcf_Specialchars  : constant := 16#0100#;
   Pcf_16Bitmode     : constant := 16#0200#;

--
-- Comm provider settable parameters.
--

   Sp_Parity       : constant := 16#0001#;
   Sp_Baud         : constant := 16#0002#;
   Sp_Databits     : constant := 16#0004#;
   Sp_Stopbits     : constant := 16#0008#;
   Sp_Handshaking  : constant := 16#0010#;
   Sp_Parity_Check : constant := 16#0020#;
   Sp_Rlsd         : constant := 16#0040#;

--
-- Settable baud rates in the provider.
--

   Baud_075    : constant := 16#0000_0001#;
   Baud_110    : constant := 16#0000_0002#;
   Baud_134_5  : constant := 16#0000_0004#;
   Baud_150    : constant := 16#0000_0008#;
   Baud_300    : constant := 16#0000_0010#;
   Baud_600    : constant := 16#0000_0020#;
   Baud_1200   : constant := 16#0000_0040#;
   Baud_1800   : constant := 16#0000_0080#;
   Baud_2400   : constant := 16#0000_0100#;
   Baud_4800   : constant := 16#0000_0200#;
   Baud_7200   : constant := 16#0000_0400#;
   Baud_9600   : constant := 16#0000_0800#;
   Baud_14400  : constant := 16#0000_1000#;
   Baud_19200  : constant := 16#0000_2000#;
   Baud_38400  : constant := 16#0000_4000#;
   Baud_56K    : constant := 16#0000_8000#;
   Baud_128K   : constant := 16#0001_0000#;
   Baud_115200 : constant := 16#0002_0000#;
   Baud_57600  : constant := 16#0004_0000#;
   Baud_User   : constant := 16#1000_0000#;

--
-- Settable Data Bits
--

   Databits_5   : constant := 16#0001#;
   Databits_6   : constant := 16#0002#;
   Databits_7   : constant := 16#0004#;
   Databits_8   : constant := 16#0008#;
   Databits_16  : constant := 16#0010#;
   Databits_16X : constant := 16#0020#;

--
-- Settable Stop and Parity bits.
--

   Stopbits_10  : constant := 16#0001#;
   Stopbits_15  : constant := 16#0002#;
   Stopbits_20  : constant := 16#0004#;
   Parity_None  : constant := 16#0100#;
   Parity_Odd   : constant := 16#0200#;
   Parity_Even  : constant := 16#0400#;
   Parity_Mark  : constant := 16#0800#;
   Parity_Space : constant := 16#1000#;

--%%   LPCOMMPROP = ^COMMPROP;
--%%   {$EXTERNALSYM LPCOMMPROP}
--%%   _COMMPROP = record
--%%     wPacketLength: Word;
--%%     wPacketVersion: Word;
--%%     dwServiceMask: DWORD;
--%%     dwReserved1: DWORD;
--%%     dwMaxTxQueue: DWORD;
--%%     dwMaxRxQueue: DWORD;
--%%     dwMaxBaud: DWORD;
--%%     dwProvSubType: DWORD;
--%%     dwProvCapabilities: DWORD;
--%%     dwSettableParams: DWORD;
--%%     dwSettableBaud: DWORD;
--%%     wSettableData: Word;
--%%     wSettableStopParity: Word;
--%%     dwCurrentTxQueue: DWORD;
--%%     dwCurrentRxQueue: DWORD;
--%%     dwProvSpec1: DWORD;
--%%     dwProvSpec2: DWORD;
--%%     wcProvChar: array [0..0] of WCHAR;
--%%   end;
--%%   {$EXTERNALSYM _COMMPROP}
--%%   COMMPROP = _COMMPROP;
--%%   {$EXTERNALSYM COMMPROP}
--%%   TCommProp = COMMPROP;
--%%   PCommProp = LPCOMMPROP;

--
-- Set dwProvSpec1 to COMMPROP_INITIALIZED to indicate that wPacketLength
-- is valid before a call to GetCommProperties().
--

   Commprop_Initialized : constant := 16#E73C_F52E#;

-- _COMSTAT Flags (bitfield)

   Comstat_Cts_Hold   : constant := 2#0000_0000_0000_0001#;
   Comstat_Dsr_Hold   : constant := 2#0000_0000_0000_0010#;
   Comstat_Rlsd_Hold  : constant := 2#0000_0000_0000_0100#;
   Comstat_XOFF_Hold  : constant := 2#0000_0000_0000_1000#;
   Comstat_XOFF_Sent  : constant := 2#0000_0000_0001_0000#;
   Comstat_F_Eof      : constant := 2#0000_0000_0010_0000#;
   Comstat_F_Txim     : constant := 2#0000_0000_0100_0000#;

   type Comstat_Type;
   type Comstat_Ptr is access all Comstat_Type;
   type Comstat_CPtr is access constant Comstat_Type;
   type Comstat_Type is record
      Flags : Unsigned_32;
      In_Que : Unsigned_32;
      Out_Que : Unsigned_32;
   end record;

--
-- DTR Control Flow Values.
--

   Dtr_Control_Disable   : constant := 16#00#;
   Dtr_Control_Enable    : constant := 16#01#;
   Dtr_Control_Handshake : constant := 16#02#;

--
-- RTS Control Flow Values
--

   RTS_Control_Disable   : constant := 16#00#;
   RTS_Control_Enable    : constant := 16#01#;
   RTS_Control_Handshake : constant := 16#02#;
   RTS_Control_Toggle    : constant := 16#03#;

-- _DCB.Flags

   fDcbBinary : constant := 2#0000_0000_0000_0001#;           -- Binary Mode (skip EOF check)
   fDcbParity : constant := 2#0000_0000_0000_0010#;           -- Enable parity checking
   fDcbOutxCtsFlow : constant := 2#0000_0000_0000_0100#;      -- CTS handshaking on output
   fDcbOutxDsrFlow : constant := 2#0000_0000_0000_1000#;      -- DSR handshaking on output
   fDcbDtrControl : constant := 16#0030#;         -- DTR Flow control
   fDcbDsrSensitivity : constant := 2#0000_0000_0100_0000#;   -- DSR Sensitivity
   fDcbTxcontinueOnXoff : constant := 2#0000_0000_1000_0000#; -- Continue TX when Xoff sent
   fDcbOutX : constant := 2#0000_0001_0000_0000#;             -- Enable output X-ON/X-OFF
   fDcbInX : constant := 2#0000_0010_0000_0000#;              -- Enable input X-ON/X-OFF
   fDcbErrorChar : constant := 2#0000_0100_0000_0000# ;       -- Enable Err Replacement
   fDcbNull : constant := 2#0000_1000_0000_0000# ;            -- Enable Null stripping
   fDcbRtsControl : constant := 16#3000#;         -- Rts Flow control
   fAbortOnError : constant := 2#0100_0000_0000_0000# ;       -- Abort all reads and writes on Error

   type DCB_Type;
   type DCB_Ptr is access all DCB_Type;
   type DCB_CPtr is access constant DCB_Type;
   type DCB_Type is record
      DC_Blength : Unsigned_32;    -- sizeof(DCB)
      Baud_Rate : Unsigned_32;     -- Baudrate at which running
      Flags : Unsigned_32;         -- See constants above
      Reserved : Unsigned_16;      -- Not currently used
      XON_Lim : Unsigned_16;       -- Transmit X-ON threshold
      XOFF_Lim : Unsigned_16;      -- Transmit X-OFF threshold
      Byte_Size : Unsigned_8;      -- Number of bits/byte, 4-8
      Parity : Unsigned_8;         -- 0-4=None,Odd,Even,Mark,Space
      Stop_Bits : Unsigned_8;      -- 0,1,2 = 1, 1.5, 2
      XON_Char : Char;             -- Tx and Rx X-ON character
      XOFF_Char : Char;            -- Tx and Rx X-OFF character
      Error_Char : Char;           -- Error replacement char
      Eof_Char : Char;             -- End of Input character
      Evt_Char : Char;             -- Received Event character
      Reserved1 : Unsigned_16;     -- Fill for now.
   end record;

   type Comm_Timeouts_Type;
   type Comm_Timeouts_Ptr is access all Comm_Timeouts_Type;
   type Comm_Timeouts_CPtr is access constant Comm_Timeouts_Type;
   type Comm_Timeouts_Type is record
      Read_Interval_Timeout : Unsigned_32;      -- Maximum time between read chars.
      Read_Total_Timeout_Multiplier : Unsigned_32; -- Multiplier of characters.
      Read_Total_Timeout_Constant : Unsigned_32; -- Constant in milliseconds.
      Write_Total_Timeout_Multiplier : Unsigned_32; -- Multiplier of characters.
      Write_Total_Timeout_Constant : Unsigned_32; -- Constant in milliseconds.
   end record;

--%%   LPCOMMCONFIG = ^COMMCONFIG;
--%%   {$EXTERNALSYM LPCOMMCONFIG}
--%%   _COMMCONFIG = record
--%%     dwSize: DWORD;            // Size of the entire struct
--%%     wVersion: Word;           // version of the structure
--%%     wReserved: Word;          // alignment
--%%     dcb: DCB;                 // device control block
--%%     dwProviderSubType: DWORD; // ordinal value for identifying
--%%                               // provider-defined data structure format
--%%     dwProviderOffset: DWORD;  // Specifies the offset of provider specific
--%%                               // data field in bytes from the start
--%%     dwProviderSize: DWORD;    // size of the provider-specific data field
--%%     wcProviderData: array [0..0] of WCHAR; // provider-specific data
--%%   end;
--%%   {$EXTERNALSYM _COMMCONFIG}
--%%   COMMCONFIG = _COMMCONFIG;
--%%   {$EXTERNALSYM COMMCONFIG}
--%%   TCommConfig = COMMCONFIG;
--%%   PCommConfig = LPCOMMCONFIG;

--%%   LPSYSTEM_INFO = ^SYSTEM_INFO;
--%%   {$EXTERNALSYM LPSYSTEM_INFO}
--%%   _SYSTEM_INFO = record
--%%     case Integer of
--%%     0: (
--%%       dwOemId: DWORD); // absolete, do not use
--%%     1: (
--%%       wProcessorArchitecture: WORD;
--%%       wReserved: WORD;
--%%       dwPageSize: DWORD;
--%%       lpMinimumApplicationAddress: LPVOID;
--%%       lpMaximumApplicationAddress: LPVOID;
--%%       dwActiveProcessorMask: DWORD_PTR;
--%%       dwNumberOfProcessors: DWORD;
--%%       dwProcessorType: DWORD;
--%%       dwAllocationGranularity: DWORD;
--%%       wProcessorLevel: WORD;
--%%       wProcessorRevision: WORD);
--%%   end;
--%%   {$EXTERNALSYM _SYSTEM_INFO}
--%%   SYSTEM_INFO = _SYSTEM_INFO;
--%%   {$EXTERNALSYM SYSTEM_INFO}
--%%   TSystemInfo = SYSTEM_INFO;
--%%   PSystemInfo = LPSYSTEM_INFO;

--
--

--%% function FreeModule(hLibModule: HMODULE): BOOL;
--%% {$EXTERNALSYM FreeModule}
--%% function MakeProcInstance(lpProc: FARPROC; hInstance: HINST): FARPROC;
--%% {$EXTERNALSYM MakeProcInstance}
--%% procedure FreeProcInstance(lpProc: FARPROC);
--%% {$EXTERNALSYM FreeProcInstance}

-- Global Memory Flags

   GMem_Fixed          : constant := 16#0000#;
   GMem_Moveable       : constant := 16#0002#;
   GMem_Nocompact      : constant := 16#0010#;
   GMem_Nodiscard      : constant := 16#0020#;
   GMem_Zeroinit       : constant := 16#0040#;
   GMem_Modify         : constant := 16#0080#;
   GMem_Discardable    : constant := 16#0100#;
   GMem_Not_Banked     : constant := 16#1000#;
   GMem_Share          : constant := 16#2000#;
   GMem_Ddeshare       : constant := 16#2000#;
   GMem_Notify         : constant := 16#4000#;
   GMem_Lower          : constant := GMem_Not_Banked;
   GMem_Valid_Flags    : constant := 16#7F72#;
   GMem_Invalid_Handle : constant := 16#8000#;

--%%   GHND = GMEM_MOVEABLE or GMEM_ZEROINIT;
--%%   {$EXTERNALSYM GHND}
--%%   GPTR = GMEM_FIXED or GMEM_ZEROINIT;
--%%   {$EXTERNALSYM GPTR}

--%% function GlobalLRUNewest(h: HANDLE): HANDLE;
--%% {$EXTERNALSYM GlobalLRUNewest}
--%% function GlobalLRUOldest(h: HANDLE): HANDLE;
--%% {$EXTERNALSYM GlobalLRUOldest}
--%% function GlobalDiscard(h: HANDLE): HANDLE;
--%% {$EXTERNALSYM GlobalDiscard}

-- Flags returned by GlobalFlags (in addition to GMEM_DISCARDABLE)

   GMem_Discarded : constant := 16#4000#;
   GMem_Lockcount : constant := 16#00FF#;

   type Memory_Status_Type;
   type Memory_Status_Ptr is access all Memory_Status_Type;
   type Memory_Status_CPtr is access constant Memory_Status_Type;
   type Memory_Status_Type is record
      Length : Unsigned_32;
      Memory_Load : Unsigned_32;
      Total_Phys : SIZE_T;
      Avail_Phys : SIZE_T;
      Total_Page_File : SIZE_T;
      Avail_Page_File : SIZE_T;
      Total_Virtual : SIZE_T;
      Avail_Virtual : SIZE_T;
   end record;

-- Local Memory Flags

   LMem_Fixed          : constant := 16#0000#;
   LMem_Moveable       : constant := 16#0002#;
   LMem_Nocompact      : constant := 16#0010#;
   LMem_Nodiscard      : constant := 16#0020#;
   LMem_Zeroinit       : constant := 16#0040#;
   LMem_Modify         : constant := 16#0080#;
   LMem_Discardable    : constant := 16#0F00#;
   LMem_Valid_Flags    : constant := 16#0F72#;
   LMem_Invalid_Handle : constant := 16#8000#;

--%%   LHND = LMEM_MOVEABLE or LMEM_ZEROINIT;
--%%   {$EXTERNALSYM LHND}
--%%   LPTR = LMEM_FIXED or LMEM_ZEROINIT;
--%%   {$EXTERNALSYM LPTR}

   Nonzerolhnd : constant := LMem_Moveable;
   Nonzerolptr : constant := LMem_Fixed;

--%% function LocalDiscard(h: HLOCAL): HLOCAL;
--%% {$EXTERNALSYM LocalDiscard}

-- Flags returned by LocalFlags (in addition to LMEM_DISCARDABLE)

   LMem_Discarded : constant := 16#4000#;
   LMem_Lockcount : constant := 16#00FF#;

--
-- dwCreationFlag values
--

   Debug_Process           : constant := 16#0000_0001#;
   Debug_Only_This_Process : constant := 16#0000_0002#;

   Create_Suspended : constant := 16#0000_0004#;

   Detached_Process : constant := 16#0000_0008#;

   Create_New_Console : constant := 16#0000_0010#;

   Normal_Priority_Class   : constant := 16#0000_0020#;
   Idle_Priority_Class     : constant := 16#0000_0040#;
   High_Priority_Class     : constant := 16#0000_0080#;
   Realtime_Priority_Class : constant := 16#0000_0100#;

   Create_New_Process_Group   : constant := 16#0000_0200#;
   Create_Unicode_Environment : constant := 16#0000_0400#;

   Create_Separate_Wow_Vdm : constant := 16#0000_0800#;
   Create_Shared_Wow_Vdm   : constant := 16#0000_1000#;
   Create_Forcedos         : constant := 16#0000_2000#;

   Below_Normal_Priority_Class : constant := 16#0000_4000#;
   Above_Normal_Priority_Class : constant := 16#0000_8000#;
   Stack_Size_Param_Is_A_Reservation : constant := 16#0001_0000#;

   Create_Breakaway_From_Job : constant := 16#0100_0000#;
   Create_Preserve_Code_Authz_Level : constant := 16#0200_0000#;

   Create_Default_Error_Mode : constant := 16#0400_0000#;
   Create_No_Window          : constant := 16#0800_0000#;

   Profile_User   : constant := 16#1000_0000#;
   Profile_Kernel : constant := 16#2000_0000#;
   Profile_Server : constant := 16#4000_0000#;

   Create_Ignore_System_Default : constant := 16#8000_0000#;

   Thread_Priority_Lowest       : constant := Thread_Base_Priority_Min;
   Thread_Priority_Below_Normal : constant := Thread_Priority_Lowest + 1;
   Thread_Priority_Normal       : constant := 0;
   Thread_Priority_Highest      : constant := Thread_Base_Priority_Max;
   Thread_Priority_Above_Normal : constant := Thread_Priority_Highest - 1;
   Thread_Priority_Error_Return : constant := Maxlong;

   Thread_Priority_Time_Critical : constant := Thread_Base_Priority_Lowrt;
   Thread_Priority_Idle          : constant := Thread_Base_Priority_Idle;

--
-- Debug APIs
--

   Exception_Debug_Event      : constant := 1;
   Create_Thread_Debug_Event  : constant := 2;
   Create_Process_Debug_Event : constant := 3;
   Exit_Thread_Debug_Event    : constant := 4;
   Exit_Process_Debug_Event   : constant := 5;
   Load_DLL_Debug_Event       : constant := 6;
   Unload_DLL_Debug_Event     : constant := 7;
   Output_Debug_String_Event  : constant := 8;
   Rip_Event                  : constant := 9;

   type Exception_Debug_Info_Type;
   type Exception_Debug_Info_Ptr is access all Exception_Debug_Info_Type;
   type Exception_Debug_Info_CPtr is access constant Exception_Debug_Info_Type;
   type Exception_Debug_Info_Type is record
      Exception_Record : EXCEPTION_RECORD;
      First_Chance : Unsigned_32;
   end record;

   type Create_Thread_Debug_Info_Type;
   type Create_Thread_Debug_Info_Ptr is access all Create_Thread_Debug_Info_Type;
   type Create_Thread_Debug_Info_CPtr is access constant Create_Thread_Debug_Info_Type;
   type Create_Thread_Debug_Info_Type is record
      Thread : Handle_Type;
      Thread_Local_Base : LPVOID;
      Start_Address : LPTHREAD_START_ROUTINE;
   end record;

   type Create_Process_Debug_Info_Type;
   type Create_Process_Debug_Info_Ptr is access all Create_Process_Debug_Info_Type;
   type Create_Process_Debug_Info_CPtr is access constant Create_Process_Debug_Info_Type;
   type Create_Process_Debug_Info_Type is record
      File : Handle_Type;
      Process : Handle_Type;
      Thread : Handle_Type;
      Base_Of_Image : LPVOID;
      Debug_Info_File_Offset : Unsigned_32;
      Debug_Info_Size : Unsigned_32;
      Thread_Local_Base : LPVOID;
      Start_Address : LPTHREAD_START_ROUTINE;
      Image_Name : LPVOID;
      Unicode : Word;
   end record;

   type Exit_Thread_Debug_Info_Type;
   type Exit_Thread_Debug_Info_Ptr is access all Exit_Thread_Debug_Info_Type;
   type Exit_Thread_Debug_Info_CPtr is access constant Exit_Thread_Debug_Info_Type;
   type Exit_Thread_Debug_Info_Type is record
      Exit_Code : Unsigned_32;
   end record;

   type Exit_Process_Debug_Info_Type;
   type Exit_Process_Debug_Info_Ptr is access all Exit_Process_Debug_Info_Type;
   type Exit_Process_Debug_Info_CPtr is access constant Exit_Process_Debug_Info_Type;
   type Exit_Process_Debug_Info_Type is record
      Exit_Code : Unsigned_32;
   end record;

   type Load_DLL_Debug_Info_Type;
   type Load_DLL_Debug_Info_Ptr is access all Load_DLL_Debug_Info_Type;
   type Load_DLL_Debug_Info_CPtr is access constant Load_DLL_Debug_Info_Type;
   type Load_DLL_Debug_Info_Type is record
      File : Handle_Type;
      Base_Of_DLL : LPVOID;
      Debug_Info_File_Offset : Unsigned_32;
      Debug_Info_Size : Unsigned_32;
      Image_Name : LPVOID;
      Unicode : Word;
   end record;

   type Unload_DLL_Debug_Info_Type;
   type Unload_DLL_Debug_Info_Ptr is access all Unload_DLL_Debug_Info_Type;
   type Unload_DLL_Debug_Info_CPtr is access constant Unload_DLL_Debug_Info_Type;
   type Unload_DLL_Debug_Info_Type is record
      Base_Of_DLL : LPVOID;
   end record;

   type Output_Debug_String_Info_Type;
   type Output_Debug_String_Info_Ptr is access all Output_Debug_String_Info_Type;
   type Output_Debug_String_Info_CPtr is access constant Output_Debug_String_Info_Type;
   type Output_Debug_String_Info_Type is record
      Debug_String_Data : Char_8_Ptr;
      Unicode : Word;
      Debug_String_Length : Word;
   end record;

   type Rip_Info_Type;
   type Rip_Info_Ptr is access all Rip_Info_Type;
   type Rip_Info_CPtr is access constant Rip_Info_Type;
   type Rip_Info_Type is record
      Error : Unsigned_32;
      Type : Unsigned_32;
   end record;

--%%   LPDEBUG_EVENT = ^DEBUG_EVENT;
--%%   {$EXTERNALSYM LPDEBUG_EVENT}
--%%   _DEBUG_EVENT = record
--%%     dwDebugEventCode: DWORD;
--%%     dwProcessId: DWORD;
--%%     dwThreadId: DWORD;
--%%     case Integer of
--%%       0: (Exception: EXCEPTION_DEBUG_INFO);
--%%       1: (CreateThread: CREATE_THREAD_DEBUG_INFO);
--%%       2: (CreateProcessInfo: CREATE_PROCESS_DEBUG_INFO);
--%%       3: (ExitThread: EXIT_THREAD_DEBUG_INFO);
--%%       4: (ExitProcess: EXIT_PROCESS_DEBUG_INFO);
--%%       5: (LoadDll: LOAD_DLL_DEBUG_INFO);
--%%       6: (UnloadDll: UNLOAD_DLL_DEBUG_INFO);
--%%       7: (DebugString: OUTPUT_DEBUG_STRING_INFO);
--%%       8: (RipInfo: RIP_INFO);
--%%   end;
--%%   {$EXTERNALSYM _DEBUG_EVENT}
--%%   DEBUG_EVENT = _DEBUG_EVENT;
--%%   {$EXTERNALSYM DEBUG_EVENT}
--%%   TDebugEvent = DEBUG_EVENT;
--%%   PDebugEvent = LPDEBUG_EVENT;

--%%   LPCONTEXT = PCONTEXT;
--%%   {$EXTERNALSYM LPCONTEXT}
--%%   LPEXCEPTION_RECORD = PEXCEPTION_RECORD;
--%%   {$EXTERNALSYM LPEXCEPTION_RECORD}
   subtype Lpexception_Pointers_Type is Exception_Pointers_Ptr;
   type Lpexception_Pointers_Ptr is access all Exception_Pointers_Ptr;
   type Lpexception_Pointers_CPtr is access constant Exception_Pointers_Ptr;

   Drive_Unknown     : constant := 0;
   Drive_No_Root_Dir : constant := 1;
   Drive_Removable   : constant := 2;
   Drive_Fixed       : constant := 3;
   Drive_Remote      : constant := 4;
   Drive_CDRom       : constant := 5;
   Drive_Ramdisk     : constant := 6;

--%% function GetFreeSpace(w: WORD): DWORD;
--%% {$EXTERNALSYM GetFreeSpace}

   File_Type_Unknown : constant := 16#0000#;
   File_Type_Disk    : constant := 16#0001#;
   File_Type_Char    : constant := 16#0002#;
   File_Type_Pipe    : constant := 16#0003#;
   File_Type_Remote  : constant := 16#8000#;

--%%   STD_INPUT_HANDLE  = DWORD(-10);
--%%   {$EXTERNALSYM STD_INPUT_HANDLE}
--%%   STD_OUTPUT_HANDLE = DWORD(-11);
--%%   {$EXTERNALSYM STD_OUTPUT_HANDLE}
--%%   STD_ERROR_HANDLE  = DWORD(-12);
--%%   {$EXTERNALSYM STD_ERROR_HANDLE}

   Noparity    : constant := 0;
   Oddparity   : constant := 1;
   Evenparity  : constant := 2;
   Markparity  : constant := 3;
   Spaceparity : constant := 4;

   Onestopbit   : constant := 0;
   One5Stopbits : constant := 1;
   Twostopbits  : constant := 2;

   Ignore   : constant := 0;                -- Ignore signal
   Infinite : constant := 16#FFFF_FFFF#; -- Infinite timeout

--
-- Baud rates at which the communication device operates
--

   CBR_110    : constant := 110;
   CBR_300    : constant := 300;
   CBR_600    : constant := 600;
   CBR_1200   : constant := 1200;
   CBR_2400   : constant := 2400;
   CBR_4800   : constant := 4800;
   CBR_9600   : constant := 9600;
   CBR_14400  : constant := 14400;
   CBR_19200  : constant := 19200;
   CBR_38400  : constant := 38400;
   CBR_56000  : constant := 56000;
   CBR_57600  : constant := 57600;
   CBR_115200 : constant := 115200;
   CBR_128000 : constant := 128000;
   CBR_256000 : constant := 256000;

--
-- Error Flags
--

   Ce_Rxover   : constant := 16#0001#; -- Receive Queue overflow
   Ce_Overrun  : constant := 16#0002#; -- Receive Overrun Error
   Ce_Rxparity : constant := 16#0004#; -- Receive Parity Error
   Ce_Frame    : constant := 16#0008#; -- Receive Framing error
   Ce_Break    : constant := 16#0010#; -- Break Detected
   Ce_Txfull   : constant := 16#0100#; -- TX Queue is full
   Ce_Pto      : constant := 16#0200#; -- LPTx Timeout
   Ce_Ioe      : constant := 16#0400#; -- LPTx I/O Error
   Ce_Dns      : constant := 16#0800#; -- LPTx Device not selected
   Ce_Oop      : constant := 16#1000#; -- LPTx Out-Of-Paper
   Ce_Mode     : constant := 16#8000#; -- Requested mode unsupported

   Ie_Badid    : constant := 16#FFFF_FFFF#; -- Invalid or unsupported id
--%%   IE_OPEN     = DWORD(-2); // Device Already Open
--%%   {$EXTERNALSYM IE_OPEN}
--%%   IE_NOPEN    = DWORD(-3); // Device Not Open
--%%   {$EXTERNALSYM IE_NOPEN}
--%%   IE_MEMORY   = DWORD(-4); // Unable to allocate queues
--%%   {$EXTERNALSYM IE_MEMORY}
--%%   IE_DEFAULT  = DWORD(-5); // Error in default parameters
--%%   {$EXTERNALSYM IE_DEFAULT}
--%%   IE_HARDWARE = DWORD(-10); // Hardware Not Present
--%%   {$EXTERNALSYM IE_HARDWARE}
--%%   IE_BYTESIZE = DWORD(-11); // Illegal Byte Size
--%%   {$EXTERNALSYM IE_BYTESIZE}
--%%   IE_BAUDRATE = DWORD(-12); // Unsupported BaudRate
--%%   {$EXTERNALSYM IE_BAUDRATE}

--
-- Events
--

   Ev_Rxchar   : constant := 16#0001#; -- Any Character received
   Ev_Rxflag   : constant := 16#0002#; -- Received certain character
   Ev_Txempty  : constant := 16#0004#; -- Transmitt Queue Empty
   Ev_Cts      : constant := 16#0008#; -- CTS changed state
   Ev_Dsr      : constant := 16#0010#; -- DSR changed state
   Ev_Rlsd     : constant := 16#0020#; -- RLSD changed state
   Ev_Break    : constant := 16#0040#; -- BREAK received
   Ev_Err      : constant := 16#0080#; -- Line status error occurred
   Ev_Ring     : constant := 16#0100#; -- Ring signal detected
   Ev_Perr     : constant := 16#0200#; -- Printer error occured
   Ev_Rx80Full : constant := 16#0400#; -- Receive buffer is 80 percent full
   Ev_Event1   : constant := 16#0800#; -- Provider specific event 1
   Ev_Event2   : constant := 16#1000#; -- Provider specific event 2

--
-- Escape Functions
--

   Setxoff  : constant := 1; -- Simulate XOFF received
   Setxon   : constant := 2; -- Simulate XON received
   Setrts   : constant := 3; -- Set RTS high
   Clrrts   : constant := 4; -- Set RTS low
   Setdtr   : constant := 5; -- Set DTR high
   Clrdtr   : constant := 6; -- Set DTR low
   Resetdev : constant := 7; -- Reset device if possible
   Setbreak : constant := 8; -- Set the device break line.
   Clrbreak : constant := 9; -- Clear the device break line.

--
-- PURGE function flags.
--

   Purge_Txabort : constant := 16#0001#; -- Kill the pending/current writes to the comm port.
   Purge_Rxabort : constant := 16#0002#; -- Kill the pending/current reads to the comm port.
   Purge_Txclear : constant := 16#0004#; -- Kill the transmit queue if there.
   Purge_Rxclear : constant := 16#0008#; -- Kill the typeahead buffer if there.

   Lptx : constant := 16#80#; -- Set if ID is for LPT device

--
-- Modem Status Flags
--

   MS_Cts_On  : constant := 16#0010#;
   MS_Dsr_On  : constant := 16#0020#;
   MS_Ring_On : constant := 16#0040#;
   MS_Rlsd_On : constant := 16#0080#;

--
-- WaitSoundState() Constants
--

   S_Queueempty   : constant := 0;
   S_Threshold    : constant := 1;
   S_Allthreshold : constant := 2;

--
-- Accent Modes
--

   S_Normal   : constant := 0;
   S_Legato   : constant := 1;
   S_Staccato : constant := 2;

--
-- SetSoundNoise() Sources
--

   S_Period512   : constant := 0; -- Freq = N/512 high pitch, less coarse hiss
   S_Period1024  : constant := 1; -- Freq = N/1024
   S_Period2048  : constant := 2; -- Freq = N/2048 low pitch, more coarse hiss
   S_Periodvoice : constant := 3; -- Source is frequency from voice channel (3)
   S_White512    : constant := 4; -- Freq = N/512 high pitch, less coarse hiss
   S_White1024   : constant := 5; -- Freq = N/1024
   S_White2048   : constant := 6; -- Freq = N/2048 low pitch, more coarse hiss
   S_Whitevoice  : constant := 7; -- Source is frequency from voice channel (3)

   S_Serdvna : constant := 16#FFFF_FFFF#; -- Device not available
--%%   S_SEROFM  = DWORD(-2); // Out of memory
--%%   {$EXTERNALSYM S_SEROFM}
--%%   S_SERMACT = DWORD(-3); // Music active
--%%   {$EXTERNALSYM S_SERMACT}
--%%   S_SERQFUL = DWORD(-4); // Queue full
--%%   {$EXTERNALSYM S_SERQFUL}
--%%   S_SERBDNT = DWORD(-5); // Invalid note
--%%   {$EXTERNALSYM S_SERBDNT}
--%%   S_SERDLN  = DWORD(-6); // Invalid note length
--%%   {$EXTERNALSYM S_SERDLN}
--%%   S_SERDCC  = DWORD(-7); // Invalid note count
--%%   {$EXTERNALSYM S_SERDCC}
--%%   S_SERDTP  = DWORD(-8); // Invalid tempo
--%%   {$EXTERNALSYM S_SERDTP}
--%%   S_SERDVL  = DWORD(-9); // Invalid volume
--%%   {$EXTERNALSYM S_SERDVL}
--%%   S_SERDMD  = DWORD(-10); // Invalid mode
--%%   {$EXTERNALSYM S_SERDMD}
--%%   S_SERDSH  = DWORD(-11); // Invalid shape
--%%   {$EXTERNALSYM S_SERDSH}
--%%   S_SERDPT  = DWORD(-12); // Invalid pitch
--%%   {$EXTERNALSYM S_SERDPT}
--%%   S_SERDFQ  = DWORD(-13); // Invalid frequency
--%%   {$EXTERNALSYM S_SERDFQ}
--%%   S_SERDDR  = DWORD(-14); // Invalid duration
--%%   {$EXTERNALSYM S_SERDDR}
--%%   S_SERDSR  = DWORD(-15); // Invalid source
--%%   {$EXTERNALSYM S_SERDSR}
--%%   S_SERDST  = DWORD(-16); // Invalid state
--%%   {$EXTERNALSYM S_SERDST}

   Nmpwait_Wait_Forever     : constant := 16#FFFF_FFFF#;
   Nmpwait_Nowait           : constant := 16#0000_0001#;
   Nmpwait_Use_Default_Wait : constant := 16#0000_0000#;

   FS_Case_Is_Preserved      : constant := File_Case_Preserved_Names;
   FS_Case_Sensitive         : constant := File_Case_Sensitive_Search;
   FS_Unicode_Stored_On_Disk : constant := File_Unicode_On_Disk;
   FS_Persistent_Acls        : constant := File_Persistent_Acls;
   FS_Vol_Is_Compressed      : constant := File_Volume_Is_Compressed;
   FS_File_Compression       : constant := File_File_Compression;
   FS_File_Encryption        : constant := File_Supports_Encryption;

   File_Map_Copy       : constant := Section_Query;
   File_Map_Write      : constant := Section_Map_Write;
   File_Map_Read       : constant := Section_Map_Read;
   File_Map_All_Access : constant := Section_All_Access;

   Of_Read             : constant := 16#0000_0000#;
   Of_Write            : constant := 16#0000_0001#;
   Of_ReadWrite        : constant := 16#0000_0002#;
   Of_Share_Compat     : constant := 16#0000_0000#;
   Of_Share_Exclusive  : constant := 16#0000_0010#;
   Of_Share_Deny_Write : constant := 16#0000_0020#;
   Of_Share_Deny_Read  : constant := 16#0000_0030#;
   Of_Share_Deny_None  : constant := 16#0000_0040#;
   Of_Parse            : constant := 16#0000_0100#;
   Of_Delete           : constant := 16#0000_0200#;
   Of_Verify           : constant := 16#0000_0400#;
   Of_Cancel           : constant := 16#0000_0800#;
   Of_Create           : constant := 16#0000_1000#;
   Of_Prompt           : constant := 16#0000_2000#;
   Of_Exist            : constant := 16#0000_4000#;
   Of_Reopen           : constant := 16#0000_8000#;

   Ofs_Maxpathname : constant := 128;

--%%   LPOFSTRUCT = ^OFSTRUCT;
--%%   {$EXTERNALSYM LPOFSTRUCT}
--%%   _OFSTRUCT = record
--%%     cBytes: Byte;
--%%     fFixedDisk: Byte;
--%%     nErrCode: Word;
--%%     Reserved1: Word;
--%%     Reserved2: Word;
--%%     szPathName: array [0..OFS_MAXPATHNAME - 1] of CHAR;
--%%   end;
--%%   {$EXTERNALSYM _OFSTRUCT}
--%%   OFSTRUCT = _OFSTRUCT;
--%%   {$EXTERNALSYM OFSTRUCT}
--%%   TOfStruct = OFSTRUCT;
--%%   POfStruct = LPOFSTRUCT;

-- 64 bit interlocked functions, donated by Will DeWitt Jr.

--%% function  InterlockedCompareExchange64(var Destination: LONGLONG; Exchange, Comperand: LONGLONG): LONGLONG; stdcall;
--%% {$EXTERNALSYM InterlockedCompareExchange64}

--%% function  InterlockedAnd64(var Destination: LONGLONG; Value: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedAnd64}

--%% function  InterlockedOr64(var Destination: LONGLONG; Value: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedOr64}

--%% function  InterlockedXor64(var Destination: LONGLONG; Value: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedXor64}

--%% function  InterlockedIncrement64(var Addend: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedIncrement64}

--%% function  InterlockedDecrement64(var Addend: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedDecrement}

--%% function  InterlockedExchange64(var Target: LONGLONG; Value: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedExchange64}

--%% function  InterlockedExchangeAdd64(var Addend: LONGLONG; Value: LONGLONG): LONGLONG;
--%% {$EXTERNALSYM InterlockedExchangeAdd64}

--
-- The Risc compilers support intrinsic functions for interlocked
-- increment, decrement, and exchange.
--

--%% function InterlockedIncrement(var lpAddend: LONG): LONG; stdcall;
--%% {$EXTERNALSYM InterlockedIncrement}

--%% function InterlockedDecrement(var lpAddend: LONG): LONG; stdcall;
--%% {$EXTERNALSYM InterlockedDecrement}

--%% function InterlockedExchange(var Target: LONG; Value: LONG): LONG; stdcall;
--%% {$EXTERNALSYM InterlockedExchange}

--%% function InterlockedExchangePointer(var Target: PVOID; Value: PVOID): PVOID;
--%% {$EXTERNALSYM InterlockedExchangePointer}

--%% function InterlockedExchangeAdd(var Addend: LONG; Value: LONG): LONG; stdcall;
--%% {$EXTERNALSYM InterlockedExchangeAdd}

--%% function InterlockedCompareExchange(var Destination: LONG; Exchange: LONG;
--%%   Comperand: LONG): LONG; stdcall;
--%% {$EXTERNALSYM InterlockedCompareExchange}

--%% function InterlockedCompareExchangePointer(var Destination: PVOID;
--%%   Exchange, Comperand: PVOID): PVOID;
--%% {$EXTERNALSYM InterlockedCompareExchangePointer}

--%% {
--%% #define InterlockedIncrementAcquire InterlockedIncrement
--%% #define InterlockedIncrementRelease InterlockedIncrement
--%% #define InterlockedDecrementAcquire InterlockedDecrement
--%% #define InterlockedDecrementRelease InterlockedDecrement
--%% #define InterlockedIncrementAcquire InterlockedIncrement
--%% #define InterlockedIncrementRelease InterlockedIncrement
--%% #define InterlockedCompareExchangeAcquire InterlockedCompareExchange
--%% #define InterlockedCompareExchangeRelease InterlockedCompareExchange
--%% #define InterlockedCompareExchangeAcquire64 InterlockedCompareExchange64
--%% #define InterlockedCompareExchangeRelease64 InterlockedCompareExchange64
--%% }

--%% procedure InitializeSListHead(ListHead: PSLIST_HEADER); stdcall;
--%% {$EXTERNALSYM InitializeSListHead}

--%% function InterlockedPopEntrySList(ListHead: PSLIST_HEADER): PSLIST_ENTRY; stdcall;
--%% {$EXTERNALSYM InterlockedPopEntrySList}

--%% function InterlockedPushEntrySList(ListHead: PSLIST_HEADER; ListEntry: PSLIST_ENTRY): PSLIST_ENTRY; stdcall;
--%% {$EXTERNALSYM InterlockedPushEntrySList}

--%% function InterlockedFlushSList(ListHead: PSLIST_HEADER): PSLIST_ENTRY; stdcall;
--%% {$EXTERNALSYM InterlockedFlushSList}

--%% function QueryDepthSList(ListHead: PSLIST_HEADER): USHORT; stdcall;
--%% {$EXTERNALSYM QueryDepthSList}

--%% function FreeResource(hResData: HGLOBAL): BOOL; stdcall;
--%% {$EXTERNALSYM FreeResource}

--%% function LockResource(hResData: HGLOBAL): LPVOID; stdcall;
--%% {$EXTERNALSYM LockResource}

--%% function UnlockResource(hResData: HANDLE): BOOL;
--%% {$EXTERNALSYM UnlockResource}

   Maxintatom : constant := 16#C000#;
--%%   INVALID_ATOM = ATOM(0);
--%%   {$EXTERNALSYM INVALID_ATOM}

--%%   MAKEINTATOMA = PAnsiChar;
--%%   MAKEINTATOMW = PWideChar;
--%%   {$IFDEF UNICODE}
--%%   MAKEINTATOM = MAKEINTATOMW;
--%%   {$EXTERNALSYM MAKEINTATOM}
--%%   {$ELSE}
--%%   MAKEINTATOM = MAKEINTATOMA;
--%%   {$EXTERNALSYM MAKEINTATOM}
--%%   {$ENDIF UNICODE}

--%% function FreeLibrary(hLibModule: HMODULE): BOOL; stdcall;
--%% {$EXTERNALSYM FreeLibrary}

--%% procedure FreeLibraryAndExitThread(hLibModule: HMODULE; dwExitCode: DWORD); stdcall;
--%% {$EXTERNALSYM FreeLibraryAndExitThread}

--%% function DisableThreadLibraryCalls(hLibModule: HMODULE): BOOL; stdcall;
--%% {$EXTERNALSYM DisableThreadLibraryCalls}

--%% function GetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC; stdcall;
--%% {$EXTERNALSYM GetProcAddress}

--%% function GetVersion: DWORD; stdcall;
--%% {$EXTERNALSYM GetVersion)}

--%% function GlobalAlloc(uFlags: UINT; dwBytes: SIZE_T): HGLOBAL; stdcall;
--%% {$EXTERNALSYM GlobalAlloc}

--%% function GlobalReAlloc(hMem: HGLOBAL; dwBytes: SIZE_T; uFlags: UINT): HGLOBAL; stdcall;
--%% {$EXTERNALSYM GlobalReAlloc}

--%% function GlobalSize(hMem: HGLOBAL): SIZE_T; stdcall;
--%% {$EXTERNALSYM GlobalSize}

--%% function GlobalFlags(hMem: HGLOBAL): UINT; stdcall;
--%% {$EXTERNALSYM GlobalFlags}

--%% function GlobalLock(hMem: HGLOBAL): LPVOID; stdcall;
--%% {$EXTERNALSYM GlobalLock}

-- !!!MWH My version  win31 = DWORD WINAPI GlobalHandle(UINT)

--%% function GlobalHandle(pMem: LPCVOID): HGLOBAL; stdcall;
--%% {$EXTERNALSYM GlobalHandle}

--%% function GlobalUnlock(hMem: HGLOBAL): BOOL; stdcall;
--%% {$EXTERNALSYM GlobalUnlock}

--%% function GlobalFree(hMem: HGLOBAL): HGLOBAL; stdcall;
--%% {$EXTERNALSYM GlobalFree}

--%% function GlobalCompact(dwMinFree: DWORD): SIZE_T; stdcall;
--%% {$EXTERNALSYM GlobalCompact}

--%% procedure GlobalFix(hMem: HGLOBAL); stdcall;
--%% {$EXTERNALSYM GlobalFix}

--%% procedure GlobalUnfix(hMem: HGLOBAL); stdcall;
--%% {$EXTERNALSYM GlobalUnfix}

--%% function GlobalWire(hMem: HGLOBAL): LPVOID; stdcall;
--%% {$EXTERNALSYM GlobalWire}

--%% function GlobalUnWire(hMem: HGLOBAL): BOOL; stdcall;
--%% {$EXTERNALSYM GlobalUnWire}

--%% procedure GlobalMemoryStatus(var lpBuffer: MEMORYSTATUS); stdcall;
--%% {$EXTERNALSYM GlobalMemoryStatus}

   type Memory_Status_Ex_Type;
   type Memory_Status_Ex_Ptr is access all Memory_Status_Ex_Type;
   type Memory_Status_Ex_CPtr is access constant Memory_Status_Ex_Type;
   type Memory_Status_Ex_Type is record
      Length : Unsigned_32;
      Memory_Load : Unsigned_32;
      Total_Phys : DWORDLONG;
      Avail_Phys : DWORDLONG;
      Total_Page_File : DWORDLONG;
      Avail_Page_File : DWORDLONG;
      Total_Virtual : DWORDLONG;
      Avail_Virtual : DWORDLONG;
      Avail_Extended_Virtual : DWORDLONG;
   end record;

--%% function GlobalMemoryStatusEx(var lpBuffer: MEMORYSTATUSEX): BOOL; stdcall;
--%% {$EXTERNALSYM GlobalMemoryStatusEx}

--%% function LocalAlloc(uFlags: UINT; uBytes: SIZE_T): HLOCAL; stdcall;
--%% {$EXTERNALSYM LocalAlloc}

--%% function LocalReAlloc(hMem: HLOCAL; uBytes: SIZE_T; uFlags: UINT): HLOCAL; stdcall;
--%% {$EXTERNALSYM LocalReAlloc}

--%% function LocalLock(hMem: HLOCAL): LPVOID; stdcall;
--%% {$EXTERNALSYM LocalLock}

--%% function LocalHandle(pMem: LPCVOID): HLOCAL; stdcall;
--%% {$EXTERNALSYM LocalHandle}

--%% function LocalUnlock(hMem: HLOCAL): BOOL; stdcall;
--%% {$EXTERNALSYM LocalUnlock}

--%% function LocalSize(hMem: HLOCAL): SIZE_T; stdcall;
--%% {$EXTERNALSYM LocalSize}

--%% function LocalFlags(hMem: HLOCAL): UINT; stdcall;
--%% {$EXTERNALSYM LocalFlags}

--%% function LocalFree(hMem: HLOCAL): HLOCAL; stdcall;
--%% {$EXTERNALSYM LocalFree}

--%% function LocalShrink(hMem: HLOCAL; cbNewSize: UINT): SIZE_T; stdcall;
--%% {$EXTERNALSYM LocalShrink}

--%% function LocalCompact(uMinFree: UINT): SIZE_T; stdcall;
--%% {$EXTERNALSYM LocalCompact}

--%% function FlushInstructionCache(hProcess: HANDLE; lpBaseAddress: LPCVOID;
--%%   dwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FlushInstructionCache}

--%% function VirtualAlloc(lpAddress: LPVOID; dwSize: SIZE_T; flAllocationType: DWORD;
--%%   flProtect: DWORD): LPVOID; stdcall;
--%% {$EXTERNALSYM VirtualAlloc}

--%% function VirtualFree(lpAddress: LPVOID; dwSize: SIZE_T; dwFreeType: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM VirtualFree}

--%% function VirtualProtect(lpAddress: LPVOID; dwSize: SIZE_T; flNewProtect: DWORD;
--%%   lpflOldProtect: PDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM VirtualProtect}

--%% function VirtualQuery(lpAddress: LPCVOID; var lpBuffer: MEMORY_BASIC_INFORMATION;
--%%   dwLength: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM VirtualQuery}

--%% function VirtualAllocEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
--%%   flAllocationType: DWORD; flProtect: DWORD): LPVOID; stdcall;
--%% {$EXTERNALSYM VirtualAllocEx}

--%% function GetWriteWatch(dwFlags: DWORD; lpBaseAddress: PVOID;
--%%   dwRegionSize: SIZE_T; var lpAddresses: PVOID; var lpdwCount: ULONG_PTR;
--%%   var lpdwGranularity: ULONG): UINT; stdcall;
--%% {$EXTERNALSYM GetWriteWatch}

--%% function ResetWriteWatch(lpBaseAddress: LPVOID; dwRegionSize: SIZE_T): UINT; stdcall;
--%% {$EXTERNALSYM ResetWriteWatch}

--%% function GetLargePageMinimum: SIZE_T; stdcall;
--%% {$EXTERNALSYM GetLargePageMinimum}

--%% function VirtualFreeEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
--%%   dwFreeType: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM VirtualFreeEx}

--%% function VirtualProtectEx(hProcess: HANDLE; lpAddress: LPVOID; dwSize: SIZE_T;
--%%   flNewProtect: DWORD; lpflOldProtect: PDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM VirtualProtectEx}

--%% function VirtualQueryEx(hProcess: HANDLE; lpAddress: LPCVOID;
--%%   var lpBuffer: MEMORY_BASIC_INFORMATION; dwLength: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM VirtualQueryEx}

--%% function HeapCreate(flOptions: DWORD; dwInitialSize: SIZE_T;
--%%   dwMaximumSize: SIZE_T): HANDLE; stdcall;
--%% {$EXTERNALSYM HeapCreate}

--%% function HeapDestroy(hHeap: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM HeapDestroy}

--%% function HeapAlloc(hHeap: HANDLE; dwFlags: DWORD; dwBytes: SIZE_T): LPVOID; stdcall;
--%% {$EXTERNALSYM HeapAlloc}

--%% function HeapReAlloc(hHeap: HANDLE; dwFlags: DWORD; lpMem: LPVOID; dwBytes: SIZE_T): LPVOID; stdcall;
--%% {$EXTERNALSYM HeapReAlloc}

--%% function HeapFree(hHeap: HANDLE; dwFlags: DWORD; lpMem: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM HeapFree}

--%% function HeapSize(hHeap: HANDLE; dwFlags: DWORD; lpMem: LPCVOID): SIZE_T; stdcall;
--%% {$EXTERNALSYM HeapSize}

--%% function HeapValidate(hHeap: HANDLE; dwFlags: DWORD; lpMem: LPCVOID): BOOL; stdcall;
--%% {$EXTERNALSYM HeapValidate}

--%% function HeapCompact(hHeap: HANDLE; dwFlags: DWORD): SIZE_T; stdcall;
--%% {$EXTERNALSYM HeapCompact}

--%% function GetProcessHeap: HANDLE; stdcall;
--%% {$EXTERNALSYM GetProcessHeap)}

--%% function GetProcessHeaps(NumberOfHeaps: DWORD; var ProcessHeaps: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetProcessHeaps}

--%%   PPROCESS_HEAP_ENTRY = ^PROCESS_HEAP_ENTRY;
--%%   {$EXTERNALSYM PPROCESS_HEAP_ENTRY}
--%%   _PROCESS_HEAP_ENTRY = record
--%%     lpData: PVOID;
--%%     cbData: DWORD;
--%%     cbOverhead: BYTE;
--%%     iRegionIndex: BYTE;
--%%     wFlags: WORD;
--%%     case Integer of
--%%       0: (
--%%         hMem: HANDLE;
--%%         dwReserved: array [0..2] of DWORD);
--%%       1: (
--%%         dwComittedSize: DWORD;
--%%         dwUnComittedSize: DWORD;
--%%         lpFirstBlock: LPVOID;
--%%         lpLastBlock: LPVOID);
--%%   end;
--%%   {$EXTERNALSYM _PROCESS_HEAP_ENTRY}
--%%   PROCESS_HEAP_ENTRY = _PROCESS_HEAP_ENTRY;
--%%   {$EXTERNALSYM PROCESS_HEAP_ENTRY}
--%%   LPPROCESS_HEAP_ENTRY = ^PROCESS_HEAP_ENTRY;
--%%   {$EXTERNALSYM LPPROCESS_HEAP_ENTRY}
--%%   TProcessHeapEntry = PROCESS_HEAP_ENTRY;
--%%   PProcessHeapEntry = PPROCESS_HEAP_ENTRY;

   Process_Heap_Region            : constant := 16#0001#;
   Process_Heap_Uncommitted_Range : constant := 16#0002#;
   Process_Heap_Entry_Busy        : constant := 16#0004#;
   Process_Heap_Entry_Moveable    : constant := 16#0010#;
   Process_Heap_Entry_Ddeshare    : constant := 16#0020#;

--%% function HeapLock(hHeap: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM HeapLock}

--%% function HeapUnlock(hHeap: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM HeapUnlock}

--%% function HeapWalk(hHeap: HANDLE; var lpEntry: PROCESS_HEAP_ENTRY): BOOL; stdcall;
--%% {$EXTERNALSYM HeapWalk}

--%% function HeapSetInformation(HeapHandle: HANDLE; HeapInformationClass: HEAP_INFORMATION_CLASS;
--%%   HeapInformation: PVOID; HeapInformationLength: SIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM HeapSetInformation}

--%% function HeapQueryInformation(HeapHandle: HANDLE; HeapInformationClass: HEAP_INFORMATION_CLASS;
--%%   HeapInformation: PVOID; HeapInformationLength: SIZE_T; ReturnLength: PSIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM HeapQueryInformation}

-- GetBinaryType return values.

   Scs_32Bit_Binary : constant := 0;
   Scs_Dos_Binary   : constant := 1;
   Scs_Wow_Binary   : constant := 2;
   Scs_Pif_Binary   : constant := 3;
   Scs_Posix_Binary : constant := 4;
   Scs_Os216_Binary : constant := 5;
   Scs_64Bit_Binary : constant := 6;

   Scs_This_Platform_Binary : constant := Scs_32Bit_Binary;

--%% function GetBinaryTypeA(lpApplicationName: LPCSTR; var lpBinaryType: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetBinaryTypeA}
--%% function GetBinaryTypeW(lpApplicationName: LPCWSTR; var lpBinaryType: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetBinaryTypeW}
--%% function GetBinaryType(lpApplicationName: LPCTSTR; var lpBinaryType: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetBinaryType}

--%% function GetShortPathNameA(lpszLongPath: LPCSTR; lpszShortPath: LPSTR;
--%%   cchBuffer: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetShortPathNameA}
--%% function GetShortPathNameW(lpszLongPath: LPCWSTR; lpszShortPath: LPWSTR;
--%%   cchBuffer: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetShortPathNameW}
--%% function GetShortPathName(lpszLongPath: LPCTSTR; lpszShortPath: LPTSTR;
--%%   cchBuffer: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetShortPathName}

--%% function GetLongPathNameA(lpszShortPath: LPCSTR; lpszLongPath: LPSTR;
--%%   cchBuffer: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetLongPathNameA}
--%% function GetLongPathNameW(lpszShortPath: LPCWSTR; lpszLongPath: LPWSTR;
--%%   cchBuffer: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetLongPathNameW}
--%% function GetLongPathName(lpszShortPath: LPCTSTR; lpszLongPath: LPTSTR;
--%%   cchBuffer: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetLongPathName}

--%% function GetProcessAffinityMask(hProcess: HANDLE;
--%%   var lpProcessAffinityMask, lpSystemAffinityMask: DWORD_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessAffinityMask}

--%% function SetProcessAffinityMask(hProcess: HANDLE;
--%%   dwProcessAffinityMask: DWORD_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetProcessAffinityMask}

--%% function GetProcessHandleCount(hProcess: HANDLE; out pdwHandleCount: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessHandleCount}

--%% function GetProcessTimes(hProcess: HANDLE; var lpCreationTime, lpExitTime,
--%%   lpKernelTime, lpUserTime: FILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessTimes}

--%% function GetProcessIoCounters(hProcess: HANDLE; var lpIoCounters: IO_COUNTERS): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessIoCounters}

--%% function GetProcessWorkingSetSize(hProcess: HANDLE;
--%%   var lpMinimumWorkingSetSize, lpMaximumWorkingSetSize: SIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessWorkingSetSize}

--%% function GetProcessWorkingSetSizeEx(hProcess: HANDLE; out lpMinimumWorkingSetSize,  lpMaximumWorkingSetSize: SIZE_T; out Flags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessWorkingSetSizeEx}

--%% function SetProcessWorkingSetSize(hProcess: HANDLE; dwMinimumWorkingSetSize,
--%%   dwMaximumWorkingSetSize: SIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM SetProcessWorkingSetSize}

--%% function SetProcessWorkingSetSizeEx(hProcess: HANDLE; dwMinimumWorkingSetSize, dwMaximumWorkingSetSize: SIZE_T; Flags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetProcessWorkingSetSizeEx}

--%% function OpenProcess(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   dwProcessId: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenProcess}

--%% function GetCurrentProcess: HANDLE; stdcall;
--%% {$EXTERNALSYM GetCurrentProcess}

--%% function GetCurrentProcessId: DWORD; stdcall;
--%% {$EXTERNALSYM GetCurrentProcessId}

--%% procedure ExitProcess(uExitCode: UINT); stdcall;
--%% {$EXTERNALSYM ExitProcess}

--%% function TerminateProcess(hProcess: HANDLE; uExitCode: UINT): BOOL; stdcall;
--%% {$EXTERNALSYM TerminateProcess}

--%% function GetExitCodeProcess(hProcess: HANDLE; var lpExitCode: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetExitCodeProcess}

--%% procedure FatalExit(ExitCode: Integer); stdcall;
--%% {$EXTERNALSYM FatalExit}

--%% function GetEnvironmentStringsW: LPWSTR; stdcall;
--%% {$EXTERNALSYM GetEnvironmentStringsW}

--%% function GetEnvironmentStrings: LPSTR; stdcall;
--%% {$EXTERNALSYM GetEnvironmentStrings}

--%% {$IFNDEF UNICODE}
--%% function GetEnvironmentStringsA: LPSTR; stdcall;
--%% {$EXTERNALSYM GetEnvironmentStringsA}
--%% {$ENDIF !UNICODE}


--%% {$IFDEF WIN2003_UP}
-- This function is only available in Windows 2003, Vista and 2008
-- http://sourceforge.net/support/tracker.php?aid=1846987
--%% function SetEnvironmentStringsA(NewEnvironment: LPSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetEnvironmentStringsA}

--%% function SetEnvironmentStringsW(NewEnvironment: LPWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetEnvironmentStringsW}
--%% function SetEnvironmentStrings(NewEnvironment: LPTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetEnvironmentStrings}
--%% {$ENDIF WIN2003_UP}

--%% function FreeEnvironmentStringsA(pstr: LPSTR): BOOL; stdcall;
--%% {$EXTERNALSYM FreeEnvironmentStringsA}
--%% function FreeEnvironmentStringsW(pstr: LPWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM FreeEnvironmentStringsW}
--%% function FreeEnvironmentStrings(pstr: LPTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM FreeEnvironmentStrings}

--%% procedure RaiseException(dwExceptionCode: DWORD; dwExceptionFlags: DWORD;
--%%   nNumberOfArguments: DWORD; lpArguments: PULONG_PTR); stdcall;
--%% {$EXTERNALSYM RaiseException}

--%% function UnhandledExceptionFilter(ExceptionInfo: PEXCEPTION_POINTERS): LONG; stdcall;
--%% {$EXTERNALSYM UnhandledExceptionFilter}

--%%   PTOP_LEVEL_EXCEPTION_FILTER = function(ExceptionInfo: PEXCEPTION_POINTERS): LONG; stdcall;
--%%   {$EXTERNALSYM PTOP_LEVEL_EXCEPTION_FILTER}
--%%   LPTOP_LEVEL_EXCEPTION_FILTER = PTOP_LEVEL_EXCEPTION_FILTER;
--%%   {$EXTERNALSYM LPTOP_LEVEL_EXCEPTION_FILTER}
--%%   TTopLevelExceptionFilter = PTOP_LEVEL_EXCEPTION_FILTER;

--%% function SetUnhandledExceptionFilter(lpTopLevelExceptionFilter: LPTOP_LEVEL_EXCEPTION_FILTER): LPTOP_LEVEL_EXCEPTION_FILTER; stdcall;
--%% {$EXTERNALSYM SetUnhandledExceptionFilter}

--
-- Fiber creation flags
--

   Fiber_Flag_Float_Switch : constant := 16#1#;     -- context switch floating point

--%% function CreateFiber(dwStackSize: DWORD; lpStartAddress: LPFIBER_START_ROUTINE;
--%%   lpParameter: LPVOID): LPVOID; stdcall;
--%% {$EXTERNALSYM CreateFiber}

--%% function CreateFiberEx(dwStackCommitSize, dwStackReserveSize: SIZE_T; dwFlags: DWORD;
--%%   lpStartAddress: LPFIBER_START_ROUTINE; lpParameter: LPVOID): LPVOID; stdcall;
--%% {$EXTERNALSYM CreateFiberEx}

--%% procedure DeleteFiber(lpFiber: LPVOID); stdcall;
--%% {$EXTERNALSYM DeleteFiber}

--%% function ConvertThreadToFiber(lpParameter: LPVOID): LPVOID; stdcall;
--%% {$EXTERNALSYM ConvertThreadToFiber}

--%% function ConvertThreadToFiberEx(lpParameter: LPVOID; dwFlags: DWORD): LPVOID; stdcall;
--%% {$EXTERNALSYM ConvertThreadToFiberEx}

--%% function ConvertFiberToThread: BOOL; stdcall;
--%% {$EXTERNALSYM ConvertFiberToThread}

--%% procedure SwitchToFiber(lpFiber: LPVOID); stdcall;
--%% {$EXTERNALSYM SwitchToFiber}

--%% function SwitchToThread: BOOL; stdcall;
--%% {$EXTERNALSYM SwitchToThread}

--%% function CreateThread(lpThreadAttributes: LPSECURITY_ATTRIBUTES;
--%%   dwStackSize: DWORD; lpStartAddress: LPTHREAD_START_ROUTINE; lpParameter: LPVOID;
--%%   dwCreationFlags: DWORD; lpThreadId: LPDWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateThread}

--%% function CreateRemoteThread(hProcess: HANDLE;
--%%   lpThreadAttributes: LPSECURITY_ATTRIBUTES; dwStackSize: DWORD;
--%%   lpStartAddress: LPTHREAD_START_ROUTINE; lpParameter: LPVOID;
--%%   dwCreationFlags: DWORD; lpThreadId: LPDWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateRemoteThread}

--%% function GetCurrentThread: HANDLE; stdcall;
--%% {$EXTERNALSYM GetCurrentThread}

--%% function GetCurrentThreadId: DWORD; stdcall;
--%% {$EXTERNALSYM GetCurrentThreadId}

--%% function GetProcessIdOfThread(Thread: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetProcessIdOfThread}

--%% function GetThreadId(Thread: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetThreadId}

--%% function GetProcessId(Process: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetProcessId}

--%% function GetCurrentProcessorNumber: DWORD; stdcall;
--%% {$EXTERNALSYM GetCurrentProcessorNumber}

--%% function SetThreadAffinityMask(hThread: HANDLE;
--%%   dwThreadAffinityMask: DWORD_PTR): DWORD_PTR; stdcall;
--%% {$EXTERNALSYM SetThreadAffinityMask}

--%% function SetThreadIdealProcessor(hThread: HANDLE; dwIdealProcessor: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM SetThreadIdealProcessor}

--%% function SetProcessPriorityBoost(hProcess: HANDLE;
--%%   bDisablePriorityBoost: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetProcessPriorityBoost}

--%% function GetProcessPriorityBoost(hProcess: HANDLE;
--%%   var pDisablePriorityBoost: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessPriorityBoost}

--%% function RequestWakeupLatency(latency: LATENCY_TIME): BOOL; stdcall;
--%% {$EXTERNALSYM RequestWakeupLatency}

--%% function IsSystemResumeAutomatic: BOOL; stdcall;
--%% {$EXTERNALSYM IsSystemResumeAutomatic}

--%% function OpenThread(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   dwThreadId: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenThread}

--%% function SetThreadPriority(hThread: HANDLE; nPriority: Integer): BOOL; stdcall;
--%% {$EXTERNALSYM SetThreadPriority}

--%% function SetThreadPriorityBoost(hThread: HANDLE; bDisablePriorityBoost: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetThreadPriorityBoost}

--%% function GetThreadPriorityBoost(hThread: HANDLE;
--%%   var pDisablePriorityBoost: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetThreadPriorityBoost}

--%% function GetThreadPriority(hThread: HANDLE): Integer; stdcall;
--%% {$EXTERNALSYM GetThreadPriority}

--%% function GetThreadTimes(hThread: HANDLE; var lpCreationTime, lpExitTime,
--%%   lpKernelTime, lpUserTime: FILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM GetThreadTimes}

--%% function GetThreadIOPendingFlag(hThread: HANDLE; out lpIOIsPending: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetThreadIOPendingFlag}

--%% procedure ExitThread(dwExitCode: DWORD); stdcall;
--%% {$EXTERNALSYM ExitThread}

--%% function TerminateThread(hThread: HANDLE; dwExitCode: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM TerminateThread}

--%% function GetExitCodeThread(hThread: HANDLE; var lpExitCode: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetExitCodeThread}

--%% function GetThreadSelectorEntry(hThread: HANDLE; dwSelector: DWORD;
--%%   var lpSelectorEntry: LDT_ENTRY): BOOL; stdcall;
--%% {$EXTERNALSYM GetThreadSelectorEntry}

--%% function SetThreadExecutionState(esFlags: EXECUTION_STATE): EXECUTION_STATE; stdcall;
--%% {$EXTERNALSYM SetThreadExecutionState}

--%% function GetLastError: DWORD; stdcall;
--%% {$EXTERNALSYM GetLastError}

--%% procedure SetLastError(dwErrCode: DWORD); stdcall;
--%% {$EXTERNALSYM SetLastError}

--%% procedure RestoreLastError(dwErrCode: DWORD); stdcall;
--%% {$EXTERNALSYM RestoreLastError}

--%%    PRESTORE_LAST_ERROR = procedure(dwErrCode: DWORD); stdcall;
--%%    {$EXTERNALSYM PRESTORE_LAST_ERROR}

--%%   RESTORE_LAST_ERROR_NAME_A = 'RestoreLastError';
--%%   {$EXTERNALSYM RESTORE_LAST_ERROR_NAME_A}
--%%   RESTORE_LAST_ERROR_NAME_W = WideString('RestoreLastError');
--%%   {$EXTERNALSYM RESTORE_LAST_ERROR_NAME_W}
--%%   RESTORE_LAST_ERROR_NAME   = __TEXT('RestoreLastError');
--%%   {$EXTERNALSYM RESTORE_LAST_ERROR_NAME}

--%% function HasOverlappedIoCompleted(const lpOverlapped: OVERLAPPED): BOOL;
--%% {$EXTERNALSYM HasOverlappedIoCompleted}

--%% function GetOverlappedResult(hFile: HANDLE; const lpOverlapped: OVERLAPPED;
--%%   var lpNumberOfBytesTransferred: DWORD; bWait: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetOverlappedResult}

--%% function CreateIoCompletionPort(FileHandle: HANDLE; ExistingCompletionPort: HANDLE;
--%%   CompletionKey: ULONG_PTR; NumberOfConcurrentThreads: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateIoCompletionPort}

--%% function GetQueuedCompletionStatus(CompletionPort: HANDLE;
--%%   var lpNumberOfBytesTransferred: DWORD; var lpCompletionKey: ULONG_PTR;
--%%   var lpOverlapped: LPOVERLAPPED; dwMilliseconds: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetQueuedCompletionStatus}

--%% function PostQueuedCompletionStatus(CompletionPort: HANDLE;
--%%   dwNumberOfBytesTransferred: DWORD; dwCompletionKey: ULONG_PTR;
--%%   lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM PostQueuedCompletionStatus}

   Sem_Failcriticalerrors     : constant := 16#0001#;
   Sem_Nogpfaulterrorbox      : constant := 16#0002#;
   Sem_Noalignmentfaultexcept : constant := 16#0004#;
   Sem_Noopenfileerrorbox     : constant := 16#8000#;

--%% function SetErrorMode(uMode: UINT): UINT; stdcall;
--%% {$EXTERNALSYM SetErrorMode}

--%% function ReadProcessMemory(hProcess: HANDLE; lpBaseAddress: LPCVOID;
--%%   lpBuffer: LPVOID; nSize: DWORD; lpNumberOfBytesRead: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM ReadProcessMemory}

--%% function WriteProcessMemory(hProcess: HANDLE; lpBaseAddress: LPVOID;
--%%   lpBuffer: LPVOID; nSize: DWORD; lpNumberOfBytesWritten: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProcessMemory}

--%% function GetThreadContext(hThread: HANDLE; var lpContext: CONTEXT): BOOL; stdcall;
--%% {$EXTERNALSYM GetThreadContext}

--%% function SetThreadContext(hThread: HANDLE; const lpContext: CONTEXT): BOOL; stdcall;
--%% {$EXTERNALSYM SetThreadContext}

--%% function SuspendThread(hThread: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM SuspendThread}

--%% function ResumeThread(hThread: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM ResumeThread}

--%%   PAPCFUNC = procedure(dwParam: ULONG_PTR); stdcall;
--%%   {$EXTERNALSYM PAPCFUNC}
--%%   TApcFunc = PAPCFUNC;

--%% function QueueUserAPC(pfnAPC: PAPCFUNC; hThread: HANDLE; dwData: ULONG_PTR): DWORD; stdcall;
--%% {$EXTERNALSYM QueueUserAPC}

--%% function IsDebuggerPresent: BOOL; stdcall;
--%% {$EXTERNALSYM IsDebuggerPresent}

--%% function CheckRemoteDebuggerPresent(hProcess: HANDLE; out pbDebuggerPresent: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM CheckRemoteDebuggerPresent}

--%% procedure DebugBreak; stdcall;
--%% {$EXTERNALSYM DebugBreak}

--%% function WaitForDebugEvent(var lpDebugEvent: DEBUG_EVENT; dwMilliseconds: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM WaitForDebugEvent}

--%% function ContinueDebugEvent(dwProcessId: DWORD; dwThreadId: DWORD;
--%%   dwContinueStatus: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM ContinueDebugEvent}

--%% function DebugActiveProcess(dwProcessId: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DebugActiveProcess}

--%% function DebugActiveProcessStop(dwProcessId: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DebugActiveProcessStop}

--%% function DebugSetProcessKillOnExit(KillOnExit: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM DebugSetProcessKillOnExit}

--%% function DebugBreakProcess(Process: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DebugBreakProcess}

--%% procedure InitializeCriticalSection(var lpCriticalSection: CRITICAL_SECTION); stdcall;
--%% {$EXTERNALSYM InitializeCriticalSection}

--%% procedure EnterCriticalSection(var lpCriticalSection: CRITICAL_SECTION); stdcall;
--%% {$EXTERNALSYM EnterCriticalSection}

--%% procedure LeaveCriticalSection(var lpCriticalSection: CRITICAL_SECTION); stdcall;
--%% {$EXTERNALSYM LeaveCriticalSection}

--%% function InitializeCriticalSectionAndSpinCount(var lpCriticalSection: CRITICAL_SECTION;
--%%   dwSpinCount: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM InitializeCriticalSectionAndSpinCount}

--%% function SetCriticalSectionSpinCount(var lpCriticalSection: CRITICAL_SECTION;
--%%   dwSpinCount: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM SetCriticalSectionSpinCount}

--%% function TryEnterCriticalSection(var lpCriticalSection: CRITICAL_SECTION): BOOL; stdcall;
--%% {$EXTERNALSYM TryEnterCriticalSection}

--%% procedure DeleteCriticalSection(var lpCriticalSection: CRITICAL_SECTION); stdcall;
--%% {$EXTERNALSYM DeleteCriticalSection}

--%% function SetEvent(hEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetEvent}

--%% function ResetEvent(hEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ResetEvent}

--%% function PulseEvent(hEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM PulseEvent}

--%% function ReleaseSemaphore(hSemaphore: HANDLE; lReleaseCount: LONG;
--%%   lpPreviousCount: LPLONG): BOOL; stdcall;
--%% {$EXTERNALSYM ReleaseSemaphore}

--%% function ReleaseMutex(hMutex: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ReleaseMutex}

--%% function WaitForSingleObject(hHandle: HANDLE; dwMilliseconds: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM WaitForSingleObject}

--%% function WaitForMultipleObjects(nCount: DWORD; lpHandles: PHANDLE; bWaitAll: BOOL;
--%%   dwMilliseconds: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM WaitForMultipleObjects}

--%% procedure Sleep(dwMilliseconds: DWORD); stdcall;
--%% {$EXTERNALSYM Sleep}

--%% function LoadResource(hModule: HMODULE; hResInfo: HRSRC): HGLOBAL; stdcall;
--%% {$EXTERNALSYM LoadResource}

--%% function SizeofResource(hModule: HMODULE; hResInfo: HRSRC): DWORD; stdcall;
--%% {$EXTERNALSYM SizeofResource}

--%% function GlobalDeleteAtom(nAtom: ATOM): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalDeleteAtom}

--%% function InitAtomTable(nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM InitAtomTable}

--%% function DeleteAtom(nAtom: ATOM): ATOM; stdcall;
--%% {$EXTERNALSYM DeleteAtom}

--%% function SetHandleCount(uNumber: UINT): UINT; stdcall;
--%% {$EXTERNALSYM SetHandleCount}

--%% function GetLogicalDrives: DWORD; stdcall;
--%% {$EXTERNALSYM GetLogicalDrives}

--%% function LockFile(hFile: HANDLE; dwFileOffsetLow: DWORD; dwFileOffsetHigh: DWORD;
--%%   nNumberOfBytesToLockLow: DWORD; nNumberOfBytesToLockHigh: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LockFile}

--%% function UnlockFile(hFile: HANDLE; dwFileOffsetLow: DWORD; dwFileOffsetHigh: DWORD;
--%%   nNumberOfBytesToUnlockLow: DWORD; nNumberOfBytesToUnlockHigh: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM UnlockFile}

--%% function LockFileEx(hFile: HANDLE; dwFlags: DWORD; dwReserved: DWORD;
--%%   nNumberOfBytesToLockLow: DWORD; nNumberOfBytesToLockHigh: DWORD;
--%%   const lpOverlapped: OVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM LockFileEx}

   Lockfile_Fail_Immediately : constant := 16#0000_0001#;
   Lockfile_Exclusive_Lock   : constant := 16#0000_0002#;

--%% function UnlockFileEx(hFile: HANDLE; dwReserved: DWORD;
--%%   nNumberOfBytesToUnlockLow: DWORD; nNumberOfBytesToUnlockHigh: DWORD;
--%%   const lpOverlapped: OVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM UnlockFileEx}

   type By_Handle_File_Information_Type;
   type By_Handle_File_Information_Ptr is access all By_Handle_File_Information_Type;
   type By_Handle_File_Information_CPtr is access constant By_Handle_File_Information_Type;
   type By_Handle_File_Information_Type is record
      File_Attributes : Unsigned_32;
      Creation_Time : File_Time_Type;
      Last_Access_Time : File_Time_Type;
      Last_Write_Time : File_Time_Type;
      Volume_Serial_Number : Unsigned_32;
      File_Size_High : Unsigned_32;
      File_Size_Low : Unsigned_32;
      Number_Of_Links : Unsigned_32;
      File_Index_High : Unsigned_32;
      File_Index_Low : Unsigned_32;
   end record;

--%% function GetFileInformationByHandle(hFile: HANDLE;
--%%   var lpFileInformation: BY_HANDLE_FILE_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileInformationByHandle}

--%% function GetFileType(hFile: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetFileType}

--%% function GetFileSize(hFile: HANDLE; lpFileSizeHigh: LPDWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetFileSize}

--%% function GetFileSizeEx(hFile: HANDLE; var lpFileSize: LARGE_INTEGER): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileSizeEx}

--%% function GetStdHandle(nStdHandle: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM GetStdHandle}

--%% function SetStdHandle(nStdHandle: DWORD; hHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetStdHandle}

--%% function WriteFile(hFile: HANDLE; lpBuffer: LPCVOID; nNumberOfBytesToWrite: DWORD;
--%%   lpNumberOfBytesWritten: LPDWORD; lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM WriteFile}

--%% function ReadFile(hFile: HANDLE; lpBuffer: LPVOID; nNumberOfBytesToRead: DWORD;
--%%   lpNumberOfBytesRead: LPDWORD; lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM ReadFile}

--%% function FlushFileBuffers(hFile: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM FlushFileBuffers}

--%% function DeviceIoControl(hDevice: HANDLE; dwIoControlCode: DWORD;
--%%   lpInBuffer: LPVOID; nInBufferSize: DWORD; lpOutBuffer: LPVOID;
--%%   nOutBufferSize: DWORD; lpBytesReturned: LPDWORD;
--%%   lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM DeviceIoControl}

--%% function RequestDeviceWakeup(hDevice: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM RequestDeviceWakeup}

--%% function CancelDeviceWakeupRequest(hDevice: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CancelDeviceWakeupRequest}

--%% function GetDevicePowerState(hDevice: HANDLE; var pfOn: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetDevicePowerState}

--%% function SetMessageWaitingIndicator(hMsgIndicator: HANDLE; ulMsgCount: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM SetMessageWaitingIndicator}

--%% function SetEndOfFile(hFile: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetEndOfFile}

--%% function SetFilePointer(hFile: HANDLE; lDistanceToMove: LONG;
--%%   lpDistanceToMoveHigh: PLONG; dwMoveMethod: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM SetFilePointer}

--%% function SetFilePointerEx(hFile: HANDLE; liDistanceToMove: LARGE_INTEGER;
--%%   lpNewFilePointer: PLARGE_INTEGER; dwMoveMethod: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFilePointerEx}

--%% function FindClose(hFindFile: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM FindClose}

--%% function GetFileTime(hFile: HANDLE; lpCreationTime, lpLastAccessTime,
--%%   lpLastWriteTime: PFILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileTime}

--%% function SetFileTime(hFile: HANDLE; lpCreationTime, lpLastAccessTime,
--%%   lpLastWriteTime: PFILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileTime}

--%% function SetFileValidData(hFile: HANDLE; ValidDataLength: LONGLONG): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileValidData}

--%% function SetFileShortNameA(hFile: HANDLE; lpShortName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileShortNameA}
--%% function SetFileShortNameW(hFile: HANDLE; lpShortName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileShortNameW}
--%% function SetFileShortName(hFile: HANDLE; lpShortName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileShortName}

--%% function CloseHandle(hObject: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CloseHandle}

--%% function DuplicateHandle(hSourceProcessHandle: HANDLE; hSourceHandle: HANDLE;
--%%   hTargetProcessHandle: HANDLE; lpTargetHandle: LPHANDLE;
--%%   dwDesiredAccess: DWORD; bInheritHandle: BOOL; dwOptions: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DuplicateHandle}

--%% function GetHandleInformation(hObject: HANDLE; var lpdwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetHandleInformation}

--%% function SetHandleInformation(hObject: HANDLE; dwMask: DWORD; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetHandleInformation}

   Handle_Flag_Inherit            : constant := 16#0000_0001#;
   Handle_Flag_Protect_From_Close : constant := 16#0000_0002#;

   Hinstance_Error                : constant := 32;

--%% function LoadModule(lpModuleName: LPCSTR; lpParameterBlock: LPVOID): DWORD; stdcall;
--%% {$EXTERNALSYM LoadModule}

--%% function WinExec(lpCmdLine: LPCSTR; uCmdShow: UINT): UINT; stdcall;
--%% {$EXTERNALSYM WinExec}

--%% function ClearCommBreak(hFile: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ClearCommBreak}

--%% function ClearCommError(hFile: HANDLE; var lpErrors: DWORD;
--%%   lpStat: LPCOMSTAT): BOOL; stdcall;
--%% {$EXTERNALSYM ClearCommError}

--%% function SetupComm(hFile: HANDLE; dwInQueue: DWORD; dwOutQueue: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetupComm}

--%% function EscapeCommFunction(hFile: HANDLE; dwFunc: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM EscapeCommFunction}

--%% function GetCommConfig(hCommDev: HANDLE; var lpCC: COMMCONFIG;
--%%   var lpdwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetCommConfig}

--%% function GetCommMask(hFile: HANDLE; var lpEvtMask: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetCommMask}

--%% function GetCommProperties(hFile: HANDLE; var lpCommProp: COMMPROP): BOOL; stdcall;
--%% {$EXTERNALSYM GetCommProperties}

--%% function GetCommModemStatus(hFile: HANDLE; var lpModemStat: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetCommModemStatus}

--%% function GetCommState(hFile: HANDLE; var lpDCB: DCB): BOOL; stdcall;
--%% {$EXTERNALSYM GetCommState}

--%% function GetCommTimeouts(hFile: HANDLE; var lpCommTimeouts: COMMTIMEOUTS): BOOL; stdcall;
--%% {$EXTERNALSYM GetCommTimeouts}

--%% function PurgeComm(hFile: HANDLE; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM PurgeComm}

--%% function SetCommBreak(hFile: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetCommBreak}

--%% function SetCommConfig(hCommDev: HANDLE; const lpCC: COMMCONFIG; dwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetCommConfig}

--%% function SetCommMask(hFile: HANDLE; dwEvtMask: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetCommMask}

--%% function SetCommState(hFile: HANDLE; const lpDCB: DCB): BOOL; stdcall;
--%% {$EXTERNALSYM SetCommState}

--%% function SetCommTimeouts(hFile: HANDLE; const lpCommTimeouts: COMMTIMEOUTS): BOOL; stdcall;
--%% {$EXTERNALSYM SetCommTimeouts}

--%% function TransmitCommChar(hFile: HANDLE; cChar: Char): BOOL; stdcall;
--%% {$EXTERNALSYM TransmitCommChar}

--%% function WaitCommEvent(hFile: HANDLE; var lpEvtMask: DWORD;
--%%   lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM WaitCommEvent}

--%% function SetTapePosition(hDevice: HANDLE; dwPositionMethod, dwPartition,
--%%   dwOffsetLow, dwOffsetHigh: DWORD; bImmediate: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM SetTapePosition}

--%% function GetTapePosition(hDevice: HANDLE; dwPositionType: DWORD;
--%%   var lpdwPartition, lpdwOffsetLow: LPDWORD; lpdwOffsetHigh: LPDWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetTapePosition}

--%% function PrepareTape(hDevice: HANDLE; dwOperation: DWORD; bImmediate: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM PrepareTape}

--%% function EraseTape(hDevice: HANDLE; dwEraseType: DWORD; bImmediate: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM EraseTape}

--%% function CreateTapePartition(hDevice: HANDLE; dwPartitionMethod: DWORD;
--%%   dwCount: DWORD; dwSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM CreateTapePartition}

--%% function WriteTapemark(hDevice: HANDLE; dwTapemarkType: DWORD;
--%%   dwTapemarkCount: DWORD; bImmediate: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM WriteTapemark}

--%% function GetTapeStatus(hDevice: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetTapeStatus}

--%% function GetTapeParameters(hDevice: HANDLE; dwOperation: DWORD;
--%%   var lpdwSize: DWORD; lpTapeInformation: LPVOID): DWORD; stdcall;
--%% {$EXTERNALSYM GetTapeParameters}

   Get_Tape_Media_Information : constant := 0;
   Get_Tape_Drive_Information : constant := 1;

--%% function SetTapeParameters(hDevice: HANDLE; dwOperation: DWORD; lpTapeInformation: LPVOID): DWORD; stdcall;
--%% {$EXTERNALSYM SetTapeParameters}

   Set_Tape_Media_Information : constant := 0;
   Set_Tape_Drive_Information : constant := 1;

--%% function Beep(dwFreq: DWORD; dwDuration: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM Beep}

--%% function MulDiv(nNumber, nNumerator, nDenominator: Integer): Integer; stdcall;
--%% {$EXTERNALSYM MulDiv}

--%% procedure GetSystemTime(var lpSystemTime: SYSTEMTIME); stdcall;
--%% {$EXTERNALSYM GetSystemTime}

--%% procedure GetSystemTimeAsFileTime(var lpSystemTimeAsFileTime: FILETIME); stdcall;
--%% {$EXTERNALSYM GetSystemTimeAsFileTime}

--%% function SetSystemTime(var lpSystemTime: SYSTEMTIME): BOOL; stdcall;
--%% {$EXTERNALSYM SetSystemTime}

--%% procedure GetLocalTime(var lpSystemTime: SYSTEMTIME); stdcall;
--%% {$EXTERNALSYM GetLocalTime}

--%% function SetLocalTime(var lpSystemTime: SYSTEMTIME): BOOL; stdcall;
--%% {$EXTERNALSYM SetLocalTime}

--%% procedure GetSystemInfo(var lpSystemInfo: SYSTEM_INFO); stdcall;
--%% {$EXTERNALSYM GetSystemInfo}

--%% function GetSystemRegistryQuota(out pdwQuotaAllowed, pdwQuotaUsed: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetSystemRegistryQuota}

--%% function GetSystemTimes(lpIdleTime, lpKernelTime, lpUserTime: LPFILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM GetSystemTimes}

--%% procedure GetNativeSystemInfo(lpSystemInfo: LPSYSTEM_INFO); stdcall;
--%% {$EXTERNALSYM GetNativeSystemInfo}

--%% function IsProcessorFeaturePresent(ProcessorFeature: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM IsProcessorFeaturePresent}

--%%   PTIME_ZONE_INFORMATION = ^TIME_ZONE_INFORMATION;
--%%   {$EXTERNALSYM PTIME_ZONE_INFORMATION}
--%%   _TIME_ZONE_INFORMATION = record
--%%     Bias: LONG;
--%%     StandardName: array [0..31] of WCHAR;
--%%     StandardDate: SYSTEMTIME;
--%%     StandardBias: LONG;
--%%     DaylightName: array [0..31] of WCHAR;
--%%     DaylightDate: SYSTEMTIME;
--%%     DaylightBias: LONG;
--%%   end;
--%%   {$EXTERNALSYM _TIME_ZONE_INFORMATION}
--%%   TIME_ZONE_INFORMATION = _TIME_ZONE_INFORMATION;
--%%   {$EXTERNALSYM TIME_ZONE_INFORMATION}
--%%   LPTIME_ZONE_INFORMATION = ^TIME_ZONE_INFORMATION;
--%%   {$EXTERNALSYM LPTIME_ZONE_INFORMATION}
--%%   TTimeZoneInformation = TIME_ZONE_INFORMATION;
--%%   PTimeZoneInformation = PTIME_ZONE_INFORMATION;

--%% function SystemTimeToTzSpecificLocalTime(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION;
--%%   var lpUniversalTime, lpLocalTime: SYSTEMTIME): BOOL; stdcall;
--%% {$EXTERNALSYM SystemTimeToTzSpecificLocalTime}

--%% function TzSpecificLocalTimeToSystemTime(const lpTimeZoneInformation: TIME_ZONE_INFORMATION;
--%%   const lpLocalTime: SYSTEMTIME; var lpUniversalTime: SYSTEMTIME): BOOL; stdcall;
--%% {$EXTERNALSYM TzSpecificLocalTimeToSystemTime}

--%% function GetTimeZoneInformation(var lpTimeZoneInformation: TIME_ZONE_INFORMATION): DWORD; stdcall;
--%% {$EXTERNALSYM GetTimeZoneInformation}

--%% function SetTimeZoneInformation(const lpTimeZoneInformation: TIME_ZONE_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM SetTimeZoneInformation}

--
-- Routines to convert back and forth between system time and file time
--

--%% function SystemTimeToFileTime(const lpSystemTime: SYSTEMTIME; var lpFileTime: FILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM SystemTimeToFileTime}

--%% function FileTimeToLocalFileTime(const lpFileTime: FILETIME; var lpLocalFileTime: FILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM FileTimeToLocalFileTime}

--%% function LocalFileTimeToFileTime(const lpLocalFileTime: FILETIME; var lpFileTime: FILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM LocalFileTimeToFileTime}

--%% function FileTimeToSystemTime(const lpFileTime: FILETIME; var lpSystemTime: SYSTEMTIME): BOOL; stdcall;
--%% {$EXTERNALSYM FileTimeToSystemTime}

--%% function CompareFileTime(const lpFileTime1, lpFileTime2: FILETIME): LONG; stdcall;
--%% {$EXTERNALSYM CompareFileTime}

--%% function FileTimeToDosDateTime(const lpFileTime: FILETIME; var lpFatDate,
--%%   lpFatTime: WORD): BOOL; stdcall;
--%% {$EXTERNALSYM FileTimeToDosDateTime}

--%% function DosDateTimeToFileTime(wFatDate, wFatTime: WORD; var lpFileTime: FILETIME): BOOL; stdcall;
--%% {$EXTERNALSYM DosDateTimeToFileTime}

--%% function GetTickCount: DWORD; stdcall;
--%% {$EXTERNALSYM GetTickCount}

--%% function SetSystemTimeAdjustment(dwTimeAdjustment: DWORD;
--%%   bTimeAdjustmentDisabled: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSystemTimeAdjustment}

--%% function GetSystemTimeAdjustment(var lpTimeAdjustment, lpTimeIncrement: DWORD;
--%%   var lpTimeAdjustmentDisabled: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetSystemTimeAdjustment}

--%% function FormatMessageA(dwFlags: DWORD; lpSource: LPCVOID; dwMessageId: DWORD;
--%%   dwLanguageId: DWORD; lpBuffer: LPSTR; nSize: DWORD; Arguments: Pointer): DWORD; stdcall;
--%% {$EXTERNALSYM FormatMessageA}
--%% function FormatMessageW(dwFlags: DWORD; lpSource: LPCVOID; dwMessageId: DWORD;
--%%   dwLanguageId: DWORD; lpBuffer: LPWSTR; nSize: DWORD; Arguments: Pointer): DWORD; stdcall;
--%% {$EXTERNALSYM FormatMessageW}
--%% function FormatMessage(dwFlags: DWORD; lpSource: LPCVOID; dwMessageId: DWORD;
--%%   dwLanguageId: DWORD; lpBuffer: LPTSTR; nSize: DWORD; Arguments: Pointer): DWORD; stdcall;
--%% {$EXTERNALSYM FormatMessage}

   Format_Message_Allocate_Buffer : constant := 16#0000_0100#;
   Format_Message_Ignore_Inserts  : constant := 16#0000_0200#;
   Format_Message_From_String     : constant := 16#0000_0400#;
   Format_Message_From_Hmodule    : constant := 16#0000_0800#;
   Format_Message_From_System     : constant := 16#0000_1000#;
   Format_Message_Argument_Array  : constant := 16#0000_2000#;
   Format_Message_Max_Width_Mask  : constant := 16#0000_00FF#;

--%% function CreatePipe(var hReadPipe, hWritePipe: HANDLE;
--%%   lpPipeAttributes: LPSECURITY_ATTRIBUTES; nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CreatePipe}

--%% function ConnectNamedPipe(hNamedPipe: HANDLE; lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM ConnectNamedPipe}

--%% function DisconnectNamedPipe(hNamedPipe: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DisconnectNamedPipe}

--%% function SetNamedPipeHandleState(hNamedPipe: HANDLE; lpMode: LPDWORD;
--%%   lpMaxCollectionCount: LPDWORD; lpCollectDataTimeout: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetNamedPipeHandleState}

--%% function GetNamedPipeInfo(hNamedPipe: HANDLE; lpFlags, lpOutBufferSize,
--%%   lpInBufferSize, lpMaxInstances: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetNamedPipeInfo}

--%% function PeekNamedPipe(hNamedPipe: HANDLE; lpBuffer: LPVOID; nBufferSize: DWORD;
--%%   lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM PeekNamedPipe}

--%% function TransactNamedPipe(hNamedPipe: HANDLE; lpInBuffer: LPVOID;
--%%   nInBufferSize: DWORD; lpOutBuffer: LPVOID; nOutBufferSize: DWORD;
--%%   lpBytesRead: LPDWORD; lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM TransactNamedPipe}

--%% function CreateMailslotA(lpName: LPCSTR; nMaxMessageSize, lReadTimeout: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateMailslotA}
--%% function CreateMailslotW(lpName: LPCWSTR; nMaxMessageSize, lReadTimeout: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateMailslotW}
--%% function CreateMailslot(lpName: LPCTSTR; nMaxMessageSize, lReadTimeout: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateMailslot}

--%% function GetMailslotInfo(hMailslot: HANDLE; lpMaxMessageSize, lpNextSize,
--%%   lpMessageCount, lpReadTimeout: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetMailslotInfo}

--%% function SetMailslotInfo(hMailslot: HANDLE; lReadTimeout: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetMailslotInfo}

--%% function MapViewOfFile(hFileMappingObject: HANDLE; dwDesiredAccess: DWORD;
--%%   dwFileOffsetHigh, dwFileOffsetLow: DWORD; dwNumberOfBytesToMap: SIZE_T): LPVOID; stdcall;
--%% {$EXTERNALSYM MapViewOfFile}

--%% function FlushViewOfFile(lpBaseAddress: LPCVOID; dwNumberOfBytesToFlush: SIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM FlushViewOfFile}

--%% function UnmapViewOfFile(lpBaseAddress: LPCVOID): BOOL; stdcall;
--%% {$EXTERNALSYM UnmapViewOfFile}

--
-- File Encryption API
--

--%% function EncryptFileA(lpFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM EncryptFileA}
--%% function EncryptFileW(lpFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM EncryptFileW}
--%% function EncryptFile(lpFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM EncryptFile}

--%% function DecryptFileA(lpFileName: LPCSTR; dwReserved: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DecryptFileA}
--%% function DecryptFileW(lpFileName: LPCWSTR; dwReserved: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DecryptFileW}
--%% function DecryptFile(lpFileName: LPCTSTR; dwReserved: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DecryptFile}

--
--  Encryption Status Value
--

   File_Encryptable        : constant := 0;
   File_Is_Encrypted       : constant := 1;
   File_System_Attr        : constant := 2;
   File_Root_Dir           : constant := 3;
   File_System_Dir         : constant := 4;
   File_Unknown            : constant := 5;
   File_System_Not_Support : constant := 6;
   File_User_Disallowed    : constant := 7;
   File_Read_Only          : constant := 8;
   File_Dir_Disallowed     : constant := 9;

--%% function FileEncryptionStatusA(lpFileName: LPCSTR; var lpStatus: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FileEncryptionStatusA}
--%% function FileEncryptionStatusW(lpFileName: LPCWSTR; var lpStatus: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FileEncryptionStatusW}
--%% function FileEncryptionStatus(lpFileName: LPCTSTR; var lpStatus: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FileEncryptionStatus}

--
-- Currently defined recovery flags
--

   Efs_Use_Recovery_Keys : constant := 16#1#;

--%%   PFE_EXPORT_FUNC = function(pbData: PBYTE; pvCallbackContext: PVOID;
--%%     ulLength: ULONG): DWORD; stdcall;
--%%   {$EXTERNALSYM PFE_EXPORT_FUNC}

--%%   PFE_IMPORT_FUNC = function(pbData: PBYTE; pvCallbackContext: PVOID;
--%%     ulLength: PULONG): DWORD; stdcall;
--%%   {$EXTERNALSYM PFE_IMPORT_FUNC}

--
--  OpenRaw flag values
--

   Create_For_Import : constant := 1;
   Create_For_Dir    : constant := 2;
   Overwrite_Hidden  : constant := 4;

--%% function OpenEncryptedFileRawA(lpFileName: LPCSTR; ulFlags: ULONG;
--%%   pvContext: PVOID): DWORD; stdcall;
--%% {$EXTERNALSYM OpenEncryptedFileRawA}
--%% function OpenEncryptedFileRawW(lpFileName: LPCWSTR; ulFlags: ULONG;
--%%   pvContext: PVOID): DWORD; stdcall;
--%% {$EXTERNALSYM OpenEncryptedFileRawW}
--%% function OpenEncryptedFileRaw(lpFileName: LPCTSTR; ulFlags: ULONG;
--%%   pvContext: PVOID): DWORD; stdcall;
--%% {$EXTERNALSYM OpenEncryptedFileRaw}

--%% function ReadEncryptedFileRaw(pfExportCallback: PFE_EXPORT_FUNC;
--%%   pvCallbackContext: PVOID; pvContext: PVOID): DWORD; stdcall;
--%% {$EXTERNALSYM ReadEncryptedFileRaw}

--%% function WriteEncryptedFileRaw(pfImportCallback: PFE_IMPORT_FUNC;
--%%   pvCallbackContext: PVOID; pvContext: PVOID): DWORD; stdcall;
--%% {$EXTERNALSYM WriteEncryptedFileRaw}

--%% procedure CloseEncryptedFileRaw(pvContext: PVOID); stdcall;
--%% {$EXTERNALSYM CloseEncryptedFileRaw}

--
-- _l Compat Functions
--

--%% function lstrcmpA(lpString1, lpString2: LPCSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrcmpA}
--%% function lstrcmpW(lpString1, lpString2: LPCWSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrcmpW}
--%% function lstrcmp(lpString1, lpString2: LPCTSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrcmp}

--%% function lstrcmpiA(lpString1, lpString2: LPCSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrcmpiA}
--%% function lstrcmpiW(lpString1, lpString2: LPCWSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrcmpiW}
--%% function lstrcmpi(lpString1, lpString2: LPCTSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrcmpi}

--%% function lstrcpynA(lpString1: LPSTR; lpString2: LPCSTR; iMaxLength: Integer): LPSTR; stdcall;
--%% {$EXTERNALSYM lstrcpynA}
--%% function lstrcpynW(lpString1: LPWSTR; lpString2: LPCWSTR; iMaxLength: Integer): LPWSTR; stdcall;
--%% {$EXTERNALSYM lstrcpynW}
--%% function lstrcpyn(lpString1: LPTSTR; lpString2: LPCTSTR; iMaxLength: Integer): LPTSTR; stdcall;
--%% {$EXTERNALSYM lstrcpyn}

--%% function lstrcpyA(lpString1: LPSTR; lpString2: LPCSTR): LPSTR; stdcall;
--%% {$EXTERNALSYM lstrcpyA}
--%% function lstrcpyW(lpString1: LPWSTR; lpString2: LPCWSTR): LPWSTR; stdcall;
--%% {$EXTERNALSYM lstrcpyW}
--%% function lstrcpy(lpString1: LPTSTR; lpString2: LPCTSTR): LPTSTR; stdcall;
--%% {$EXTERNALSYM lstrcpy}

--%% function lstrcatA(lpString1: LPSTR; lpString2: LPCSTR): LPSTR; stdcall;
--%% {$EXTERNALSYM lstrcatA}
--%% function lstrcatW(lpString1: LPWSTR; lpString2: LPCWSTR): LPWSTR; stdcall;
--%% {$EXTERNALSYM lstrcatW}
--%% function lstrcat(lpString1: LPTSTR; lpString2: LPCTSTR): LPTSTR; stdcall;
--%% {$EXTERNALSYM lstrcat}

--%% function lstrlenA(lpString: LPCSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrlenA}
--%% function lstrlenW(lpString: LPCWSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrlenW}
--%% function lstrlen(lpString: LPCTSTR): Integer; stdcall;
--%% {$EXTERNALSYM lstrlen}

--%% function OpenFile(lpFileName: LPCSTR; var lpReOpenBuff: OFSTRUCT; uStyle: UINT): HFILE; stdcall;
--%% {$EXTERNALSYM OpenFile}

--%% function _lopen(lpPathName: LPCSTR; iReadWrite: Integer): HFILE; stdcall;
--%% {$EXTERNALSYM _lopen}

--%% function _lcreat(lpPathName: LPCSTR; iAttribute: Integer): HFILE; stdcall;
--%% {$EXTERNALSYM _lcreat}

--%% function _lread(hFile: HFILE; lpBuffer: LPVOID; uBytes: UINT): UINT; stdcall;
--%% {$EXTERNALSYM _lread}

--%% function _lwrite(hFile: HFILE; lpBuffer: LPCSTR; uBytes: UINT): UINT; stdcall;
--%% {$EXTERNALSYM _lwrite}

--%% function _hread(hFile: HFILE; lpBuffer: LPVOID; lBytes: Longint): Longint; stdcall;
--%% {$EXTERNALSYM _hread}

--%% function _hwrite(hFile: HFILE; lpBuffer: LPCSTR; lBytes: Longint): Longint; stdcall;
--%% {$EXTERNALSYM _hwrite}

--%% function _lclose(hFile: HFILE): HFILE; stdcall;
--%% {$EXTERNALSYM _lclose}

--%% function _llseek(hFile: HFILE; lOffset: LONG; iOrigin: Integer): LONG; stdcall;
--%% {$EXTERNALSYM _llseek}

--%% function IsTextUnicode(lpBuffer: LPVOID; cb: Integer; lpi: LPINT): BOOL; stdcall;
--%% {$EXTERNALSYM IsTextUnicode}

--%%   PFLS_CALLBACK_FUNCTION = procedure(lpFlsData: PVOID); stdcall;
--%%   {$EXTERNALSYM PFLS_CALLBACK_FUNCTION}
--%%   TFlsCallbackFunction = PFLS_CALLBACK_FUNCTION;

   Fls_Out_Of_Indexes : constant := 16#FFFF_FFFF#;

--%% function FlsAlloc(lpCallback: PFLS_CALLBACK_FUNCTION): DWORD; stdcall;
--%% {$EXTERNALSYM FlsAlloc}

--%% function FlsGetValue(dwFlsIndex: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM FlsGetValue}

--%% function FlsSetValue(dwFlsIndex: DWORD; lpFlsData: PVOID): DWORD; stdcall;
--%% {$EXTERNALSYM FlsSetValue}

--%% function FlsFree(dwFlsIndex: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM FlsFree}

   Tls_Out_Of_Indexes : constant := 16#FFFF_FFFF#;

--%% function TlsAlloc: DWORD; stdcall;
--%% {$EXTERNALSYM TlsAlloc}

--%% function TlsGetValue(dwTlsIndex: DWORD): LPVOID; stdcall;
--%% {$EXTERNALSYM TlsGetValue}

--%% function TlsSetValue(dwTlsIndex: DWORD; lpTlsValue: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM TlsSetValue}

--%% function TlsFree(dwTlsIndex: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM TlsFree}

--%%   LPOVERLAPPED_COMPLETION_ROUTINE = procedure(dwErrorCode: DWORD;
--%%     dwNumberOfBytesTransfered: DWORD; lpOverlapped: LPOVERLAPPED); stdcall;
--%%   {$EXTERNALSYM LPOVERLAPPED_COMPLETION_ROUTINE}
--%%   TOverlappedCompletionRoutine = LPOVERLAPPED_COMPLETION_ROUTINE;

--%% function SleepEx(dwMilliseconds: DWORD; bAlertable: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM SleepEx}

--%% function WaitForSingleObjectEx(hHandle: HANDLE; dwMilliseconds: DWORD;
--%%   bAlertable: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM WaitForSingleObjectEx}

--%% function WaitForMultipleObjectsEx(nCount: DWORD; lpHandles: PHANDLE;
--%%   bWaitAll: BOOL; dwMilliseconds: DWORD; bAlertable: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM WaitForMultipleObjectsEx}

--%% function SignalObjectAndWait(hObjectToSignal: HANDLE; hObjectToWaitOn: HANDLE;
--%%   dwMilliseconds: DWORD; bAlertable: BOOL): DWORD; stdcall;
--%% {$EXTERNALSYM SignalObjectAndWait}

--%% function ReadFileEx(hFile: HANDLE; lpBuffer: LPVOID; nNumberOfBytesToRead: DWORD;
--%%   lpOverlapped: LPOVERLAPPED; lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): BOOL; stdcall;
--%% {$EXTERNALSYM ReadFileEx}

--%% function WriteFileEx(hFile: HANDLE; lpBuffer: LPCVOID; nNumberOfBytesToWrite: DWORD;
--%%   lpOverlapped: LPOVERLAPPED; lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): BOOL; stdcall;
--%% {$EXTERNALSYM WriteFileEx}

--%% function BackupRead(hFile: HANDLE; lpBuffer: LPBYTE;
--%%   nNumberOfBytesToRead: DWORD; var lpNumberOfBytesRead: DWORD;
--%%   bAbort, bProcessSecurity: BOOL; var lpContext: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM BackupRead}

--%% function BackupSeek(hFile: HANDLE; dwLowBytesToSeek, dwHighBytesToSeek: DWORD;
--%%   var lpdwLowByteSeeked, lpdwHighByteSeeked: DWORD; var lpContext: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM BackupSeek}

--%% function BackupWrite(hFile: HANDLE; lpBuffer: LPBYTE; nNumberOfBytesToWrite: DWORD;
--%%   var lpNumberOfBytesWritten: DWORD; bAbort, bProcessSecurity: BOOL;
--%%   var lpContext: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM BackupWrite}

--
--  Stream id structure
--

--%%   LPWIN32_STREAM_ID = ^WIN32_STREAM_ID;
--%%   {$EXTERNALSYM LPWIN32_STREAM_ID}
--%%   _WIN32_STREAM_ID = record
--%%     dwStreamId: DWORD;
--%%     dwStreamAttributes: DWORD;
--%%     Size: TLargeInteger;
--%%     dwStreamNameSize: DWORD;
--%%     cStreamName: array [0..ANYSIZE_ARRAY - 1] of WCHAR;
--%%   end;
--%%   {$EXTERNALSYM _WIN32_STREAM_ID}
--%%   WIN32_STREAM_ID = _WIN32_STREAM_ID;
--%%   {$EXTERNALSYM WIN32_STREAM_ID}
--%%   TWin32StreamId = WIN32_STREAM_ID;
--%%   PWin32StreamId = LPWIN32_STREAM_ID;

--
--  Stream Ids
--

   Backup_Invalid        : constant := 16#0000_0000#;
   Backup_Data           : constant := 16#0000_0001#;
   Backup_Ea_Data        : constant := 16#0000_0002#;
   Backup_Security_Data  : constant := 16#0000_0003#;
   Backup_Alternate_Data : constant := 16#0000_0004#;
   Backup_Link           : constant := 16#0000_0005#;
   Backup_Property_Data  : constant := 16#0000_0006#;
   Backup_Object_Id      : constant := 16#0000_0007#;
   Backup_Reparse_Data   : constant := 16#0000_0008#;
   Backup_Sparse_Block   : constant := 16#0000_0009#;

--
--  Stream Attributes
--

   Stream_Normal_Attribute    : constant := 16#0000_0000#;
   Stream_Modified_When_Read  : constant := 16#0000_0001#;
   Stream_Contains_Security   : constant := 16#0000_0002#;
   Stream_Contains_Properties : constant := 16#0000_0004#;
   Stream_Sparse_Attribute    : constant := 16#0000_0008#;

--%% function ReadFileScatter(hFile: HANDLE; aSegmentArray: PFILE_SEGMENT_ELEMENT;
--%%   nNumberOfBytesToRead: DWORD; lpReserved: LPDWORD; lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM ReadFileScatter}

--%% function WriteFileGather(hFile: HANDLE; aSegmentArray: PFILE_SEGMENT_ELEMENT;
--%%   nNumberOfBytesToWrite: DWORD; lpReserved: LPDWORD; lpOverlapped: LPOVERLAPPED): BOOL; stdcall;
--%% {$EXTERNALSYM WriteFileGather}

--
-- Dual Mode API below this line. Dual Mode Structures also included.
--

   Startf_Useshowwindow    : constant := 16#0000_0001#;
   Startf_Usesize          : constant := 16#0000_0002#;
   Startf_Useposition      : constant := 16#0000_0004#;
   Startf_Usecountchars    : constant := 16#0000_0008#;
   Startf_Usefillattribute : constant := 16#0000_0010#;
   Startf_Runfullscreen    : constant := 16#0000_0020#; -- ignored for non-x86 platforms
   Startf_Forceonfeedback  : constant := 16#0000_0040#;
   Startf_Forceofffeedback : constant := 16#0000_0080#;
   Startf_Usestdhandles    : constant := 16#0000_0100#;

   Startf_Usehotkey : constant := 16#0000_0200#;

   type Startup_Info_A_Type;
   type Startup_Info_A_Ptr is access all Startup_Info_A_Type;
   type Startup_Info_A_CPtr is access constant Startup_Info_A_Type;
   type Startup_Info_A_Type is record
       : Unsigned_32;
      Reserved : Char_8_Ptr;
      Desktop : Char_8_Ptr;
      Title : Char_8_Ptr;
      X : Unsigned_32;
      Y : Unsigned_32;
      X_Size : Unsigned_32;
      Y_Size : Unsigned_32;
      X_Count_Chars : Unsigned_32;
      Y_Count_Chars : Unsigned_32;
      Fill_Attribute : Unsigned_32;
      Flags : Unsigned_32;
      Show_Window : Unsigned_16;
      Reserved2 : Unsigned_16;
      Reserved2 : LPBYTE;
      Std_Input : Handle_Type;
      Std_Output : Handle_Type;
      Std_Error : Handle_Type;
   end record;

   type Startup_Info_W_Type;
   type Startup_Info_W_Ptr is access all Startup_Info_W_Type;
   type Startup_Info_W_CPtr is access constant Startup_Info_W_Type;
   type Startup_Info_W_Type is record
       : Unsigned_32;
      Reserved : Char_16_Ptr;
      Desktop : Char_16_Ptr;
      Title : Char_16_Ptr;
      X : Unsigned_32;
      Y : Unsigned_32;
      X_Size : Unsigned_32;
      Y_Size : Unsigned_32;
      X_Count_Chars : Unsigned_32;
      Y_Count_Chars : Unsigned_32;
      Fill_Attribute : Unsigned_32;
      Flags : Unsigned_32;
      Show_Window : Unsigned_16;
      Reserved2 : Unsigned_16;
      Reserved2 : LPBYTE;
      Std_Input : Handle_Type;
      Std_Output : Handle_Type;
      Std_Error : Handle_Type;
   end record;

--%%   {$IFDEF UNICODE}
   subtype Startupinfo_Type is Startup_Info_W_Type;
   subtype Startupinfo_Ptr is Startup_Info_W_Ptr;
   subtype Startupinfo_CPtr is Startup_Info_W_CPtr;
   subtype Lpstartupinfo_Type is Startup_Info_W_Ptr;
   type Lpstartupinfo_Ptr is access all Startup_Info_W_Ptr;
   type Lpstartupinfo_CPtr is access constant Startup_Info_W_Ptr;
--%%   TStartupInfo = TStartupInfoW;
--%%   PStartupInfo = PStartupInfoW;
--%%   {$ELSE}
   subtype Startupinfo_Type is Startup_Info_A_Type;
   subtype Startupinfo_Ptr is Startup_Info_A_Ptr;
   subtype Startupinfo_CPtr is Startup_Info_A_CPtr;
   subtype Lpstartupinfo_Type is Startup_Info_A_Ptr;
   type Lpstartupinfo_Ptr is access all Startup_Info_A_Ptr;
   type Lpstartupinfo_CPtr is access constant Startup_Info_A_Ptr;
--%%   TStartupInfo = TStartupInfoA;
--%%   PStartupInfo = PStartupInfoA;
--%%   {$ENDIF UNICODE}

   Shutdown_Noretry : constant := 16#0000_0001#;

--%%   PWIN32_FIND_DATAA = ^WIN32_FIND_DATAA;
--%%   {$EXTERNALSYM PWIN32_FIND_DATAA}
--%%   _WIN32_FIND_DATAA = record
--%%     dwFileAttributes: DWORD;
--%%     ftCreationTime: FILETIME;
--%%     ftLastAccessTime: FILETIME;
--%%     ftLastWriteTime: FILETIME;
--%%     nFileSizeHigh: DWORD;
--%%     nFileSizeLow: DWORD;
--%%     dwReserved0: DWORD;
--%%     dwReserved1: DWORD;
--%%     cFileName: array [0..MAX_PATH - 1] of CHAR;
--%%     cAlternateFileName: array [0..13] of CHAR;
--%%   end;
--%%   {$EXTERNALSYM _WIN32_FIND_DATAA}
--%%   WIN32_FIND_DATAA = _WIN32_FIND_DATAA;
--%%   {$EXTERNALSYM WIN32_FIND_DATAA}
--%%   LPWIN32_FIND_DATAA = ^WIN32_FIND_DATAA;
--%%   {$EXTERNALSYM LPWIN32_FIND_DATAA}
--%%   TWin32FindDataA = WIN32_FIND_DATAA;
--%%   PWin32FindDataA = PWIN32_FIND_DATAA;

--%%   PWIN32_FIND_DATAW = ^WIN32_FIND_DATAW;
--%%   {$EXTERNALSYM PWIN32_FIND_DATAW}
--%%   _WIN32_FIND_DATAW = record
--%%     dwFileAttributes: DWORD;
--%%     ftCreationTime: FILETIME;
--%%     ftLastAccessTime: FILETIME;
--%%     ftLastWriteTime: FILETIME;
--%%     nFileSizeHigh: DWORD;
--%%     nFileSizeLow: DWORD;
--%%     dwReserved0: DWORD;
--%%     dwReserved1: DWORD;
--%%     cFileName: array [0..MAX_PATH - 1] of WCHAR;
--%%     cAlternateFileName: array [0..13] of WCHAR;
--%%   end;
--%%   {$EXTERNALSYM _WIN32_FIND_DATAW}
--%%   WIN32_FIND_DATAW = _WIN32_FIND_DATAW;
--%%   {$EXTERNALSYM WIN32_FIND_DATAW}
--%%   LPWIN32_FIND_DATAW = ^WIN32_FIND_DATAW;
--%%   {$EXTERNALSYM LPWIN32_FIND_DATAW}
--%%   TWin32FindDataW = WIN32_FIND_DATAW;
--%%   PWin32FindDataW = PWIN32_FIND_DATAW;

--%%   {$IFDEF UNICODE}
--%%   WIN32_FIND_DATA = WIN32_FIND_DATAW;
--%%   {$EXTERNALSYM WIN32_FIND_DATA}
--%%   PWIN32_FIND_DATA = PWIN32_FIND_DATAW;
--%%   {$EXTERNALSYM PWIN32_FIND_DATA}
--%%   LPWIN32_FIND_DATA = LPWIN32_FIND_DATAW;
--%%   {$EXTERNALSYM LPWIN32_FIND_DATA}
--%%   TWin32FindData = TWin32FindDataW;
--%%   PWin32FindData = PWin32FindDataW;
--%%   {$ELSE}
--%%   WIN32_FIND_DATA = WIN32_FIND_DATAA;
--%%   {$EXTERNALSYM WIN32_FIND_DATA}
--%%   PWIN32_FIND_DATA = PWIN32_FIND_DATAA;
--%%   {$EXTERNALSYM PWIN32_FIND_DATA}
--%%   LPWIN32_FIND_DATA = LPWIN32_FIND_DATAA;
--%%   {$EXTERNALSYM LPWIN32_FIND_DATA}
--%%   TWin32FindData = TWin32FindDataA;
--%%   PWin32FindData = PWin32FindDataA;
--%%   {$ENDIF UNICODE}

   type Win32File_Attribute_Data_Type;
   type Win32File_Attribute_Data_Ptr is access all Win32File_Attribute_Data_Type;
   type Win32File_Attribute_Data_CPtr is access constant Win32File_Attribute_Data_Type;
   type Win32File_Attribute_Data_Type is record
      File_Attributes : Unsigned_32;
      Creation_Time : File_Time_Type;
      Last_Access_Time : File_Time_Type;
      Last_Write_Time : File_Time_Type;
      File_Size_High : Unsigned_32;
      File_Size_Low : Unsigned_32;
   end record;

--%% function CreateMutexA(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: BOOL; lpName: LPCSTR): HANDLE;
--%% {$EXTERNALSYM CreateMutexA}
--%% function CreateMutexW(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: BOOL; lpName: LPCWSTR): HANDLE;
--%% {$EXTERNALSYM CreateMutexW}
--%% function CreateMutex(lpMutexAttributes: LPSECURITY_ATTRIBUTES;
--%%   bInitialOwner: BOOL; lpName: LPCTSTR): HANDLE;
--%% {$EXTERNALSYM CreateMutex}

--%% function OpenMutexA(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenMutexA}
--%% function OpenMutexW(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenMutexW}
--%% function OpenMutex(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenMutex}

--%% function CreateEventA(lpEventAttributes: LPSECURITY_ATTRIBUTES;
--%%   bManualReset, bInitialState: BOOL; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateEventA}
--%% function CreateEventW(lpEventAttributes: LPSECURITY_ATTRIBUTES;
--%%   bManualReset, bInitialState: BOOL; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateEventW}
--%% function CreateEvent(lpEventAttributes: LPSECURITY_ATTRIBUTES;
--%%   bManualReset, bInitialState: BOOL; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateEvent}

--%% function OpenEventA(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenEventA}
--%% function OpenEventW(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenEventW}
--%% function OpenEvent(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenEvent}

--%% function CreateSemaphoreA(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES;
--%%   lInitialCount, lMaximumCount: LONG; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateSemaphoreA}
--%% function CreateSemaphoreW(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES;
--%%   lInitialCount, lMaximumCount: LONG; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateSemaphoreW}
--%% function CreateSemaphore(lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES;
--%%   lInitialCount, lMaximumCount: LONG; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateSemaphore}

--%% function OpenSemaphoreA(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenSemaphoreA}
--%% function OpenSemaphoreW(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenSemaphoreW}
--%% function OpenSemaphore(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenSemaphore}

--%%   PTIMERAPCROUTINE = procedure(lpArgToCompletionRoutine: LPVOID;
--%%     dwTimerLowValue, dwTimerHighValue: DWORD); stdcall;
--%%   {$EXTERNALSYM PTIMERAPCROUTINE}
--%%   TTimerApcRoutine = PTIMERAPCROUTINE;

--%% function CreateWaitableTimerA(lpTimerAttributes: LPSECURITY_ATTRIBUTES;
--%%   bManualReset: BOOL; lpTimerName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateWaitableTimerA}
--%% function CreateWaitableTimerW(lpTimerAttributes: LPSECURITY_ATTRIBUTES;
--%%   bManualReset: BOOL; lpTimerName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateWaitableTimerW}
--%% function CreateWaitableTimer(lpTimerAttributes: LPSECURITY_ATTRIBUTES;
--%%   bManualReset: BOOL; lpTimerName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateWaitableTimer}

--%% function OpenWaitableTimerA(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpTimerName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenWaitableTimerA}
--%% function OpenWaitableTimerW(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpTimerName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenWaitableTimerW}
--%% function OpenWaitableTimer(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpTimerName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenWaitableTimer}

--%% function SetWaitableTimer(hTimer: HANDLE; var lpDueTime: LARGE_INTEGER;
--%%   lPeriod: LONG; pfnCompletionRoutine: PTIMERAPCROUTINE;
--%%   lpArgToCompletionRoutine: LPVOID; fResume: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetWaitableTimer}

--%% function CancelWaitableTimer(hTimer: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CancelWaitableTimer}

--%% function CreateFileMappingA(hFile: HANDLE; lpFileMappingAttributes: LPSECURITY_ATTRIBUTES;
--%%   flProtect, dwMaximumSizeHigh, dwMaximumSizeLow: DWORD; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateFileMappingA}
--%% function CreateFileMappingW(hFile: HANDLE; lpFileMappingAttributes: LPSECURITY_ATTRIBUTES;
--%%   flProtect, dwMaximumSizeHigh, dwMaximumSizeLow: DWORD; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateFileMappingW}
--%% function CreateFileMapping(hFile: HANDLE; lpFileMappingAttributes: LPSECURITY_ATTRIBUTES;
--%%   flProtect, dwMaximumSizeHigh, dwMaximumSizeLow: DWORD; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateFileMapping}

--%% function OpenFileMappingA(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenFileMappingA}
--%% function OpenFileMappingW(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenFileMappingW}
--%% function OpenFileMapping(dwDesiredAccess: DWORD; bInheritHandle: BOOL;
--%%   lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenFileMapping}

--%% function GetLogicalDriveStringsA(nBufferLength: DWORD; lpBuffer: LPSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetLogicalDriveStringsA}
--%% function GetLogicalDriveStringsW(nBufferLength: DWORD; lpBuffer: LPWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetLogicalDriveStringsW}
--%% function GetLogicalDriveStrings(nBufferLength: DWORD; lpBuffer: LPTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetLogicalDriveStrings}

--%%   _MEMORY_RESOURCE_NOTIFICATION_TYPE = (
--%%     LowMemoryResourceNotification,
--%%     HighMemoryResourceNotification);
--%%   {$EXTERNALSYM _MEMORY_RESOURCE_NOTIFICATION_TYPE}
--%%   MEMORY_RESOURCE_NOTIFICATION_TYPE = _MEMORY_RESOURCE_NOTIFICATION_TYPE;
--%%   {$EXTERNALSYM MEMORY_RESOURCE_NOTIFICATION_TYPE}
--%%   TMemoryResourceNotification = MEMORY_RESOURCE_NOTIFICATION_TYPE;

--%% function CreateMemoryResourceNotification(NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateMemoryResourceNotification}

--%% function QueryMemoryResourceNotification(ResourceNotificationHandle: HANDLE;
--%%   ResourceState: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM QueryMemoryResourceNotification}

--%% function LoadLibraryA(lpLibFileName: LPCSTR): HMODULE; stdcall;
--%% {$EXTERNALSYM LoadLibraryA}
--%% function LoadLibraryW(lpLibFileName: LPCWSTR): HMODULE; stdcall;
--%% {$EXTERNALSYM LoadLibraryW}
--%% function LoadLibrary(lpLibFileName: LPCTSTR): HMODULE; stdcall;
--%% {$EXTERNALSYM LoadLibrary}

--%% function LoadLibraryExA(lpLibFileName: LPCSTR; hFile: HANDLE; dwFlags: DWORD): HMODULE; stdcall;
--%% {$EXTERNALSYM LoadLibraryExA}
--%% function LoadLibraryExW(lpLibFileName: LPCWSTR; hFile: HANDLE; dwFlags: DWORD): HMODULE; stdcall;
--%% {$EXTERNALSYM LoadLibraryExW}
--%% function LoadLibraryEx(lpLibFileName: LPCTSTR; hFile: HANDLE; dwFlags: DWORD): HMODULE; stdcall;
--%% {$EXTERNALSYM LoadLibraryEx}

   Dont_Resolve_DLL_References   : constant := 16#0000_0001#;
   Load_Library_As_Datafile      : constant := 16#0000_0002#;
   Load_With_Altered_Search_Path : constant := 16#0000_0008#;
   Load_Ignore_Code_Authz_Level  : constant := 16#0000_0010#;

--%% function GetModuleFileNameA(hModule: HMODULE; lpFilename: LPSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetModuleFileNameA}
--%% function GetModuleFileNameW(hModule: HMODULE; lpFilename: LPWSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetModuleFileNameW}
--%% function GetModuleFileName(hModule: HMODULE; lpFilename: LPTSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetModuleFileName}

--%% function GetModuleHandleA(lpModuleName: LPCSTR): HMODULE; stdcall;
--%% {$EXTERNALSYM GetModuleHandleA}
--%% function GetModuleHandleW(lpModuleName: LPCWSTR): HMODULE; stdcall;
--%% {$EXTERNALSYM GetModuleHandleW}
--%% function GetModuleHandle(lpModuleName: LPCTSTR): HMODULE; stdcall;
--%% {$EXTERNALSYM GetModuleHandle}

   Get_Module_Handle_Ex_Flag_Pin                : constant := 16#0000_0001#;
   Get_Module_Handle_Ex_Flag_Unchanged_Refcount : constant := 16#0000_0002#;
   Get_Module_Handle_Ex_Flag_From_Address       : constant := 16#0000_0004#;

--%%   PGET_MODULE_HANDLE_EXA = function(dwFlags: DWORD; lpModuleName: LPCSTR; var phModule: HMODULE): BOOL; stdcall;
--%%   {$EXTERNALSYM PGET_MODULE_HANDLE_EXA}
--%%   PGET_MODULE_HANDLE_EXW = function(dwFlags: DWORD; lpModuleName: LPCWSTR; var phModule: HMODULE): BOOL; stdcall;
--%%   {$EXTERNALSYM PGET_MODULE_HANDLE_EXW}

--%%   {$IFDEF UNICODE}
--%%   PGET_MODULE_HANDLE_EX = PGET_MODULE_HANDLE_EXW;
--%%   {$EXTERNALSYM PGET_MODULE_HANDLE_EX}
--%%   {$ELSE}
--%%   PGET_MODULE_HANDLE_EX = PGET_MODULE_HANDLE_EXA;
--%%   {$EXTERNALSYM PGET_MODULE_HANDLE_EX}
--%%   {$ENDIF UNICODE}

--%% function GetModuleHandleExA(dwFlags: DWORD; lpModuleName: LPCSTR; var phModule: HMODULE): BOOL; stdcall;
--%% {$EXTERNALSYM GetModuleHandleExA}
--%% function GetModuleHandleExW(dwFlags: DWORD; lpModuleName: LPCWSTR; var phModule: HMODULE): BOOL; stdcall;
--%% {$EXTERNALSYM GetModuleHandleExW}
--%% function GetModuleHandleEx(dwFlags: DWORD; lpModuleName: LPCTSTR; var phModule: HMODULE): BOOL; stdcall;
--%% {$EXTERNALSYM GetModuleHandleEx}

--%% function NeedCurrentDirectoryForExePathA(ExeName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM NeedCurrentDirectoryForExePathA}
--%% function NeedCurrentDirectoryForExePathW(ExeName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM NeedCurrentDirectoryForExePathW}
--%% function NeedCurrentDirectoryForExePath(ExeName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM NeedCurrentDirectoryForExePath}

--%% function CreateProcessA(lpApplicationName: LPCSTR; lpCommandLine: LPSTR;
--%%   lpProcessAttributes, lpThreadAttributes: LPSECURITY_ATTRIBUTES;
--%%   bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: LPVOID;
--%%   lpCurrentDirectory: LPCSTR; const lpStartupInfo: STARTUPINFOA;
--%%   var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessA}
--%% function CreateProcessW(lpApplicationName: LPCWSTR; lpCommandLine: LPWSTR;
--%%   lpProcessAttributes, lpThreadAttributes: LPSECURITY_ATTRIBUTES;
--%%   bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: LPVOID;
--%%   lpCurrentDirectory: LPCWSTR; const lpStartupInfo: STARTUPINFOW;
--%%   var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessW}
--%% function CreateProcess(lpApplicationName: LPCTSTR; lpCommandLine: LPTSTR;
--%%   lpProcessAttributes, lpThreadAttributes: LPSECURITY_ATTRIBUTES;
--%%   bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: LPVOID;
--%%   lpCurrentDirectory: LPCTSTR; const lpStartupInfo: STARTUPINFO;
--%%   var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcess}

--%% function SetProcessShutdownParameters(dwLevel, dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetProcessShutdownParameters}

--%% function GetProcessShutdownParameters(var lpdwLevel, lpdwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetProcessShutdownParameters}

--%% function GetProcessVersion(ProcessId: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProcessVersion}

--%% procedure FatalAppExitA(uAction: UINT; lpMessageText: LPCSTR); stdcall;
--%% {$EXTERNALSYM FatalAppExitA}
--%% procedure FatalAppExitW(uAction: UINT; lpMessageText: LPCWSTR); stdcall;
--%% {$EXTERNALSYM FatalAppExitW}
--%% procedure FatalAppExit(uAction: UINT; lpMessageText: LPCTSTR); stdcall;
--%% {$EXTERNALSYM FatalAppExit}

--%% procedure GetStartupInfoA(var lpStartupInfo: STARTUPINFOA); stdcall;
--%% {$EXTERNALSYM GetStartupInfoA}
--%% procedure GetStartupInfoW(var lpStartupInfo: STARTUPINFOW); stdcall;
--%% {$EXTERNALSYM GetStartupInfoW}
--%% procedure GetStartupInfo(var lpStartupInfo: STARTUPINFO); stdcall;
--%% {$EXTERNALSYM GetStartupInfo}

--%% function GetCommandLineA: LPSTR; stdcall;
--%% {$EXTERNALSYM GetCommandLineA}
--%% function GetCommandLineW: LPWSTR; stdcall;
--%% {$EXTERNALSYM GetCommandLineW}
--%% function GetCommandLine: LPTSTR; stdcall;
--%% {$EXTERNALSYM GetCommandLine}

--%% function GetEnvironmentVariableA(lpName: LPCSTR; lpBuffer: LPSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetEnvironmentVariableA}
--%% function GetEnvironmentVariableW(lpName: LPCWSTR; lpBuffer: LPWSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetEnvironmentVariableW}
--%% function GetEnvironmentVariable(lpName: LPCTSTR; lpBuffer: LPTSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetEnvironmentVariable}

--%% function SetEnvironmentVariableA(lpName, lpValue: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetEnvironmentVariableA}
--%% function SetEnvironmentVariableW(lpName, lpValue: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetEnvironmentVariableW}
--%% function SetEnvironmentVariable(lpName, lpValue: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetEnvironmentVariable}

--%% function ExpandEnvironmentStringsA(lpSrc: LPCSTR; lpDst: LPSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM ExpandEnvironmentStringsA}
--%% function ExpandEnvironmentStringsW(lpSrc: LPCWSTR; lpDst: LPWSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM ExpandEnvironmentStringsW}
--%% function ExpandEnvironmentStrings(lpSrc: LPCTSTR; lpDst: LPTSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM ExpandEnvironmentStrings}

--%% function GetFirmwareEnvironmentVariableA(lpName, lpGuid: LPCSTR; pBuffer: PVOID;
--%%   nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetFirmwareEnvironmentVariableA}
--%% function GetFirmwareEnvironmentVariableW(lpName, lpGuid: LPCWSTR; pBuffer: PVOID;
--%%   nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetFirmwareEnvironmentVariableW}
--%% function GetFirmwareEnvironmentVariable(lpName, lpGuid: LPCTSTR; pBuffer: PVOID;
--%%   nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetFirmwareEnvironmentVariable}

--%% function SetFirmwareEnvironmentVariableA(lpName, lpGuid: LPCSTR; pValue: PVOID;
--%%   nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFirmwareEnvironmentVariableA}
--%% function SetFirmwareEnvironmentVariableW(lpName, lpGuid: LPCWSTR; pValue: PVOID;
--%%   nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFirmwareEnvironmentVariableW}
--%% function SetFirmwareEnvironmentVariable(lpName, lpGuid: LPCTSTR; pValue: PVOID;
--%%   nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFirmwareEnvironmentVariable}

--%% procedure OutputDebugStringA(lpOutputString: LPCSTR); stdcall;
--%% {$EXTERNALSYM OutputDebugStringA}
--%% procedure OutputDebugStringW(lpOutputString: LPCWSTR); stdcall;
--%% {$EXTERNALSYM OutputDebugStringW}
--%% procedure OutputDebugString(lpOutputString: LPCTSTR); stdcall;
--%% {$EXTERNALSYM OutputDebugString}

--%% function FindResourceA(hModule: HMODULE; lpName, lpType: LPCSTR): HRSRC; stdcall;
--%% {$EXTERNALSYM FindResourceA}
--%% function FindResourceW(hModule: HMODULE; lpName, lpType: LPCWSTR): HRSRC; stdcall;
--%% {$EXTERNALSYM FindResourceW}
--%% function FindResource(hModule: HMODULE; lpName, lpType: LPCTSTR): HRSRC; stdcall;
--%% {$EXTERNALSYM FindResource}

--%% function FindResourceExA(hModule: HMODULE; lpType, lpName: LPCSTR; wLanguage: WORD): HRSRC; stdcall;
--%% {$EXTERNALSYM FindResourceExA}
--%% function FindResourceExW(hModule: HMODULE; lpType, lpName: LPCWSTR; wLanguage: WORD): HRSRC; stdcall;
--%% {$EXTERNALSYM FindResourceExW}
--%% function FindResourceEx(hModule: HMODULE; lpType, lpName: LPCTSTR; wLanguage: WORD): HRSRC; stdcall;
--%% {$EXTERNALSYM FindResourceEx}

--%%   ENUMRESTYPEPROCA = function(hModule: HMODULE; lpType: LPSTR; lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESTYPEPROCA}
--%%   ENUMRESTYPEPROCW = function(hModule: HMODULE; lpType: LPWSTR; lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESTYPEPROCW}
--%%   ENUMRESTYPEPROC = function(hModule: HMODULE; lpType: LPTSTR; lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESTYPEPROC}
--%%   TEnumResTypeProcA = ENUMRESTYPEPROCA;
--%%   TEnumResTypeProcW = ENUMRESTYPEPROCW;
--%%   TEnumResTypeProc = ENUMRESTYPEPROC;

--%%   ENUMRESNAMEPROCA = function(hModule: HMODULE; lpType: LPCSTR; lpName: LPSTR;
--%%     lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESNAMEPROCA}
--%%   ENUMRESNAMEPROCW = function(hModule: HMODULE; lpType: LPCWSTR; lpName: LPWSTR;
--%%     lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESNAMEPROCW}
--%%   ENUMRESNAMEPROC = function(hModule: HMODULE; lpType: LPCTSTR; lpName: LPTSTR;
--%%     lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESNAMEPROC}
--%%   TEnumResNameProcA = ENUMRESNAMEPROCA;
--%%   TEnumResNameProcW = ENUMRESNAMEPROCW;
--%%   TEnumResNameProc = ENUMRESNAMEPROC;

--%%   ENUMRESLANGPROCA = function(hModule: HMODULE; lpType, lpName: LPCSTR;
--%%     wLanguage: WORD; lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESLANGPROCA}
--%%   ENUMRESLANGPROCW = function(hModule: HMODULE; lpType, lpName: LPCWSTR;
--%%     wLanguage: WORD; lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESLANGPROCW}
--%%   ENUMRESLANGPROC = function(hModule: HMODULE; lpType, lpName: LPCTSTR;
--%%     wLanguage: WORD; lParam: LONG_PTR): BOOL; stdcall;
--%%   {$EXTERNALSYM ENUMRESLANGPROC}
--%%   TEnumResLangProcA = ENUMRESLANGPROCA;
--%%   TEnumResLangProcW = ENUMRESLANGPROCW;
--%%   TEnumResLangProc = ENUMRESLANGPROC;

--%% function EnumResourceTypesA(hModule: HMODULE; lpEnumFunc: ENUMRESTYPEPROCA;
--%%   lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceTypesA}
--%% function EnumResourceTypesW(hModule: HMODULE; lpEnumFunc: ENUMRESTYPEPROCW;
--%%   lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceTypesW}
--%% function EnumResourceTypes(hModule: HMODULE; lpEnumFunc: ENUMRESTYPEPROC;
--%%   lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceTypes}

--%% function EnumResourceNamesA(hModule: HMODULE; lpType: LPCSTR;
--%%   lpEnumFunc: ENUMRESNAMEPROCA; lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceNamesA}
--%% function EnumResourceNamesW(hModule: HMODULE; lpType: LPCWSTR;
--%%   lpEnumFunc: ENUMRESNAMEPROCW; lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceNamesW}
--%% function EnumResourceNames(hModule: HMODULE; lpType: LPCTSTR;
--%%   lpEnumFunc: ENUMRESNAMEPROC; lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceNames}

--%% function EnumResourceLanguagesA(hModule: HMODULE; lpType, lpName: LPCSTR;
--%%   lpEnumFunc: ENUMRESLANGPROCA; lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceLanguagesA}
--%% function EnumResourceLanguagesW(hModule: HMODULE; lpType, lpName: LPCWSTR;
--%%   lpEnumFunc: ENUMRESLANGPROCW; lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceLanguagesW}
--%% function EnumResourceLanguages(hModule: HMODULE; lpType, lpName: LPCTSTR;
--%%   lpEnumFunc: ENUMRESLANGPROC; lParam: LONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM EnumResourceLanguages}

--%% function BeginUpdateResourceA(pFileName: LPCSTR; bDeleteExistingResources: BOOL): HANDLE; stdcall;
--%% {$EXTERNALSYM BeginUpdateResourceA}
--%% function BeginUpdateResourceW(pFileName: LPCWSTR; bDeleteExistingResources: BOOL): HANDLE; stdcall;
--%% {$EXTERNALSYM BeginUpdateResourceW}
--%% function BeginUpdateResource(pFileName: LPCTSTR; bDeleteExistingResources: BOOL): HANDLE; stdcall;
--%% {$EXTERNALSYM BeginUpdateResource}

--%% function UpdateResourceA(hUpdate: HANDLE; lpType, lpName: LPCSTR;
--%%   wLanguage: WORD; lpData: LPVOID; cbData: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM UpdateResourceA}
--%% function UpdateResourceW(hUpdate: HANDLE; lpType, lpName: LPCWSTR;
--%%   wLanguage: WORD; lpData: LPVOID; cbData: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM UpdateResourceW}
--%% function UpdateResource(hUpdate: HANDLE; lpType, lpName: LPCTSTR;
--%%   wLanguage: WORD; lpData: LPVOID; cbData: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM UpdateResource}

--%% function EndUpdateResourceA(hUpdate: HANDLE; fDiscard: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM EndUpdateResourceA}
--%% function EndUpdateResourceW(hUpdate: HANDLE; fDiscard: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM EndUpdateResourceW}
--%% function EndUpdateResource(hUpdate: HANDLE; fDiscard: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM EndUpdateResource}

--%% function GlobalAddAtomA(lpString: LPCSTR): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalAddAtomA}
--%% function GlobalAddAtomW(lpString: LPCWSTR): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalAddAtomW}
--%% function GlobalAddAtom(lpString: LPCTSTR): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalAddAtom}

--%% function GlobalFindAtomA(lpString: LPCSTR): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalFindAtomA}
--%% function GlobalFindAtomW(lpString: LPCWSTR): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalFindAtomW}
--%% function GlobalFindAtom(lpString: LPCTSTR): ATOM; stdcall;
--%% {$EXTERNALSYM GlobalFindAtom}

--%% function GlobalGetAtomNameA(nAtom: ATOM; lpBuffer: LPSTR; nSize: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GlobalGetAtomNameA}
--%% function GlobalGetAtomNameW(nAtom: ATOM; lpBuffer: LPWSTR; nSize: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GlobalGetAtomNameW}
--%% function GlobalGetAtomName(nAtom: ATOM; lpBuffer: LPTSTR; nSize: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GlobalGetAtomName}

--%% function AddAtomA(lpString: LPCSTR): ATOM; stdcall;
--%% {$EXTERNALSYM AddAtomA}
--%% function AddAtomW(lpString: LPCWSTR): ATOM; stdcall;
--%% {$EXTERNALSYM AddAtomW}
--%% function AddAtom(lpString: LPCTSTR): ATOM; stdcall;
--%% {$EXTERNALSYM AddAtom}

--%% function FindAtomA(lpString: LPCSTR): ATOM; stdcall;
--%% {$EXTERNALSYM FindAtomA}
--%% function FindAtomW(lpString: LPCWSTR): ATOM; stdcall;
--%% {$EXTERNALSYM FindAtomW}
--%% function FindAtom(lpString: LPCTSTR): ATOM; stdcall;
--%% {$EXTERNALSYM FindAtom}

--%% function GetAtomNameA(nAtom: ATOM; lpBuffer: LPSTR; nSize: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GetAtomNameA}
--%% function GetAtomNameW(nAtom: ATOM; lpBuffer: LPWSTR; nSize: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GetAtomNameW}
--%% function GetAtomName(nAtom: ATOM; lpBuffer: LPTSTR; nSize: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GetAtomName}

--%% function GetProfileIntA(lpAppName, lpKeyName: LPCSTR; nDefault: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GetProfileIntA}
--%% function GetProfileIntW(lpAppName, lpKeyName: LPCWSTR; nDefault: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GetProfileIntW}
--%% function GetProfileInt(lpAppName, lpKeyName: LPCTSTR; nDefault: Integer): UINT; stdcall;
--%% {$EXTERNALSYM GetProfileInt}

--%% function GetProfileStringA(lpAppName, lpKeyName, lpDefault: LPCSTR;
--%%   lpReturnedString: LPSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProfileStringA}
--%% function GetProfileStringW(lpAppName, lpKeyName, lpDefault: LPCWSTR;
--%%   lpReturnedString: LPWSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProfileStringW}
--%% function GetProfileString(lpAppName, lpKeyName, lpDefault: LPCTSTR;
--%%   lpReturnedString: LPTSTR; nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProfileString}

--%% function WriteProfileStringA(lpAppName, lpKeyName, lpString: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProfileStringA}
--%% function WriteProfileStringW(lpAppName, lpKeyName, lpString: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProfileStringW}
--%% function WriteProfileString(lpAppName, lpKeyName, lpString: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProfileString}

--%% function GetProfileSectionA(lpAppName: LPCSTR; lpReturnedString: LPSTR;
--%%   nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProfileSectionA}
--%% function GetProfileSectionW(lpAppName: LPCWSTR; lpReturnedString: LPWSTR;
--%%   nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProfileSectionW}
--%% function GetProfileSection(lpAppName: LPCTSTR; lpReturnedString: LPTSTR;
--%%   nSize: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetProfileSection}

--%% function WriteProfileSectionA(lpAppName, lpString: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProfileSectionA}
--%% function WriteProfileSectionW(lpAppName, lpString: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProfileSectionW}
--%% function WriteProfileSection(lpAppName, lpString: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WriteProfileSection}

--%% function GetPrivateProfileIntA(lpAppName, lpKeyName: LPCSTR; nDefault: Integer;
--%%   lpFileName: LPCSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileIntA}
--%% function GetPrivateProfileIntW(lpAppName, lpKeyName: LPCWSTR; nDefault: Integer;
--%%   lpFileName: LPCWSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileIntW}
--%% function GetPrivateProfileInt(lpAppName, lpKeyName: LPCTSTR; nDefault: Integer;
--%%   lpFileName: LPCTSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileInt}

--%% function GetPrivateProfileStringA(lpAppName, lpKeyName, lpDefault: LPCSTR;
--%%   lpReturnedString: LPSTR; nSize: DWORD; lpFileName: LPCSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileStringA}
--%% function GetPrivateProfileStringW(lpAppName, lpKeyName, lpDefault: LPCWSTR;
--%%   lpReturnedString: LPWSTR; nSize: DWORD; lpFileName: LPCWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileStringW}
--%% function GetPrivateProfileString(lpAppName, lpKeyName, lpDefault: LPCTSTR;
--%%   lpReturnedString: LPTSTR; nSize: DWORD; lpFileName: LPCTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileString}

--%% function WritePrivateProfileStringA(lpAppName, lpKeyName, lpString,
--%%   lpFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileStringA}
--%% function WritePrivateProfileStringW(lpAppName, lpKeyName, lpString,
--%%   lpFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileStringW}
--%% function WritePrivateProfileString(lpAppName, lpKeyName, lpString,
--%%   lpFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileString}

--%% function GetPrivateProfileSectionA(lpAppName: LPCSTR; lpReturnedString: LPSTR;
--%%   nSize: DWORD; lpFileName: LPCSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileSectionA}
--%% function GetPrivateProfileSectionW(lpAppName: LPCWSTR; lpReturnedString: LPWSTR;
--%%   nSize: DWORD; lpFileName: LPCWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileSectionW}
--%% function GetPrivateProfileSection(lpAppName: LPCTSTR; lpReturnedString: LPTSTR;
--%%   nSize: DWORD; lpFileName: LPCTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileSection}

--%% function WritePrivateProfileSectionA(lpAppName, lpString, lpFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileSectionA}
--%% function WritePrivateProfileSectionW(lpAppName, lpString, lpFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileSectionW}
--%% function WritePrivateProfileSection(lpAppName, lpString, lpFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileSection}

--%% function GetPrivateProfileSectionNamesA(lpszReturnBuffer: LPSTR; nSize: DWORD;
--%%   lpFileName: LPCSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileSectionNamesA}
--%% function GetPrivateProfileSectionNamesW(lpszReturnBuffer: LPWSTR; nSize: DWORD;
--%%   lpFileName: LPCWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileSectionNamesW}
--%% function GetPrivateProfileSectionNames(lpszReturnBuffer: LPTSTR; nSize: DWORD;
--%%   lpFileName: LPCTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileSectionNames}

--%% function GetPrivateProfileStructA(lpszSection, lpszKey: LPCSTR; lpStruct: LPVOID;
--%%   uSizeStruct: UINT; szFile: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileStructA}
--%% function GetPrivateProfileStructW(lpszSection, lpszKey: LPCWSTR; lpStruct: LPVOID;
--%%   uSizeStruct: UINT; szFile: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileStructW}
--%% function GetPrivateProfileStruct(lpszSection, lpszKey: LPCTSTR; lpStruct: LPVOID;
--%%   uSizeStruct: UINT; szFile: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM GetPrivateProfileStruct}

--%% function WritePrivateProfileStructA(lpszSection, lpszKey: LPCSTR; lpStruct: LPVOID;
--%%   uSizeStruct: UINT; szFile: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileStructA}
--%% function WritePrivateProfileStructW(lpszSection, lpszKey: LPCWSTR; lpStruct: LPVOID;
--%%   uSizeStruct: UINT; szFile: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileStructW}
--%% function WritePrivateProfileStruct(lpszSection, lpszKey: LPCTSTR; lpStruct: LPVOID;
--%%   uSizeStruct: UINT; szFile: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM WritePrivateProfileStruct}

--%% function GetDriveTypeA(lpRootPathName: LPCSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetDriveTypeA}
--%% function GetDriveTypeW(lpRootPathName: LPCWSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetDriveTypeW}
--%% function GetDriveType(lpRootPathName: LPCTSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetDriveType}

--%% function GetSystemDirectoryA(lpBuffer: LPSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemDirectoryA}
--%% function GetSystemDirectoryW(lpBuffer: LPWSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemDirectoryW}
--%% function GetSystemDirectory(lpBuffer: LPTSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemDirectory}

--%% function GetTempPathA(nBufferLength: DWORD; lpBuffer: LPSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetTempPathA}
--%% function GetTempPathW(nBufferLength: DWORD; lpBuffer: LPWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetTempPathW}
--%% function GetTempPath(nBufferLength: DWORD; lpBuffer: LPTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetTempPath}

--%% function GetTempFileNameA(lpPathName, lpPrefixString: LPCSTR; uUnique: UINT;
--%%   lpTempFileName: LPSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetTempFileNameA}
--%% function GetTempFileNameW(lpPathName, lpPrefixString: LPCWSTR; uUnique: UINT;
--%%   lpTempFileName: LPWSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetTempFileNameW}
--%% function GetTempFileName(lpPathName, lpPrefixString: LPCTSTR; uUnique: UINT;
--%%   lpTempFileName: LPTSTR): UINT; stdcall;
--%% {$EXTERNALSYM GetTempFileName}

--%% function GetWindowsDirectoryA(lpBuffer: LPSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetWindowsDirectoryA}
--%% function GetWindowsDirectoryW(lpBuffer: LPWSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetWindowsDirectoryW}
--%% function GetWindowsDirectory(lpBuffer: LPTSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetWindowsDirectory}

--%% function GetSystemWindowsDirectoryA(lpBuffer: LPSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemWindowsDirectoryA}
--%% function GetSystemWindowsDirectoryW(lpBuffer: LPWSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemWindowsDirectoryW}
--%% function GetSystemWindowsDirectory(lpBuffer: LPTSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemWindowsDirectory}

--%% function GetSystemWow64DirectoryA(lpBuffer: LPSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemWow64DirectoryA}
--%% function GetSystemWow64DirectoryW(lpBuffer: LPWSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemWow64DirectoryW}
--%% function GetSystemWow64Directory(lpBuffer: LPTSTR; uSize: UINT): UINT; stdcall;
--%% {$EXTERNALSYM GetSystemWow64Directory}

--%% function Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM Wow64EnableWow64FsRedirection}

--
-- for GetProcAddress
--

--%%   PGET_SYSTEM_WOW64_DIRECTORY_A = function(lpBuffer: LPSTR; uSize: UINT): UINT; stdcall;
--%%   {$EXTERNALSYM PGET_SYSTEM_WOW64_DIRECTORY_A}
--%%   PGET_SYSTEM_WOW64_DIRECTORY_W = function(lpBuffer: LPWSTR; uSize: UINT): UINT; stdcall;
--%%   {$EXTERNALSYM PGET_SYSTEM_WOW64_DIRECTORY_W}

--
-- GetProcAddress only accepts GET_SYSTEM_WOW64_DIRECTORY_NAME_A_A,
-- GET_SYSTEM_WOW64_DIRECTORY_NAME_W_A, GET_SYSTEM_WOW64_DIRECTORY_NAME_T_A.
-- The others are if you want to use the strings in some other way.
--

--%%   GET_SYSTEM_WOW64_DIRECTORY_NAME_A_A = 'GetSystemWow64DirectoryA';
--%%   {$EXTERNALSYM GET_SYSTEM_WOW64_DIRECTORY_NAME_A_A}
--%%   GET_SYSTEM_WOW64_DIRECTORY_NAME_A_W = WideString('GetSystemWow64DirectoryA');
--%%   {$EXTERNALSYM GET_SYSTEM_WOW64_DIRECTORY_NAME_A_W}
--%%   GET_SYSTEM_WOW64_DIRECTORY_NAME_A_T = __TEXT('GetSystemWow64DirectoryA');
--%%   {$EXTERNALSYM GET_SYSTEM_WOW64_DIRECTORY_NAME_A_T}
--%%   GET_SYSTEM_WOW64_DIRECTORY_NAME_W_A = 'GetSystemWow64DirectoryW';
--%%   {$EXTERNALSYM GET_SYSTEM_WOW64_DIRECTORY_NAME_W_A}
--%%   GET_SYSTEM_WOW64_DIRECTORY_NAME_W_W = WideString('GetSystemWow64DirectoryW');
--%%   {$EXTERNALSYM GET_SYSTEM_WOW64_DIRECTORY_NAME_W_W}
--%%   GET_SYSTEM_WOW64_DIRECTORY_NAME_W_T = __TEXT('GetSystemWow64DirectoryW');
--%%   {$EXTERNALSYM GET_SYSTEM_WOW64_DIRECTORY_NAME_W_T}

--%%   {$IFDEF UNICODE}
   Get_System_Wow64_Directory_Name_T_A : constant := Get_System_Wow64_Directory_Name_W_A;
   Get_System_Wow64_Directory_Name_T_W : constant := Get_System_Wow64_Directory_Name_W_W;
   Get_System_Wow64_Directory_Name_T_T : constant := Get_System_Wow64_Directory_Name_W_T;
--%%   {$ELSE}
   Get_System_Wow64_Directory_Name_T_A : constant := Get_System_Wow64_Directory_Name_A_A;
   Get_System_Wow64_Directory_Name_T_W : constant := Get_System_Wow64_Directory_Name_A_W;
   Get_System_Wow64_Directory_Name_T_T : constant := Get_System_Wow64_Directory_Name_A_T;
--%%   {$ENDIF UNICODE}

--%% function SetCurrentDirectoryA(lpPathName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetCurrentDirectoryA}
--%% function SetCurrentDirectoryW(lpPathName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetCurrentDirectoryW}
--%% function SetCurrentDirectory(lpPathName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetCurrentDirectory}

--%% function GetCurrentDirectoryA(nBufferLength: DWORD; lpBuffer: LPSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetCurrentDirectoryA}
--%% function GetCurrentDirectoryW(nBufferLength: DWORD; lpBuffer: LPWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetCurrentDirectoryW}
--%% function GetCurrentDirectory(nBufferLength: DWORD; lpBuffer: LPTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetCurrentDirectory}

-- #if _WIN32_WINNT >= 0x0502

--%% function SetDllDirectoryA(lpPathName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetDllDirectoryA}
--%% function SetDllDirectoryW(lpPathName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetDllDirectoryW}
--%% function SetDllDirectory(lpPathName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetDllDirectory}

--%% function GetDllDirectoryA(nBufferLength: DWORD; lpBuffer: LPSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetDllDirectoryA}
--%% function GetDllDirectoryW(nBufferLength: DWORD; lpBuffer: LPWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetDllDirectoryW}
--%% function GetDllDirectory(nBufferLength: DWORD; lpBuffer: LPTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetDllDirectory}

-- #endif // _WIN32_WINNT >= 0x0502

--%% function GetDiskFreeSpaceA(lpRootPathName: LPCSTR; var lpSectorsPerCluster,
--%%   lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetDiskFreeSpaceA}
--%% function GetDiskFreeSpaceW(lpRootPathName: LPCWSTR; var lpSectorsPerCluster,
--%%   lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetDiskFreeSpaceW}
--%% function GetDiskFreeSpace(lpRootPathName: LPCTSTR; var lpSectorsPerCluster,
--%%   lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetDiskFreeSpace}

--%% function GetDiskFreeSpaceExA(lpDirectoryName: LPCSTR; var lpFreeBytesAvailableToCaller,
--%%   lpTotalNumberOfBytes: ULARGE_INTEGER; lpTotalNumberOfFreeBytes: PULARGE_INTEGER): BOOL; stdcall;
--%% {$EXTERNALSYM GetDiskFreeSpaceExA}
--%% function GetDiskFreeSpaceExW(lpDirectoryName: LPCWSTR; var lpFreeBytesAvailableToCaller,
--%%   lpTotalNumberOfBytes: ULARGE_INTEGER; lpTotalNumberOfFreeBytes: PULARGE_INTEGER): BOOL; stdcall;
--%% {$EXTERNALSYM GetDiskFreeSpaceExW}
--%% function GetDiskFreeSpaceEx(lpDirectoryName: LPCTSTR; var lpFreeBytesAvailableToCaller,
--%%   lpTotalNumberOfBytes: ULARGE_INTEGER; lpTotalNumberOfFreeBytes: PULARGE_INTEGER): BOOL; stdcall;
--%% {$EXTERNALSYM GetDiskFreeSpaceEx}

--%% function CreateDirectoryA(lpPathName: LPCSTR; lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateDirectoryA}
--%% function CreateDirectoryW(lpPathName: LPCWSTR; lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateDirectoryW}
--%% function CreateDirectory(lpPathName: LPCTSTR; lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateDirectory}

--%% function CreateDirectoryExA(lpTemplateDirectory: LPCSTR; lpNewDirectory: LPCSTR;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateDirectoryExA}
--%% function CreateDirectoryExW(lpTemplateDirectory: LPCWSTR; lpNewDirectory: LPCWSTR;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateDirectoryExW}
--%% function CreateDirectoryEx(lpTemplateDirectory: LPCTSTR; lpNewDirectory: LPCTSTR;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateDirectoryEx}

--%% function RemoveDirectoryA(lpPathName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM RemoveDirectoryA}
--%% function RemoveDirectoryW(lpPathName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM RemoveDirectoryW}
--%% function RemoveDirectory(lpPathName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM RemoveDirectory}

--%% function GetFullPathNameA(lpFileName: LPCSTR; nBufferLength: DWORD;
--%%   lpBuffer: LPSTR; var lpFilePart: LPSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetFullPathNameA}
--%% function GetFullPathNameW(lpFileName: LPCWSTR; nBufferLength: DWORD;
--%%   lpBuffer: LPWSTR; var lpFilePart: LPWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetFullPathNameA}
--%% function GetFullPathName(lpFileName: LPCTSTR; nBufferLength: DWORD;
--%%   lpBuffer: LPTSTR; var lpFilePart: LPTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetFullPathName}

   Ddd_Raw_Target_Path       : constant := 16#0000_0001#;
   Ddd_Remove_Definition     : constant := 16#0000_0002#;
   Ddd_Exact_Match_On_Remove : constant := 16#0000_0004#;
   Ddd_No_Broadcast_System   : constant := 16#0000_0008#;
   Ddd_LUID_Broadcast_Drive  : constant := 16#0000_0010#;

--%% function DefineDosDeviceA(dwFlags: DWORD; lpDeviceName, lpTargetPath: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DefineDosDeviceA}
--%% function DefineDosDeviceW(dwFlags: DWORD; lpDeviceName, lpTargetPath: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DefineDosDeviceW}
--%% function DefineDosDevice(dwFlags: DWORD; lpDeviceName, lpTargetPath: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DefineDosDevice}

--%% function QueryDosDeviceA(lpDeviceName, lpTargetPath: LPSTR; ucchMax: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM QueryDosDeviceA}
--%% function QueryDosDeviceW(lpDeviceName, lpTargetPath: LPWSTR; ucchMax: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM QueryDosDeviceW}
--%% function QueryDosDevice(lpDeviceName, lpTargetPath: LPTSTR; ucchMax: DWORD): DWORD; stdcall;
--%% {$EXTERNALSYM QueryDosDevice}

--%% function CreateFileA(lpFileName: LPCSTR; dwDesiredAccess, dwShareMode: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; dwCreationDisposition: DWORD;
--%%   dwFlagsAndAttributes: DWORD; hTemplateFile: HANDLE): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateFileA}
--%% function CreateFileW(lpFileName: LPCWSTR; dwDesiredAccess, dwShareMode: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; dwCreationDisposition: DWORD;
--%%   dwFlagsAndAttributes: DWORD; hTemplateFile: HANDLE): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateFileW}
--%% function CreateFile(lpFileName: LPCTSTR; dwDesiredAccess, dwShareMode: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES; dwCreationDisposition: DWORD;
--%%   dwFlagsAndAttributes: DWORD; hTemplateFile: HANDLE): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateFile}

--%% function ReOpenFile(hOriginalFile: HANDLE; dwDesiredAccess, dwShareMode, dwFlagsAndAttributes: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM ReOpenFile}

--%% function SetFileAttributesA(lpFileName: LPCSTR; dwFileAttributes: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileAttributesA}
--%% function SetFileAttributesW(lpFileName: LPCWSTR; dwFileAttributes: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileAttributesW}
--%% function SetFileAttributes(lpFileName: LPCTSTR; dwFileAttributes: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileAttributes}

--%% function GetFileAttributesA(lpFileName: LPCSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetFileAttributesA}
--%% function GetFileAttributesW(lpFileName: LPCWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetFileAttributesW}
--%% function GetFileAttributes(lpFileName: LPCTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM GetFileAttributes}

--%%   _GET_FILEEX_INFO_LEVELS = (GetFileExInfoStandard, GetFileExMaxInfoLevel);
--%%   {$EXTERNALSYM _GET_FILEEX_INFO_LEVELS}
--%%   GET_FILEEX_INFO_LEVELS = _GET_FILEEX_INFO_LEVELS;
--%%   {$EXTERNALSYM GET_FILEEX_INFO_LEVELS}
--%%   TGetFileExInfoLevels = GET_FILEEX_INFO_LEVELS;

--%% function GetFileAttributesExA(lpFileName: LPCSTR;
--%%   fInfoLevelId: GET_FILEEX_INFO_LEVELS; lpFileInformation: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileAttributesExA}
--%% function GetFileAttributesExW(lpFileName: LPCWSTR;
--%%   fInfoLevelId: GET_FILEEX_INFO_LEVELS; lpFileInformation: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileAttributesExW}
--%% function GetFileAttributesEx(lpFileName: LPCTSTR;
--%%   fInfoLevelId: GET_FILEEX_INFO_LEVELS; lpFileInformation: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileAttributesEx}

--%% function GetCompressedFileSizeA(lpFileName: LPCSTR; lpFileSizeHigh: LPDWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetCompressedFileSizeA}
--%% function GetCompressedFileSizeW(lpFileName: LPCWSTR; lpFileSizeHigh: LPDWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetCompressedFileSizeW}
--%% function GetCompressedFileSize(lpFileName: LPCTSTR; lpFileSizeHigh: LPDWORD): DWORD; stdcall;
--%% {$EXTERNALSYM GetCompressedFileSize}

--%% function DeleteFileA(lpFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteFileA}
--%% function DeleteFileW(lpFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteFileW}
--%% function DeleteFile(lpFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteFile}

--%% (* todo
--%% WINBASEAPI
--%% BOOL
--%% WINAPI
--%% CheckNameLegalDOS8Dot3A(
--%%     IN LPCSTR lpName,
--%%     OUT LPSTR lpOemName OPTIONAL,
--%%     IN DWORD OemNameSize OPTIONAL,
--%%     OUT PBOOL pbNameContainsSpaces OPTIONAL,
--%%     OUT PBOOL pbNameLegal
--%%     );
--%% WINBASEAPI
--%% BOOL
--%% WINAPI
--%% CheckNameLegalDOS8Dot3W(
--%%     IN LPCWSTR lpName,
--%%     OUT LPSTR lpOemName OPTIONAL,
--%%     IN DWORD OemNameSize OPTIONAL,
--%%     OUT PBOOL pbNameContainsSpaces OPTIONAL,
--%%     OUT PBOOL pbNameLegal
--%%     );
--%% #ifdef UNICODE
--%% #define CheckNameLegalDOS8Dot3  CheckNameLegalDOS8Dot3W
--%% #else
--%% #define CheckNameLegalDOS8Dot3  CheckNameLegalDOS8Dot3A
--%% #endif // !UNICODE
--%% *)

--%%   _FINDEX_INFO_LEVELS = (FindExInfoStandard, FindExInfoMaxInfoLevel);
--%%   {$EXTERNALSYM _FINDEX_INFO_LEVELS}
--%%   FINDEX_INFO_LEVELS = _FINDEX_INFO_LEVELS;
--%%   {$EXTERNALSYM FINDEX_INFO_LEVELS}
--%%   TFindExInfoLevels = FINDEX_INFO_LEVELS;

--%%   _FINDEX_SEARCH_OPS = (
--%%     FindExSearchNameMatch,
--%%     FindExSearchLimitToDirectories,
--%%     FindExSearchLimitToDevices,
--%%     FindExSearchMaxSearchOp);
--%%   {$EXTERNALSYM _FINDEX_SEARCH_OPS}
--%%   FINDEX_SEARCH_OPS = _FINDEX_SEARCH_OPS;
--%%   {$EXTERNALSYM FINDEX_SEARCH_OPS}
--%%   TFindExSearchOps = FINDEX_SEARCH_OPS;

   Find_First_Ex_Case_Sensitive : constant := 16#0000_0001#;

--%% function FindFirstFileExA(lpFileName: LPCSTR; fInfoLevelId: FINDEX_INFO_LEVELS;
--%%   lpFindFileData: LPVOID; fSearchOp: FINDEX_SEARCH_OPS; lpSearchFilter: LPVOID;
--%%   dwAdditionalFlags: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstFileExA}
--%% function FindFirstFileExW(lpFileName: LPCWSTR; fInfoLevelId: FINDEX_INFO_LEVELS;
--%%   lpFindFileData: LPVOID; fSearchOp: FINDEX_SEARCH_OPS; lpSearchFilter: LPVOID;
--%%   dwAdditionalFlags: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstFileExW}
--%% function FindFirstFileEx(lpFileName: LPCTSTR; fInfoLevelId: FINDEX_INFO_LEVELS;
--%%   lpFindFileData: LPVOID; fSearchOp: FINDEX_SEARCH_OPS; lpSearchFilter: LPVOID;
--%%   dwAdditionalFlags: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstFileEx}

--%% function FindFirstFileA(lpFileName: LPCSTR; var lpFindFileData: WIN32_FIND_DATAA): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstFileA}
--%% function FindFirstFileW(lpFileName: LPCWSTR; var lpFindFileData: WIN32_FIND_DATAW): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstFileW}
--%% function FindFirstFile(lpFileName: LPCTSTR; var lpFindFileData: WIN32_FIND_DATA): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstFile}

--%% function FindNextFileA(hFindFile: HANDLE; var FindFileData: WIN32_FIND_DATAA): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextFileA}
--%% function FindNextFileW(hFindFile: HANDLE; var lpFindFileData: WIN32_FIND_DATAW): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextFileW}
--%% function FindNextFile(hFindFile: HANDLE; var lpFindFileData: WIN32_FIND_DATA): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextFile}

--%% function SearchPathA(lpPath, lpFileName, lpExtension: LPCSTR; nBufferLength: DWORD;
--%%   lpBuffer: LPSTR; var lpFilePart: LPSTR): DWORD; stdcall;
--%% {$EXTERNALSYM SearchPathA}
--%% function SearchPathW(lpPath, lpFileName, lpExtension: LPCWSTR; nBufferLength: DWORD;
--%%   lpBuffer: LPWSTR; var lpFilePart: LPWSTR): DWORD; stdcall;
--%% {$EXTERNALSYM SearchPathW}
--%% function SearchPath(lpPath, lpFileName, lpExtension: LPCTSTR; nBufferLength: DWORD;
--%%   lpBuffer: LPTSTR; var lpFilePart: LPTSTR): DWORD; stdcall;
--%% {$EXTERNALSYM SearchPath}

--%% function CopyFileA(lpExistingFileName, lpNewFileName: LPCSTR; bFailIfExists: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM CopyFileA}
--%% function CopyFileW(lpExistingFileName, lpNewFileName: LPCWSTR; bFailIfExists: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM CopyFileW}
--%% function CopyFile(lpExistingFileName, lpNewFileName: LPCTSTR; bFailIfExists: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM CopyFile}

--%%   LPPROGRESS_ROUTINE = function(
--%%     TotalFileSize: LARGE_INTEGER;
--%%     TotalBytesTransferred: LARGE_INTEGER;
--%%     StreamSize: LARGE_INTEGER;
--%%     StreamBytesTransferred: LARGE_INTEGER;
--%%     dwStreamNumber: DWORD;
--%%     dwCallbackReason: DWORD;
--%%     hSourceFile: HANDLE;
--%%     hDestinationFile: HANDLE;
--%%     lpData: LPVOID): DWORD; stdcall;
--%%   {$EXTERNALSYM LPPROGRESS_ROUTINE}
--%%   TProgressRoutine = LPPROGRESS_ROUTINE;

--%% function CopyFileExA(lpExistingFileName, lpNewFileName: LPCSTR;
--%%   lpProgressRoutine: LPPROGRESS_ROUTINE; lpData: LPVOID; var pbCancel: BOOL;
--%%   dwCopyFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CopyFileExA}
--%% function CopyFileExW(lpExistingFileName, lpNewFileName: LPCWSTR;
--%%   lpProgressRoutine: LPPROGRESS_ROUTINE; lpData: LPVOID; var pbCancel: BOOL;
--%%   dwCopyFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CopyFileExW}
--%% function CopyFileEx(lpExistingFileName, lpNewFileName: LPCTSTR;
--%%   lpProgressRoutine: LPPROGRESS_ROUTINE; lpData: LPVOID; var pbCancel: BOOL;
--%%   dwCopyFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CopyFileEx}

--%% function MoveFileA(lpExistingFileName, lpNewFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileA}
--%% function MoveFileW(lpExistingFileName, lpNewFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileW}
--%% function MoveFile(lpExistingFileName, lpNewFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFile}

--%% function MoveFileExA(lpExistingFileName, lpNewFileName: LPCSTR; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileExA}
--%% function MoveFileExW(lpExistingFileName, lpNewFileName: LPCWSTR; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileExW}
--%% function MoveFileEx(lpExistingFileName, lpNewFileName: LPCTSTR; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileEx}

--%% function MoveFileWithProgressA(lpExistingFileName, lpNewFileName: LPCSTR;
--%%   lpProgressRoutine: LPPROGRESS_ROUTINE; lpData: LPVOID; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileWithProgressA}
--%% function MoveFileWithProgressW(lpExistingFileName, lpNewFileName: LPCWSTR;
--%%   lpProgressRoutine: LPPROGRESS_ROUTINE; lpData: LPVOID; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileWithProgressW}
--%% function MoveFileWithProgress(lpExistingFileName, lpNewFileName: LPCTSTR;
--%%   lpProgressRoutine: LPPROGRESS_ROUTINE; lpData: LPVOID; dwFlags: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MoveFileWithProgress}

   Movefile_Replace_Existing      : constant := 16#0000_0001#;
   Movefile_Copy_Allowed          : constant := 16#0000_0002#;
   Movefile_Delay_Until_Reboot    : constant := 16#0000_0004#;
   Movefile_Write_Through         : constant := 16#0000_0008#;
   Movefile_Create_Hardlink       : constant := 16#0000_0010#;
   Movefile_Fail_If_Not_Trackable : constant := 16#0000_0020#;

--%% function ReplaceFileA(lpReplacedFileName, lpReplacementFileName,
--%%   lpBackupFileName: LPCSTR; dwReplaceFlags: DWORD; lpExclude: LPVOID;
--%%   lpReserved: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM ReplaceFileA}
--%% function ReplaceFileW(lpReplacedFileName, lpReplacementFileName,
--%%   lpBackupFileName: LPCWSTR; dwReplaceFlags: DWORD; lpExclude: LPVOID;
--%%   lpReserved: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM ReplaceFileW}
--%% function ReplaceFile(lpReplacedFileName, lpReplacementFileName,
--%%   lpBackupFileName: LPCTSTR; dwReplaceFlags: DWORD; lpExclude: LPVOID;
--%%   lpReserved: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM ReplaceFile}

--
-- API call to create hard links.
--

--%% function CreateHardLinkA(lpFileName, lpExistingFileName: LPCSTR;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateHardLinkA}
--%% function CreateHardLinkW(lpFileName, lpExistingFileName: LPCWSTR;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateHardLinkW}
--%% function CreateHardLink(lpFileName, lpExistingFileName: LPCTSTR;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): BOOL; stdcall;
--%% {$EXTERNALSYM CreateHardLink}

-- #if (_WIN32_WINNT >= 0x0501)

--
-- API call to enumerate for streams within a file
--

--%%   _STREAM_INFO_LEVELS = (FindStreamInfoStandard, FindStreamInfoMaxInfoLevel);
--%%   {$EXTERNALSYM _STREAM_INFO_LEVELS}
--%%   STREAM_INFO_LEVELS = _STREAM_INFO_LEVELS;
--%%   {$EXTERNALSYM STREAM_INFO_LEVELS}
--%%   TStreamInfoLevels = STREAM_INFO_LEVELS;

--%%   _WIN32_FIND_STREAM_DATA = record
--%%     StreamSize: LARGE_INTEGER;
--%%     cStreamName: array [0..MAX_PATH + 35] of WCHAR;
--%%   end;
--%%   {$EXTERNALSYM _WIN32_FIND_STREAM_DATA}
   subtype Win32Find_Stream_Data_Type is _WIN32_FIND_STREAM_DATA;
   type Win32Find_Stream_Data_Ptr is access all _WIN32_FIND_STREAM_DATA;
   type Win32Find_Stream_Data_CPtr is access constant _WIN32_FIND_STREAM_DATA;

--%% function FindFirstStreamW(lpFileName: LPCWSTR; InfoLevel: STREAM_INFO_LEVELS; lpFindStreamData: LPVOID; dwFlags: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstStreamW}

--%% function FindNextStreamW(hFindStream: HANDLE; lpFindStreamData: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextStreamW}

-- #endif // (_WIN32_WINNT >= 0x0500)

--%% function CreateNamedPipeA(lpName: LPCSTR; dwOpenMode, dwPipeMode, nMaxInstances,
--%%   nOutBufferSize, nInBufferSize, nDefaultTimeOut: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateNamedPipeA}
--%% function CreateNamedPipeW(lpName: LPCWSTR; dwOpenMode, dwPipeMode, nMaxInstances,
--%%   nOutBufferSize, nInBufferSize, nDefaultTimeOut: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateNamedPipeW}
--%% function CreateNamedPipe(lpName: LPCTSTR; dwOpenMode, dwPipeMode, nMaxInstances,
--%%   nOutBufferSize, nInBufferSize, nDefaultTimeOut: DWORD;
--%%   lpSecurityAttributes: LPSECURITY_ATTRIBUTES): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateNamedPipe}

--%% function GetNamedPipeHandleStateA(hNamedPipe: HANDLE; lpState, lpCurInstances,
--%%   lpMaxCollectionCount, lpCollectDataTimeout: LPDWORD; lpUserName: LPSTR;
--%%   nMaxUserNameSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetNamedPipeHandleStateA}
--%% function GetNamedPipeHandleStateW(hNamedPipe: HANDLE; lpState, lpCurInstances,
--%%   lpMaxCollectionCount, lpCollectDataTimeout: LPDWORD; lpUserName: LPWSTR;
--%%   nMaxUserNameSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetNamedPipeHandleStateW}
--%% function GetNamedPipeHandleState(hNamedPipe: HANDLE; lpState, lpCurInstances,
--%%   lpMaxCollectionCount, lpCollectDataTimeout: LPDWORD; lpUserName: LPTSTR;
--%%   nMaxUserNameSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetNamedPipeHandleState}

--%% function CallNamedPipeA(lpNamedPipeName: LPCSTR; lpInBuffer: LPVOID;
--%%   nInBufferSize: DWORD; lpOutBuffer: LPVOID; nOutBufferSize: DWORD;
--%%   var lpBytesRead: DWORD; nTimeOut: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CallNamedPipeA}
--%% function CallNamedPipeW(lpNamedPipeName: LPCWSTR; lpInBuffer: LPVOID;
--%%   nInBufferSize: DWORD; lpOutBuffer: LPVOID; nOutBufferSize: DWORD;
--%%   var lpBytesRead: DWORD; nTimeOut: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CallNamedPipeW}
--%% function CallNamedPipe(lpNamedPipeName: LPCTSTR; lpInBuffer: LPVOID;
--%%   nInBufferSize: DWORD; lpOutBuffer: LPVOID; nOutBufferSize: DWORD;
--%%   var lpBytesRead: DWORD; nTimeOut: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CallNamedPipe}

--%% function WaitNamedPipeA(lpNamedPipeName: LPCSTR; nTimeOut: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM WaitNamedPipeA}
--%% function WaitNamedPipeW(lpNamedPipeName: LPCWSTR; nTimeOut: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM WaitNamedPipeW}
--%% function WaitNamedPipe(lpNamedPipeName: LPCTSTR; nTimeOut: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM WaitNamedPipe}

--%% function SetVolumeLabelA(lpRootPathName, lpVolumeName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetVolumeLabelA}
--%% function SetVolumeLabelW(lpRootPathName, lpVolumeName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetVolumeLabelW}
--%% function SetVolumeLabel(lpRootPathName, lpVolumeName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetVolumeLabel}

--%% procedure SetFileApisToOEM; stdcall;
--%% {$EXTERNALSYM SetFileApisToOEM}

--%% procedure SetFileApisToANSI; stdcall;
--%% {$EXTERNALSYM SetFileApisToANSI}

--%% function AreFileApisANSI: BOOL; stdcall;
--%% {$EXTERNALSYM AreFileApisANSI}

--%% function GetVolumeInformationA(lpRootPathName: LPCSTR; lpVolumeNameBuffer: LPSTR;
--%%   nVolumeNameSize: DWORD; lpVolumeSerialNumber: LPDWORD;
--%%   var lpMaximumComponentLength, lpFileSystemFlags: DWORD;
--%%   lpFileSystemNameBuffer: LPSTR; nFileSystemNameSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumeInformationA}
--%% function GetVolumeInformationW(lpRootPathName: LPCWSTR; lpVolumeNameBuffer: LPWSTR;
--%%   nVolumeNameSize: DWORD; lpVolumeSerialNumber: LPDWORD;
--%%   var lpMaximumComponentLength, lpFileSystemFlags: DWORD;
--%%   lpFileSystemNameBuffer: LPWSTR; nFileSystemNameSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumeInformationW}
--%% function GetVolumeInformation(lpRootPathName: LPCTSTR; lpVolumeNameBuffer: LPTSTR;
--%%   nVolumeNameSize: DWORD; lpVolumeSerialNumber: LPDWORD;
--%%   var lpMaximumComponentLength, lpFileSystemFlags: DWORD;
--%%   lpFileSystemNameBuffer: LPTSTR; nFileSystemNameSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumeInformation}

--%% function CancelIo(hFile: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CancelIo}

--
-- Event logging APIs
--

--%% function ClearEventLogA(hEventLog: HANDLE; lpBackupFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM ClearEventLogA}
--%% function ClearEventLogW(hEventLog: HANDLE; lpBackupFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM ClearEventLogW}
--%% function ClearEventLog(hEventLog: HANDLE; lpBackupFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM ClearEventLogA}

--%% function BackupEventLogA(hEventLog: HANDLE; lpBackupFileName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM BackupEventLogA}
--%% function BackupEventLogW(hEventLog: HANDLE; lpBackupFileName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM BackupEventLogW}
--%% function BackupEventLog(hEventLog: HANDLE; lpBackupFileName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM BackupEventLogA}

--%% function CloseEventLog(hEventLog: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CloseEventLog}

--%% function DeregisterEventSource(hEventLog: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DeregisterEventSource}

--%% function NotifyChangeEventLog(hEventLog, hEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM NotifyChangeEventLog}

--%% function GetNumberOfEventLogRecords(hEventLog: HANDLE; var NumberOfRecords: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetNumberOfEventLogRecords}

--%% function GetOldestEventLogRecord(hEventLog: HANDLE; var OldestRecord: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetOldestEventLogRecord}

--%% function OpenEventLogA(lpUNCServerName, lpSourceName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenEventLogA}
--%% function OpenEventLogW(lpUNCServerName, lpSourceName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenEventLogW}
--%% function OpenEventLog(lpUNCServerName, lpSourceName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenEventLogA}

--%% function RegisterEventSourceA(lpUNCServerName, lpSourceName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM RegisterEventSourceA}
--%% function RegisterEventSourceW(lpUNCServerName, lpSourceName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM RegisterEventSourceW}
--%% function RegisterEventSource(lpUNCServerName, lpSourceName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM RegisterEventSourceA}

--%% function OpenBackupEventLogA(lpUNCServerName, lpFileName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenBackupEventLogA}
--%% function OpenBackupEventLogW(lpUNCServerName, lpFileName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenBackupEventLogW}
--%% function OpenBackupEventLog(lpUNCServerName, lpFileName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenBackupEventLogA}

--%% function ReadEventLogA(hEventLog: HANDLE; dwReadFlags, dwRecordOffset: DWORD;
--%%   lpBuffer: LPVOID; nNumberOfBytesToRead: DWORD;
--%%   var pnBytesRead, pnMinNumberOfBytesNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM ReadEventLogA}
--%% function ReadEventLogW(hEventLog: HANDLE; dwReadFlags, dwRecordOffset: DWORD;
--%%   lpBuffer: LPVOID; nNumberOfBytesToRead: DWORD;
--%%   var pnBytesRead, pnMinNumberOfBytesNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM ReadEventLogW}
--%% function ReadEventLog(hEventLog: HANDLE; dwReadFlags, dwRecordOffset: DWORD;
--%%   lpBuffer: LPVOID; nNumberOfBytesToRead: DWORD;
--%%   var pnBytesRead, pnMinNumberOfBytesNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM ReadEventLog}

--%% function ReportEventA(hEventLog: HANDLE; wType, wCategory: WORD; dwEventID: DWORD;
--%%   lpUserSid: PSID; wNumStrings: WORD; dwDataSize: DWORD; lpStrings: LPCSTR;
--%%   lpRawData: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM ReportEventA}
--%% function ReportEventW(hEventLog: HANDLE; wType, wCategory: WORD; dwEventID: DWORD;
--%%   lpUserSid: PSID; wNumStrings: WORD; dwDataSize: DWORD; lpStrings: LPCWSTR;
--%%   lpRawData: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM ReportEventW}
--%% function ReportEvent(hEventLog: HANDLE; wType, wCategory: WORD; dwEventID: DWORD;
--%%   lpUserSid: PSID; wNumStrings: WORD; dwDataSize: DWORD; lpStrings: LPCTSTR;
--%%   lpRawData: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM ReportEvent}

   Eventlog_Full_Info : constant := 0;

   type Eventlog_Full_Information_Type;
   type Eventlog_Full_Information_Ptr is access all Eventlog_Full_Information_Type;
   type Eventlog_Full_Information_CPtr is access constant Eventlog_Full_Information_Type;
   type Eventlog_Full_Information_Type is record
      Full : Unsigned_32;
   end record;

--%% function GetEventLogInformation(hEventLog: HANDLE; dwInfoLevel: DWORD;
--%%   lpBuffer: LPVOID; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetEventLogInformation}

--
-- Security APIs
--

--%% function DuplicateToken(ExistingTokenHandle: HANDLE;
--%%   ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL; DuplicateTokenHandle: PHANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DuplicateToken}

--%% function GetKernelObjectSecurity(Handle: HANDLE;
--%%   RequestedInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR; nLength: DWORD;
--%%   var lpnLengthNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetKernelObjectSecurity}

--%% function ImpersonateNamedPipeClient(hNamedPipe: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ImpersonateNamedPipeClient}

--%% function ImpersonateSelf(ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL): BOOL; stdcall;
--%% {$EXTERNALSYM ImpersonateSelf}

--%% function RevertToSelf : BOOL; stdcall;
--%% {$EXTERNALSYM RevertToSelf}

--%% function SetThreadToken(Thread: PHANDLE; Token: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetThreadToken}

--%% function AccessCheck(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   ClientToken: HANDLE; DesiredAccess: DWORD; const GenericMapping: GENERIC_MAPPING;
--%%   var PrivilegeSet: PRIVILEGE_SET; var PrivilegeSetLength,
--%%   GrantedAccess: DWORD; var AccessStatus: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheck}

--%% function AccessCheckByType(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   PrincipalSelfSid: PSID; ClientToken: HANDLE; DesiredAccess: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; var PrivilegeSet: PRIVILEGE_SET;
--%%   var PrivilegeSetLength, GrantedAccess: DWORD; var AccessStatus: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByType}

--%% function AccessCheckByTypeResultList(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   PrincipalSelfSid: PSID; ClientToken: HANDLE; DesiredAccess: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; var PrivilegeSet: PRIVILEGE_SET;
--%%   var PrivilegeSetLength, GrantedAccessList: DWORD;
--%%   var AccessStatusList: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultList}

--%% function OpenProcessToken(ProcessHandle: HANDLE; DesiredAccess: DWORD;
--%%   var TokenHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM OpenProcessToken}

--%% function OpenThreadToken(ThreadHandle: HANDLE; DesiredAccess: DWORD;
--%%   OpenAsSelf: BOOL; var TokenHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM OpenThreadToken}

--%% function GetTokenInformation(TokenHandle: HANDLE;
--%%   TokenInformationClass: TOKEN_INFORMATION_CLASS; TokenInformation: LPVOID;
--%%   TokenInformationLength: DWORD; var ReturnLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetTokenInformation}

--%% function SetTokenInformation(TokenHandle: HANDLE;
--%%   TokenInformationClass: TOKEN_INFORMATION_CLASS; TokenInformation: LPVOID;
--%%   TokenInformationLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetTokenInformation}

--%% function AdjustTokenPrivileges(TokenHandle: HANDLE; DisableAllPrivileges: BOOL;
--%%   NewState: PTOKEN_PRIVILEGES; BufferLength: DWORD;
--%%   PreviousState: PTOKEN_PRIVILEGES; ReturnLength: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM AdjustTokenPrivileges}

--%% function AdjustTokenGroups(TokenHandle: HANDLE; ResetToDefault: BOOL;
--%%   NewState: PTOKEN_GROUPS; BufferLength: DWORD; PreviousState: PTOKEN_GROUPS;
--%%   ReturnLength: PDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM AdjustTokenGroups}

--%% function PrivilegeCheck(ClientToken: HANDLE;
--%%   RequiredPrivileges: PPRIVILEGE_SET; var pfResult: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM PrivilegeCheck}

--%% function AccessCheckAndAuditAlarmA(SubsystemName: LPCSTR; HandleId: LPVOID;
--%%   ObjectTypeName, ObjectName: LPSTR; SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   DesiredAccess: DWORD; const GenericMapping: GENERIC_MAPPING;
--%%   ObjectCreation: BOOL; var GrantedAccess: DWORD;
--%%   var AccessStatus, pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckAndAuditAlarmA}
--%% function AccessCheckAndAuditAlarmW(SubsystemName: LPCWSTR; HandleId: LPVOID;
--%%   ObjectTypeName, ObjectName: LPWSTR; SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   DesiredAccess: DWORD; const GenericMapping: GENERIC_MAPPING;
--%%   ObjectCreation: BOOL; var GrantedAccess: DWORD;
--%%   var AccessStatus, pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckAndAuditAlarmW}
--%% function AccessCheckAndAuditAlarm(SubsystemName: LPCTSTR; HandleId: LPVOID;
--%%   ObjectTypeName, ObjectName: LPTSTR; SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   DesiredAccess: DWORD; const GenericMapping: GENERIC_MAPPING;
--%%   ObjectCreation: BOOL; var GrantedAccess: DWORD;
--%%   var AccessStatus, pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckAndAuditAlarmA}

--%% function AccessCheckByTypeAndAuditAlarmA(SubsystemName: LPCSTR; HandleId: LPVOID;
--%%   ObjectTypeName: LPCSTR; ObjectName: LPCSTR; SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE;
--%%   Flags: DWORD; ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   GenericMapping: PGENERIC_MAPPING; ObjectCreation: BOOL; GrantedAccess: LPDWORD;
--%%   AccessStatus: LPBOOL; pfGenerateOnClose: LPBOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeAndAuditAlarmA}
--%% function AccessCheckByTypeAndAuditAlarmW(SubsystemName: LPCWSTR; HandleId: LPVOID;
--%% ObjectTypeName: LPCWSTR; ObjectName: LPCWSTR; SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%% PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE;
--%% Flags: DWORD; ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%% GenericMapping: PGENERIC_MAPPING; ObjectCreation: BOOL; GrantedAccess: LPDWORD;
--%% AccessStatus: LPBOOL; pfGenerateOnClose: LPBOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeAndAuditAlarmW}
--%% function AccessCheckByTypeAndAuditAlarm(SubsystemName: LPCTSTR; HandleId: LPVOID;
--%%   ObjectTypeName, ObjectName: LPCTSTR; SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE;
--%%   Flags: DWORD; ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeAndAuditAlarmA}

--%% function AccessCheckByTypeResultListAndAuditAlarmA(SubsystemName: LPCSTR;
--%%   HandleId: LPVOID; ObjectTypeName, ObjectName: LPCSTR;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR; PrincipalSelfSid: PSID;
--%%   DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess, AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultListAndAuditAlarmA}
--%% function AccessCheckByTypeResultListAndAuditAlarmW(SubsystemName: LPCWSTR;
--%%   HandleId: LPVOID; ObjectTypeName, ObjectName: LPCWSTR;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR; PrincipalSelfSid: PSID;
--%%   DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess, AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultListAndAuditAlarmW}
--%% function AccessCheckByTypeResultListAndAuditAlarm(SubsystemName: LPCTSTR;
--%%   HandleId: LPVOID; ObjectTypeName, ObjectName: LPCTSTR;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR; PrincipalSelfSid: PSID;
--%%   DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess, AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultListAndAuditAlarmA}

--%% function AccessCheckByTypeResultListAndAuditAlarmByHandleA(SubsystemName: LPCSTR;
--%%   HandleId: LPVOID; ClientToken: HANDLE; ObjectTypeName, ObjectName: LPCSTR;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR; PrincipalSelfSid: PSID;
--%%   DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: GENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess, AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultListAndAuditAlarmByHandleA}
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandleW(SubsystemName: LPCWSTR;
--%%   HandleId: LPVOID; ClientToken: HANDLE; ObjectTypeName, ObjectName: LPCWSTR;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR; PrincipalSelfSid: PSID;
--%%   DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: PGENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess, AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultListAndAuditAlarmByHandleW}
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandle(SubsystemName: LPCTSTR;
--%%   HandleId: LPVOID; ClientToken: HANDLE; ObjectTypeName, ObjectName: LPCTSTR;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR; PrincipalSelfSid: PSID;
--%%   DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD;
--%%   ObjectTypeList: POBJECT_TYPE_LIST; ObjectTypeListLength: DWORD;
--%%   const GenericMapping: PGENERIC_MAPPING; ObjectCreation: BOOL;
--%%   var GrantedAccess, AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AccessCheckByTypeResultListAndAuditAlarmByHandle}

--%% function ObjectOpenAuditAlarmA(SubsystemName: LPCSTR; HandleId: LPVOID;
--%%   ObjectTypeName: LPSTR; ObjectName: LPSTR; pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   ClientToken: HANDLE; DesiredAccess, GrantedAccess: DWORD;
--%%   Privileges: PPRIVILEGE_SET; ObjectCreation: BOOL; AccessGranted: BOOL;
--%%   var GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectOpenAuditAlarmA}
--%% function ObjectOpenAuditAlarmW(SubsystemName: LPCWSTR; HandleId: LPVOID;
--%%   ObjectTypeName, ObjectName: LPWSTR; pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   ClientToken: HANDLE; DesiredAccess: DWORD; GrantedAccess: DWORD;
--%%   Privileges: PPRIVILEGE_SET; ObjectCreation: BOOL; AccessGranted: BOOL;
--%%   var GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectOpenAuditAlarmW}
--%% function ObjectOpenAuditAlarm(SubsystemName: LPCTSTR; HandleId: LPVOID;
--%%   ObjectTypeName: LPTSTR; ObjectName: LPTSTR; pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   ClientToken: HANDLE; DesiredAccess: DWORD; GrantedAccess: DWORD;
--%%   Privileges: PPRIVILEGE_SET; ObjectCreation: BOOL; AccessGranted: BOOL;
--%%   var GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectOpenAuditAlarmA}

--%% function ObjectPrivilegeAuditAlarmA(SubsystemName: LPCSTR; HandleId: LPVOID;
--%%   ClientToken: HANDLE; DesiredAccess: DWORD; const Privileges: PRIVILEGE_SET;
--%%   AccessGranted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectPrivilegeAuditAlarmA}
--%% function ObjectPrivilegeAuditAlarmW(SubsystemName: LPCWSTR; HandleId: LPVOID;
--%%   ClientToken: HANDLE; DesiredAccess: DWORD; const Privileges: PRIVILEGE_SET;
--%%   AccessGranted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectPrivilegeAuditAlarmW}
--%% function ObjectPrivilegeAuditAlarm(SubsystemName: LPCTSTR; HandleId: LPVOID;
--%%   ClientToken: HANDLE; DesiredAccess: DWORD; const Privileges: PRIVILEGE_SET;
--%%   AccessGranted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectPrivilegeAuditAlarmA}

--%% function ObjectCloseAuditAlarmA(SubsystemName: LPCSTR; HandleId: LPVOID;
--%%   GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectCloseAuditAlarmA}
--%% function ObjectCloseAuditAlarmW(SubsystemName: LPCWSTR; HandleId: LPVOID;
--%%   GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectCloseAuditAlarmW}
--%% function ObjectCloseAuditAlarm(SubsystemName: LPCTSTR; HandleId: LPVOID;
--%%   GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectCloseAuditAlarmA}

--%% function ObjectDeleteAuditAlarmA(SubsystemName: LPCSTR; HandleId: LPVOID;
--%%   GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectDeleteAuditAlarmA}
--%% function ObjectDeleteAuditAlarmW(SubsystemName: LPCWSTR; HandleId: LPVOID;
--%%   GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectDeleteAuditAlarmW}
--%% function ObjectDeleteAuditAlarm(SubsystemName: LPCTSTR; HandleId: LPVOID;
--%%   GenerateOnClose: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM ObjectDeleteAuditAlarmA}

--%% function PrivilegedServiceAuditAlarmA(SubsystemName, ServiceName: LPCSTR;
--%%   ClientToken: HANDLE; const Privileges: PRIVILEGE_SET; AccessGranted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM PrivilegedServiceAuditAlarmA}
--%% function PrivilegedServiceAuditAlarmW(SubsystemName, ServiceName: LPCWSTR;
--%%   ClientToken: HANDLE; const Privileges: PRIVILEGE_SET; AccessGranted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM PrivilegedServiceAuditAlarmW}
--%% function PrivilegedServiceAuditAlarm(SubsystemName, ServiceName: LPCTSTR;
--%%   ClientToken: HANDLE; const Privileges: PRIVILEGE_SET; AccessGranted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM PrivilegedServiceAuditAlarmA}

--%% function IsWellKnownSid(pSid: PSID; WellKnownSidType: WELL_KNOWN_SID_TYPE): BOOL; stdcall;
--%% {$EXTERNALSYM IsWellKnownSid}

--%% function CreateWellKnownSid(WellKnownSidType: WELL_KNOWN_SID_TYPE; DomainSid: PSID;
--%%   pSid: PSID; var cbSid: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM CreateWellKnownSid}

--%% function EqualDomainSid(pSid1, pSid2: PSID; pfEqual: PBOOL): BOOL; stdcall;
--%% {$EXTERNALSYM EqualDomainSid}

--%% function GetWindowsAccountDomainSid(pSid, ppDomainSid: PSID; var cbSid: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetWindowsAccountDomainSid}

--%% function IsValidSid(pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM IsValidSid}

--%% function EqualSid(pSid1, pSid2: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM EqualSid}

--%% function EqualPrefixSid(pSid1, pSid2: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM EqualPrefixSid}

--%% function GetSidLengthRequired(nSubAuthorityCount: UCHAR): DWORD; stdcall;
--%% {$EXTERNALSYM GetSidLengthRequired}

--%% function AllocateAndInitializeSid(pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY;
--%%   SubAuthorityCount: BYTE; nSubAuthority0, nSubAuthority1, nSubAuthority2,
--%%   nSubAuthority3, nSubAuthority4, nSubAuthority5, nSubAuthority6,
--%%   nSubAuthority7: DWORD; var pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AllocateAndInitializeSid}

--%% function FreeSid(pSid: PSID): PVOID; stdcall;
--%% {$EXTERNALSYM FreeSid}

--%% function InitializeSid(Sid: PSID; pIdentifierAuthority: PSID_IDENTIFIER_AUTHORITY;
--%%   nSubAuthorityCount: BYTE): BOOL; stdcall;
--%% {$EXTERNALSYM InitializeSid}

--%% function GetSidIdentifierAuthority(pSid: PSID): PSID_IDENTIFIER_AUTHORITY; stdcall;
--%% {$EXTERNALSYM GetSidIdentifierAuthority}

--%% function GetSidSubAuthority(pSid: PSID; nSubAuthority: DWORD): PDWORD; stdcall;
--%% {$EXTERNALSYM GetSidSubAuthority}

--%% function GetSidSubAuthorityCount(pSid: PSID): PUCHAR; stdcall;
--%% {$EXTERNALSYM GetSidSubAuthorityCount}

--%% function GetLengthSid(pSid: PSID): DWORD; stdcall;
--%% {$EXTERNALSYM GetLengthSid}

--%% function CopySid(nDestinationSidLength: DWORD; pDestinationSid: PSID;
--%%   pSourceSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM CopySid}

--%% function AreAllAccessesGranted(GrantedAccess, DesiredAccess: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM AreAllAccessesGranted}

--%% function AreAnyAccessesGranted(GrantedAccess, DesiredAccess: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM AreAnyAccessesGranted}

--%% procedure MapGenericMask(var AccessMask: DWORD; var GenericMapping: GENERIC_MAPPING); stdcall;
--%% {$EXTERNALSYM MapGenericMask}

--%% function IsValidAcl(pAcl: PACL): BOOL; stdcall;
--%% {$EXTERNALSYM IsValidAcl}

--%% function InitializeAcl(pAcl: PACL; nAclLength: DWORD; dwAclRevision: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM InitializeAcl}

--%% function GetAclInformation(pAcl: PACL; pAclInformation: LPVOID;
--%%   nAclInformationLength: DWORD; dwAclInformationClass: ACL_INFORMATION_CLASS): BOOL; stdcall;
--%% {$EXTERNALSYM GetAclInformation}

--%% function SetAclInformation(pAcl: PACL; pAclInformation: LPVOID;
--%%   nAclInformationLength: DWORD; dwAclInformationClass: ACL_INFORMATION_CLASS): BOOL; stdcall;
--%% {$EXTERNALSYM SetAclInformation}

--%% function AddAce(pAcl: PACL; dwAceRevision: DWORD; dwStartingAceIndex: DWORD;
--%%   pAceList: LPVOID; nAceListLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM AddAce}

--%% function DeleteAce(pAcl: PACL; dwAceIndex: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteAce}

--%% function GetAce(pAcl: PACL; dwAceIndex: DWORD; var pAce: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM GetAce}

--%% function AddAccessAllowedAce(pAcl: PACL; dwAceRevision, AccessMask: DWORD; pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AddAccessAllowedAce}

--%% function AddAccessAllowedAceEx(pAcl: PACL; dwAceRevision, AceFlags,
--%%   AccessMask: DWORD; pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AddAccessAllowedAceEx}

--%% function AddAccessDeniedAce(pAcl: PACL; dwAceRevision, AccessMask: DWORD; pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AddAccessDeniedAce}

--%% function AddAccessDeniedAceEx(pAcl: PACL; dwAceRevision, AceFlags: DWORD;
--%%   AccessMask: DWORD; pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AddAccessDeniedAceEx}

--%% function AddAuditAccessAce(pAcl: PACL; dwAceRevision, dwAccessMask: DWORD;
--%%   pSid: PSID; bAuditSuccess, bAuditFailure: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AddAuditAccessAce}

--%% function AddAuditAccessAceEx(pAcl: PACL; dwAceRevision, AceFlags,
--%%   dwAccessMask: DWORD; pSid: PSID; bAuditSuccess, bAuditFailure: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AddAuditAccessAceEx}

--%% function AddAccessAllowedObjectAce(pAcl: PACL; dwAceRevision, AceFlags,
--%%   AccessMask: DWORD; ObjectTypeGuid, InheritedObjectTypeGuid: LPGUID; pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AddAccessAllowedObjectAce}

--%% function AddAccessDeniedObjectAce(pAcl: PACL; dwAceRevision, AceFlags,
--%%   AccessMask: DWORD; ObjectTypeGuid, InheritedObjectTypeGuid: LPGUID; pSid: PSID): BOOL; stdcall;
--%% {$EXTERNALSYM AddAccessDeniedObjectAce}

--%% function AddAuditAccessObjectAce(pAcl: PACL; dwAceRevision, AceFlags,
--%%   AccessMask: DWORD; ObjectTypeGuid, InheritedObjectTypeGuid: LPGUID; pSid: PSID;
--%%   bAuditSuccess, bAuditFailure: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM AddAuditAccessObjectAce}

--%% function FindFirstFreeAce(pAcl: PACL; var pAce: LPVOID): BOOL; stdcall;
--%% {$EXTERNALSYM FindFirstFreeAce}

--%% function InitializeSecurityDescriptor(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   dwRevision: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM InitializeSecurityDescriptor}

--%% function IsValidSecurityDescriptor(pSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
--%% {$EXTERNALSYM IsValidSecurityDescriptor}

--%% function GetSecurityDescriptorLength(pSecurityDescriptor: PSECURITY_DESCRIPTOR): DWORD; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorLength}

--%% function GetSecurityDescriptorControl(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var pControl: SECURITY_DESCRIPTOR_CONTROL; var lpdwRevision: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorControl}

--%% function SetSecurityDescriptorControl(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   ControlBitsOfInterest, ControlBitsToSet: SECURITY_DESCRIPTOR_CONTROL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSecurityDescriptorControl}

--%% function SetSecurityDescriptorDacl(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   bDaclPresent: BOOL; pDacl: PACL; bDaclDefaulted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSecurityDescriptorDacl}

--%% function GetSecurityDescriptorDacl(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var lpbDaclPresent: BOOL; var pDacl: PACL; var lpbDaclDefaulted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorDacl}

--%% function SetSecurityDescriptorSacl(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   bSaclPresent: BOOL; pSacl: PACL; bSaclDefaulted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSecurityDescriptorSacl}

--%% function GetSecurityDescriptorSacl(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var lpbSaclPresent: BOOL; var pSacl: PACL; var lpbSaclDefaulted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorSacl}

--%% function SetSecurityDescriptorOwner(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   pOwner: PSID; bOwnerDefaulted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSecurityDescriptorOwner}

--%% function GetSecurityDescriptorOwner(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var pOwner: PSID; lpbOwnerDefaulted: PBOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorOwner}

--%% function SetSecurityDescriptorGroup(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   pGroup: PSID; bGroupDefaulted: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSecurityDescriptorGroup}

--%% function GetSecurityDescriptorGroup(pSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var pGroup: PSID; lpbGroupDefaulted: PBOOL): BOOL; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorGroup}

--%% function SetSecurityDescriptorRMControl(SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   RMControl: PUCHAR): DWORD; stdcall;
--%% {$EXTERNALSYM SetSecurityDescriptorRMControl}

--%% function GetSecurityDescriptorRMControl(SecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var RMControl: UCHAR): DWORD; stdcall;
--%% {$EXTERNALSYM GetSecurityDescriptorRMControl}

--%% function CreatePrivateObjectSecurity(ParentDescriptor, CreatorDescriptor: PSECURITY_DESCRIPTOR;
--%%   var NewDescriptor: PSECURITY_DESCRIPTOR; IsDirectoryObject: BOOL; Token: HANDLE;
--%%   const GenericMapping: GENERIC_MAPPING): BOOL; stdcall;
--%% {$EXTERNALSYM CreatePrivateObjectSecurity}

--%% function ConvertToAutoInheritPrivateObjectSecurity(ParentDescriptor,
--%%   CurrentSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var NewSecurityDescriptor: PSECURITY_DESCRIPTOR; ObjectType: LPGUID;
--%%   IsDirectoryObject: ByteBool; const GenericMapping: GENERIC_MAPPING): BOOL; stdcall;
--%% {$EXTERNALSYM ConvertToAutoInheritPrivateObjectSecurity}

--%% function CreatePrivateObjectSecurityEx(ParentDescriptor,
--%%   CreatorDescriptor: PSECURITY_DESCRIPTOR;
--%%   var NewDescriptor: PSECURITY_DESCRIPTOR; ObjectType: LPGUID;
--%%   IsContainerObject: BOOL; AutoInheritFlags: ULONG; Token: HANDLE;
--%%   const GenericMapping: GENERIC_MAPPING): BOOL; stdcall;
--%% {$EXTERNALSYM CreatePrivateObjectSecurityEx}

--%% function SetPrivateObjectSecurity(SecurityInformation: SECURITY_INFORMATION;
--%%   ModificationDescriptor: PSECURITY_DESCRIPTOR;
--%%   var ObjectsSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   const GenericMapping: GENERIC_MAPPING; Token: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetPrivateObjectSecurity}

--%% function SetPrivateObjectSecurityEx(SecurityInformation: SECURITY_INFORMATION;
--%%   ModificationDescriptor: PSECURITY_DESCRIPTOR;
--%%   var ObjectsSecurityDescriptor: PSECURITY_DESCRIPTOR; AutoInheritFlags: ULONG;
--%%   const GenericMapping: GENERIC_MAPPING; Token: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM SetPrivateObjectSecurityEx}

--%% function GetPrivateObjectSecurity(ObjectDescriptor: PSECURITY_DESCRIPTOR;
--%%   SecurityInformation: SECURITY_INFORMATION;
--%%   ResultantDescriptor: PSECURITY_DESCRIPTOR; DescriptorLength: DWORD;
--%%   var ReturnLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetPrivateObjectSecurity}

--%% function DestroyPrivateObjectSecurity(var ObjectDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
--%% {$EXTERNALSYM DestroyPrivateObjectSecurity}

--%% function MakeSelfRelativeSD(pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR; var lpdwBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MakeSelfRelativeSD}

--%% function MakeAbsoluteSD(pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   pAbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var lpdwAbsoluteSecurityDescriptorSize: DWORD; pDacl: PACL;
--%%   var lpdwDaclSize: DWORD; pSacl: PACL; var lpdwSaclSize: DWORD; pOwner: PSID;
--%%   var lpdwOwnerSize: DWORD; pPrimaryGroup: PSID; var lpdwPrimaryGroupSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MakeAbsoluteSD}

--%% function MakeAbsoluteSD2(pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR;
--%%   var lpdwBufferSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM MakeAbsoluteSD2}

--%% function SetFileSecurityA(lpFileName: LPCSTR; SecurityInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileSecurityA}
--%% function SetFileSecurityW(lpFileName: LPCWSTR; SecurityInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileSecurityW}
--%% function SetFileSecurity(lpFileName: LPCTSTR; SecurityInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
--%% {$EXTERNALSYM SetFileSecurityA}

--%% function GetFileSecurityA(lpFileName: LPCSTR; RequestedInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR; nLength: DWORD;
--%%   var lpnLengthNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileSecurityA}
--%% function GetFileSecurityW(lpFileName: LPCWSTR; RequestedInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR; nLength: DWORD;
--%%   var lpnLengthNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileSecurityW}
--%% function GetFileSecurity(lpFileName: LPCTSTR; RequestedInformation: SECURITY_INFORMATION;
--%%   pSecurityDescriptor: PSECURITY_DESCRIPTOR; nLength: DWORD;
--%%   var lpnLengthNeeded: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetFileSecurityA}

--%% function SetKernelObjectSecurity(Handle: HANDLE; SecurityInformation: SECURITY_INFORMATION;
--%%   SecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
--%% {$EXTERNALSYM SetKernelObjectSecurity}

--%% function FindFirstChangeNotificationA(lpPathName: LPCSTR; bWatchSubtree: Cardinal;
--%%   dwNotifyFilter: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstChangeNotificationA}
--%% function FindFirstChangeNotificationW(lpPathName: LPCWSTR; bWatchSubtree: Cardinal;
--%%   dwNotifyFilter: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstChangeNotificationW}
--%% function FindFirstChangeNotification(lpPathName: LPCTSTR; bWatchSubtree: Cardinal;
--%%   dwNotifyFilter: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstChangeNotification}

--%% function FindNextChangeNotification(hChangeHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextChangeNotification}

--%% function FindCloseChangeNotification(hChangeHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM FindCloseChangeNotification}

--%% function ReadDirectoryChangesW(hDirectory: HANDLE; lpBuffer: LPVOID;
--%%   nBufferLength: DWORD; bWatchSubtree: BOOL; dwNotifyFilter: DWORD;
--%%   lpBytesReturned: LPDWORD; lpOverlapped: LPOVERLAPPED;
--%%   lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE): BOOL; stdcall;
--%% {$EXTERNALSYM ReadDirectoryChangesW}

--%% function VirtualLock(lpAddress: LPVOID; dwSize: SIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM VirtualLock}

--%% function VirtualUnlock(lpAddress: LPVOID; dwSize: SIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM VirtualUnlock}

--%% function MapViewOfFileEx(hFileMappingObject: HANDLE; dwDesiredAccess: DWORD;
--%%   dwFileOffsetHigh: DWORD; dwFileOffsetLow: DWORD; dwNumberOfBytesToMap: SIZE_T;
--%%   lpBaseAddress: LPVOID): LPVOID; stdcall;
--%% {$EXTERNALSYM MapViewOfFileEx}

--%% function SetPriorityClass(hProcess: HANDLE; dwPriorityClass: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetPriorityClass}

--%% function GetPriorityClass(hProcess: HANDLE): DWORD; stdcall;
--%% {$EXTERNALSYM GetPriorityClass}

--%% function IsBadReadPtr(lp: LPVOID; ucb: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadReadPtr}

--%% function IsBadWritePtr(lp: LPVOID; ucb: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadWritePtr}

--%% function IsBadHugeReadPtr(lp: LPVOID; ucb: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadHugeReadPtr}

--%% function IsBadHugeWritePtr(lp: LPVOID; ucb: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadHugeWritePtr}

--%% function IsBadCodePtr(lpfn: FARPROC): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadCodePtr}

--%% function IsBadStringPtrA(lpsz: LPCSTR; ucchMax: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadStringPtrA}
--%% function IsBadStringPtrW(lpsz: LPCWSTR; ucchMax: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadStringPtrW}
--%% function IsBadStringPtr(lpsz: LPCTSTR; ucchMax: UINT_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM IsBadStringPtr}

--%% function LookupAccountSidA(lpSystemName: LPCSTR; Sid: PSID; Name: LPSTR;
--%%   var cchName: DWORD; ReferencedDomainName: LPSTR; var cchReferencedDomainName: DWORD;
--%%   var peUse: SID_NAME_USE): BOOL; stdcall;
--%% {$EXTERNALSYM LookupAccountSidA}
--%% function LookupAccountSidW(lpSystemName: LPCWSTR; Sid: PSID; Name: LPWSTR;
--%%   var cchName: DWORD; ReferencedDomainName: LPWSTR; var cchReferencedDomainName: DWORD;
--%%   var peUse: SID_NAME_USE): BOOL; stdcall;
--%% {$EXTERNALSYM LookupAccountSidW}
--%% function LookupAccountSid(lpSystemName: LPCTSTR; Sid: PSID; Name: LPTSTR;
--%%   var cchName: DWORD; ReferencedDomainName: LPTSTR; var cchReferencedDomainName: DWORD;
--%%   var peUse: SID_NAME_USE): BOOL; stdcall;
--%% {$EXTERNALSYM LookupAccountSid}

--%% function LookupAccountNameA(lpSystemName, lpAccountName: LPCSTR; Sid: PSID;
--%%   var cbSid: DWORD; ReferencedDomainName: LPSTR; var cchReferencedDomainName: DWORD;
--%%   var peUse: SID_NAME_USE): BOOL; stdcall;
--%% {$EXTERNALSYM LookupAccountNameA}
--%% function LookupAccountNameW(lpSystemName, lpAccountName: LPCWSTR; Sid: PSID;
--%%   var cbSid: DWORD; ReferencedDomainName: LPWSTR; var cchReferencedDomainName: DWORD;
--%%   var peUse: SID_NAME_USE): BOOL; stdcall;
--%% {$EXTERNALSYM LookupAccountNameW}
--%% function LookupAccountName(lpSystemName: LPCTSTR; lpAccountName: LPCTSTR; Sid: PSID;
--%%   var cbSid: DWORD; ReferencedDomainName: LPTSTR; var cchReferencedDomainName: DWORD;
--%%   var peUse: SID_NAME_USE): BOOL; stdcall;
--%% {$EXTERNALSYM LookupAccountName}

--%% function LookupPrivilegeValueA(lpSystemName, lpName: LPCSTR; var lpLuid: LUID): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeValueA}
--%% function LookupPrivilegeValueW(lpSystemName, lpName: LPCWSTR; var lpLuid: LUID): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeValueW}
--%% function LookupPrivilegeValue(lpSystemName, lpName: LPCTSTR; var lpLuid: LUID): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeValue}

--%% function LookupPrivilegeNameA(lpSystemName: LPCSTR; const lpLuid: LUID;
--%%   lpName: LPSTR; var cbName: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeNameA}
--%% function LookupPrivilegeNameW(lpSystemName: LPCWSTR; const lpLuid: LUID;
--%%   lpName: LPWSTR; var cbName: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeNameW}
--%% function LookupPrivilegeName(lpSystemName: LPCTSTR; const lpLuid: LUID;
--%%   lpName: LPTSTR; var cbName: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeName}

--%% function LookupPrivilegeDisplayNameA(lpSystemName, lpName: LPCSTR;
--%%   lpDisplayName: LPSTR; var cbDisplayName, lpLanguageId: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeDisplayNameA}
--%% function LookupPrivilegeDisplayNameW(lpSystemName, lpName: LPCWSTR;
--%%   lpDisplayName: LPWSTR; var cbDisplayName, lpLanguageId: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeDisplayNameW}
--%% function LookupPrivilegeDisplayName(lpSystemName, lpName: LPCTSTR;
--%%   lpDisplayName: LPTSTR; var cbDisplayName, lpLanguageId: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM LookupPrivilegeDisplayName}

--%% function AllocateLocallyUniqueId(var Luid: LUID): BOOL; stdcall;
--%% {$EXTERNALSYM AllocateLocallyUniqueId}

--%% function BuildCommDCBA(lpDef: LPCSTR; var lpDCB: DCB): BOOL; stdcall;
--%% {$EXTERNALSYM BuildCommDCBA}
--%% function BuildCommDCBW(lpDef: LPCWSTR; var lpDCB: DCB): BOOL; stdcall;
--%% {$EXTERNALSYM BuildCommDCBW}
--%% function BuildCommDCB(lpDef: LPCTSTR; var lpDCB: DCB): BOOL; stdcall;
--%% {$EXTERNALSYM BuildCommDCB}

--%% function BuildCommDCBAndTimeoutsA(lpDef: LPCSTR; var lpDCB: DCB;
--%%   var lpCommTimeouts: COMMTIMEOUTS): BOOL; stdcall;
--%% {$EXTERNALSYM BuildCommDCBAndTimeoutsA}
--%% function BuildCommDCBAndTimeoutsW(lpDef: LPCWSTR; var lpDCB: DCB;
--%%   var lpCommTimeouts: COMMTIMEOUTS): BOOL; stdcall;
--%% {$EXTERNALSYM BuildCommDCBAndTimeoutsW}
--%% function BuildCommDCBAndTimeouts(lpDef: LPCTSTR; var lpDCB: DCB;
--%%   var lpCommTimeouts: COMMTIMEOUTS): BOOL; stdcall;
--%% {$EXTERNALSYM BuildCommDCBAndTimeouts}

--%% function CommConfigDialogA(lpszName: LPCSTR; hWnd: HWND; var lpCC: COMMCONFIG): BOOL; stdcall;
--%% {$EXTERNALSYM CommConfigDialogA}
--%% function CommConfigDialogW(lpszName: LPCWSTR; hWnd: HWND; var lpCC: COMMCONFIG): BOOL; stdcall;
--%% {$EXTERNALSYM CommConfigDialogW}
--%% function CommConfigDialog(lpszName: LPCTSTR; hWnd: HWND; var lpCC: COMMCONFIG): BOOL; stdcall;
--%% {$EXTERNALSYM CommConfigDialog}

--%% function GetDefaultCommConfigA(lpszName: LPCSTR; var lpCC: COMMCONFIG;
--%%   var lpdwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetDefaultCommConfigA}
--%% function GetDefaultCommConfigW(lpszName: LPCWSTR; var lpCC: COMMCONFIG;
--%%   var lpdwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetDefaultCommConfigW}
--%% function GetDefaultCommConfig(lpszName: LPCTSTR; var lpCC: COMMCONFIG;
--%%   var lpdwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetDefaultCommConfig}

--%% function SetDefaultCommConfigA(lpszName: LPCSTR; const lpCC: COMMCONFIG;
--%%   dwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetDefaultCommConfigA}
--%% function SetDefaultCommConfigW(lpszName: LPCWSTR; const lpCC: COMMCONFIG;
--%%   dwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetDefaultCommConfigW}
--%% function SetDefaultCommConfig(lpszName: LPCTSTR; const lpCC: COMMCONFIG;
--%%   dwSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetDefaultCommConfig}

   Max_Computername_Length : constant := 15;

--%% function GetComputerNameA(lpBuffer: LPSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetComputerNameA}
--%% function GetComputerNameW(lpBuffer: LPWSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetComputerNameW}
--%% function GetComputerName(lpBuffer: LPTSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetComputerName}

--%% function SetComputerNameA(lpComputerName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetComputerNameA}
--%% function SetComputerNameW(lpComputerName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetComputerNameW}
--%% function SetComputerName(lpComputerName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetComputerName}

--%%   _COMPUTER_NAME_FORMAT = (
--%%     ComputerNameNetBIOS,
--%%     ComputerNameDnsHostname,
--%%     ComputerNameDnsDomain,
--%%     ComputerNameDnsFullyQualified,
--%%     ComputerNamePhysicalNetBIOS,
--%%     ComputerNamePhysicalDnsHostname,
--%%     ComputerNamePhysicalDnsDomain,
--%%     ComputerNamePhysicalDnsFullyQualified,
--%%     ComputerNameMax);
--%%   {$EXTERNALSYM _COMPUTER_NAME_FORMAT}
--%%   COMPUTER_NAME_FORMAT = _COMPUTER_NAME_FORMAT;
--%%   {$EXTERNALSYM COMPUTER_NAME_FORMAT}
--%%   TComputerNameFormat = COMPUTER_NAME_FORMAT;

--%% function GetComputerNameExA(NameType: COMPUTER_NAME_FORMAT; lpBuffer: LPSTR;
--%%   var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetComputerNameExA}
--%% function GetComputerNameExW(NameType: COMPUTER_NAME_FORMAT; lpBuffer: LPWSTR;
--%%   var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetComputerNameExW}
--%% function GetComputerNameEx(NameType: COMPUTER_NAME_FORMAT; lpBuffer: LPTSTR;
--%%   var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetComputerNameEx}

--%% function SetComputerNameExA(NameType: COMPUTER_NAME_FORMAT; lpBuffer: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetComputerNameExA}
--%% function SetComputerNameExW(NameType: COMPUTER_NAME_FORMAT; lpBuffer: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetComputerNameExW}
--%% function SetComputerNameEx(NameType: COMPUTER_NAME_FORMAT; lpBuffer: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetComputerNameEx}

--%% function DnsHostnameToComputerNameA(Hostname, ComputerName: LPSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DnsHostnameToComputerNameA}
--%% function DnsHostnameToComputerNameW(Hostname, ComputerName: LPWSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DnsHostnameToComputerNameW}
--%% function DnsHostnameToComputerName(Hostname, ComputerName: LPTSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM DnsHostnameToComputerName}

--%% function GetUserNameA(lpBuffer: LPSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetUserNameA}
--%% function GetUserNameW(lpBuffer: LPWSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetUserNameW}
--%% function GetUserName(lpBuffer: LPTSTR; var nSize: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetUserName}

--
-- Logon Support APIs
--

   Logon32_Logon_Interactive       : constant := 2;
   Logon32_Logon_Network           : constant := 3;
   Logon32_Logon_Batch             : constant := 4;
   Logon32_Logon_Service           : constant := 5;
   Logon32_Logon_Unlock            : constant := 7;
   Logon32_Logon_Network_Cleartext : constant := 8;
   Logon32_Logon_New_Credentials   : constant := 9;

   Logon32_Provider_Default : constant := 0;
   Logon32_Provider_Winnt35 : constant := 1;
   Logon32_Provider_Winnt40 : constant := 2;
   Logon32_Provider_Winnt50 : constant := 3;

--%% function LogonUserA(lpszUsername, lpszDomain, lpszPassword: LPCSTR;
--%%   dwLogonType, dwLogonProvider: DWORD; var phToken: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM LogonUserA}
--%% function LogonUserW(lpszUsername, lpszDomain, lpszPassword: LPCWSTR;
--%%   dwLogonType, dwLogonProvider: DWORD; var phToken: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM LogonUserW}
--%% function LogonUser(lpszUsername, lpszDomain, lpszPassword: LPCTSTR;
--%%   dwLogonType, dwLogonProvider: DWORD; var phToken: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM LogonUser}

--%% function LogonUserExA(lpszUsername, lpszDomain, lpszPassword: LPCSTR;
--%%   dwLogonType, dwLogonProvider: DWORD; var phToken: HANDLE; ppLogonSid: PPSID;
--%%   ppProfileBuffer: PPVOID; pdwProfileLength: LPDWORD; pQuotaLimits: PQUOTA_LIMITS): BOOL; stdcall;
--%% {$EXTERNALSYM LogonUserExA}
--%% function LogonUserExW(lpszUsername, lpszDomain, lpszPassword: LPCWSTR;
--%%   dwLogonType, dwLogonProvider: DWORD; var phToken: HANDLE; ppLogonSid: PPSID;
--%%   ppProfileBuffer: PPVOID; pdwProfileLength: LPDWORD; pQuotaLimits: PQUOTA_LIMITS): BOOL; stdcall;
--%% {$EXTERNALSYM LogonUserExW}
--%% function LogonUserEx(lpszUsername, lpszDomain, lpszPassword: LPCTSTR;
--%%   dwLogonType, dwLogonProvider: DWORD; var phToken: HANDLE; ppLogonSid: PPSID;
--%%   ppProfileBuffer: PPVOID; pdwProfileLength: LPDWORD; pQuotaLimits: PQUOTA_LIMITS): BOOL; stdcall;
--%% {$EXTERNALSYM LogonUserEx}

--%% function ImpersonateLoggedOnUser(hToken: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ImpersonateLoggedOnUser}

--%% function CreateProcessAsUserA(hToken: HANDLE; lpApplicationName: LPCSTR;
--%%   lpCommandLine: LPSTR; lpProcessAttributes: LPSECURITY_ATTRIBUTES;
--%%   lpThreadAttributes: LPSECURITY_ATTRIBUTES; bInheritHandles: BOOL;
--%%   dwCreationFlags: DWORD; lpEnvironment: LPVOID; lpCurrentDirectory: LPCSTR;
--%%   const lpStartupInfo: STARTUPINFOA; var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessAsUserA}
--%% function CreateProcessAsUserW(hToken: HANDLE; lpApplicationName: LPCWSTR;
--%%   lpCommandLine: LPWSTR; lpProcessAttributes: LPSECURITY_ATTRIBUTES;
--%%   lpThreadAttributes: LPSECURITY_ATTRIBUTES; bInheritHandles: BOOL;
--%%   dwCreationFlags: DWORD; lpEnvironment: LPVOID; lpCurrentDirectory: LPCWSTR;
--%%   const lpStartupInfo: STARTUPINFOW; var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessAsUserW}
--%% function CreateProcessAsUser(hToken: HANDLE; lpApplicationName: LPCTSTR;
--%%   lpCommandLine: LPTSTR; lpProcessAttributes: LPSECURITY_ATTRIBUTES;
--%%   lpThreadAttributes: LPSECURITY_ATTRIBUTES; bInheritHandles: BOOL;
--%%   dwCreationFlags: DWORD; lpEnvironment: LPVOID; lpCurrentDirectory: LPCTSTR;
--%%   const lpStartupInfo: STARTUPINFO; var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessAsUser}

--
-- LogonFlags
--

   Logon_With_Profile         : constant := 16#0000_0001#;
   Logon_Netcredentials_Only  : constant := 16#0000_0002#;
   Logon_Zero_Password_Buffer : constant := 16#8000_0000#;

--%% function CreateProcessWithLogonW(lpUsername, lpDomain, lpPassword: LPCWSTR;
--%%   dwLogonFlags: DWORD; lpApplicationName: LPCWSTR; lpCommandLine: LPWSTR;
--%%   dwCreationFlags: DWORD; lpEnvironment: LPVOID; lpCurrentDirectory: LPCWSTR;
--%%   const lpStartupInfo: STARTUPINFOW; var lpProcessInformation: PROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessWithLogonW}

--%% function CreateProcessWithTokenW(hToken: HANDLE; dwLogonFlags: DWORD; lpApplicationName: LPCWSTR; lpCommandLine: LPWSTR;
--%%   dwCreationFlags: DWORD; lpEnvironment: LPVOID; lpCurrentDirectory: LPCWSTR; lpStartupInfo: LPSTARTUPINFOW;
--%%   lpProcessInformation: LPPROCESS_INFORMATION): BOOL; stdcall;
--%% {$EXTERNALSYM CreateProcessWithTokenW}

--%% function ImpersonateAnonymousToken(ThreadHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ImpersonateAnonymousToken}

--%% function DuplicateTokenEx(hExistingToken: HANDLE; dwDesiredAccess: DWORD;
--%%   lpTokenAttributes: LPSECURITY_ATTRIBUTES; ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL;
--%%   TokenType: TOKEN_TYPE; var phNewToken: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DuplicateTokenEx}

--%% function CreateRestrictedToken(ExistingTokenHandle: HANDLE; Flags: DWORD;
--%%   DisableSidCount: DWORD; SidsToDisable: PSID_AND_ATTRIBUTES;
--%%   DeletePrivilegeCount: DWORD; PrivilegesToDelete: PLUID_AND_ATTRIBUTES;
--%%   RestrictedSidCount: DWORD; SidsToRestrict: PSID_AND_ATTRIBUTES;
--%%   var NewTokenHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CreateRestrictedToken}

--%% function IsTokenRestricted(TokenHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM IsTokenRestricted}

--%% function CheckTokenMembership(TokenHandle: HANDLE; SidToCheck: PSID; var IsMember: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM CheckTokenMembership}

--%% function IsTokenUntrusted(TokenHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM IsTokenUntrusted}

--
-- Thread pool API's
--

--%%   WAITORTIMERCALLBACK = WAITORTIMERCALLBACKFUNC;
--%%   {$EXTERNALSYM WAITORTIMERCALLBACK}
--%%   TWaitOrTimerCallback = WAITORTIMERCALLBACKFUNC;

--%% function RegisterWaitForSingleObject(var phNewWaitObject: HANDLE; hObject: HANDLE;
--%%   Callback: WAITORTIMERCALLBACK; Context: PVOID; dwMilliseconds, dwFlags: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM RegisterWaitForSingleObject}

--%% function RegisterWaitForSingleObjectEx(hObject: HANDLE;
--%%   Callback: WAITORTIMERCALLBACK; Context: PVOID; dwMilliseconds, dwFlags: ULONG): HANDLE; stdcall;
--%% {$EXTERNALSYM RegisterWaitForSingleObjectEx}

--%% function UnregisterWait(WaitHandle: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM UnregisterWait}

--%% function UnregisterWaitEx(WaitHandle, CompletionEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM UnregisterWaitEx}

--%% function QueueUserWorkItem(Function_: LPTHREAD_START_ROUTINE; Context: PVOID;
--%%   Flags: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM QueueUserWorkItem}

--%% function BindIoCompletionCallback(FileHandle: HANDLE;
--%%   Function_: LPOVERLAPPED_COMPLETION_ROUTINE; Flags: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM BindIoCompletionCallback}

--%% function CreateTimerQueue: HANDLE; stdcall;
--%% {$EXTERNALSYM CreateTimerQueue}

--%% function CreateTimerQueueTimer(var phNewTimer: HANDLE; TimerQueue: HANDLE;
--%%   Callback: WAITORTIMERCALLBACK; Parameter: PVOID; DueTime, Period: DWORD;
--%%   Flags: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM CreateTimerQueueTimer}

--%% function ChangeTimerQueueTimer(TimerQueue, Timer: HANDLE; DueTime, Period: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM ChangeTimerQueueTimer}

--%% function DeleteTimerQueueTimer(TimerQueue, Timer, CompletionEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteTimerQueueTimer}

--%% function DeleteTimerQueueEx(TimerQueue, CompletionEvent: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteTimerQueueEx}

--%% function SetTimerQueueTimer(TimerQueue, Callback: WAITORTIMERCALLBACK;
--%%   Parameter: PVOID; DueTime, Period: DWORD; PreferIo: BOOL): HANDLE; stdcall;
--%% {$EXTERNALSYM SetTimerQueueTimer}

--%% function CancelTimerQueueTimer(TimerQueue, Timer: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM CancelTimerQueueTimer}

--%% function DeleteTimerQueue(TimerQueue: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteTimerQueue}

--
-- Plug-and-Play API's
--

   Hw_Profile_Guidlen : constant := 39; -- 36-characters plus NULL terminator
   Max_Profile_Len    : constant := 80;

   Dockinfo_Undocked      : constant := 16#1#;
   Dockinfo_Docked        : constant := 16#2#;
   Dockinfo_User_Supplied : constant := 16#4#;
--%%   DOCKINFO_USER_UNDOCKED = DOCKINFO_USER_SUPPLIED or DOCKINFO_UNDOCKED;
--%%   {$EXTERNALSYM DOCKINFO_USER_UNDOCKED}
--%%   DOCKINFO_USER_DOCKED   = DOCKINFO_USER_SUPPLIED or DOCKINFO_DOCKED;
--%%   {$EXTERNALSYM DOCKINFO_USER_DOCKED}

--%%   LPHW_PROFILE_INFOA = ^HW_PROFILE_INFOA;
--%%   {$EXTERNALSYM LPHW_PROFILE_INFOA}
--%%   tagHW_PROFILE_INFOA = record
--%%     dwDockInfo: DWORD;
--%%     szHwProfileGuid: array [0..HW_PROFILE_GUIDLEN - 1] of CHAR;
--%%     szHwProfileName: array [0..MAX_PROFILE_LEN - 1] of CHAR;
--%%   end;
--%%   {$EXTERNALSYM tagHW_PROFILE_INFOA}
--%%   HW_PROFILE_INFOA = tagHW_PROFILE_INFOA;
--%%   {$EXTERNALSYM HW_PROFILE_INFOA}
--%%   THWProfileInfoA = HW_PROFILE_INFOA;
--%%   PHWProfileInfoA = LPHW_PROFILE_INFOA;

--%%   LPHW_PROFILE_INFOW = ^HW_PROFILE_INFOW;
--%%   {$EXTERNALSYM LPHW_PROFILE_INFOW}
--%%   tagHW_PROFILE_INFOW = record
--%%     dwDockInfo: DWORD;
--%%     szHwProfileGuid: array [0..HW_PROFILE_GUIDLEN - 1] of WCHAR;
--%%     szHwProfileName: array [0..MAX_PROFILE_LEN - 1] of WCHAR;
--%%   end;
--%%   {$EXTERNALSYM tagHW_PROFILE_INFOW}
--%%   HW_PROFILE_INFOW = tagHW_PROFILE_INFOW;
--%%   {$EXTERNALSYM HW_PROFILE_INFOW}
--%%   THWProfileInfoW = HW_PROFILE_INFOW;
--%%   PHWProfileInfoW = LPHW_PROFILE_INFOW;

--%%   {$IFDEF UNICODE}
--%%   HW_PROFILE_INFO = HW_PROFILE_INFOW;
--%%   {$EXTERNALSYM HW_PROFILE_INFO}
--%%   LPHW_PROFILE_INFO = LPHW_PROFILE_INFOW;
--%%   {$EXTERNALSYM LPHW_PROFILE_INFO}
--%%   THWProfileInfo = THWProfileInfoW;
--%%   PHWProfileInfo = PHWProfileInfoW;
--%%   {$ELSE}
--%%   HW_PROFILE_INFO = HW_PROFILE_INFOA;
--%%   {$EXTERNALSYM HW_PROFILE_INFO}
--%%   LPHW_PROFILE_INFO = LPHW_PROFILE_INFOA;
--%%   {$EXTERNALSYM LPHW_PROFILE_INFO}
--%%   THWProfileInfo = THWProfileInfoA;
--%%   PHWProfileInfo = PHWProfileInfoA;
--%%   {$ENDIF UNICODE}

--%% function GetCurrentHwProfileA(var lpHwProfileInfo: HW_PROFILE_INFOA): BOOL; stdcall;
--%% {$EXTERNALSYM GetCurrentHwProfileA}
--%% function GetCurrentHwProfileW(var lpHwProfileInfo: HW_PROFILE_INFOW): BOOL; stdcall;
--%% {$EXTERNALSYM GetCurrentHwProfileW}
--%% function GetCurrentHwProfile(var lpHwProfileInfo: HW_PROFILE_INFO): BOOL; stdcall;
--%% {$EXTERNALSYM GetCurrentHwProfile}

--
-- Performance counter API's
--

--%% function QueryPerformanceCounter(var lpPerformanceCount: LARGE_INTEGER): BOOL; stdcall;
--%% {$EXTERNALSYM QueryPerformanceCounter}

--%% function QueryPerformanceFrequency(var lpFrequency: LARGE_INTEGER): BOOL; stdcall;
--%% {$EXTERNALSYM QueryPerformanceFrequency}

--%% function GetVersionExA(lpVersionInformation: LPOSVERSIONINFOA): BOOL; stdcall;
--%% {$EXTERNALSYM GetVersionExA}
--%% function GetVersionExW(lpVersionInformation: LPOSVERSIONINFOW): BOOL; stdcall;
--%% {$EXTERNALSYM GetVersionExW}
--%% function GetVersionEx(lpVersionInformation: LPOSVERSIONINFO): BOOL; stdcall;
--%% {$EXTERNALSYM GetVersionEx}

--%% function VerifyVersionInfoA(var lpVersionInformation: OSVERSIONINFOEXA;
--%%   dwTypeMask: DWORD; dwlConditionMask: DWORDLONG): BOOL; stdcall;
--%% {$EXTERNALSYM VerifyVersionInfoA}
--%% function VerifyVersionInfoW(var lpVersionInformation: OSVERSIONINFOEXW;
--%%   dwTypeMask: DWORD; dwlConditionMask: DWORDLONG): BOOL; stdcall;
--%% {$EXTERNALSYM VerifyVersionInfoW}
--%% function VerifyVersionInfo(var lpVersionInformation: OSVERSIONINFOEX;
--%%   dwTypeMask: DWORD; dwlConditionMask: DWORDLONG): BOOL; stdcall;
--%% {$EXTERNALSYM VerifyVersionInfo}

-- DOS and OS/2 Compatible Error Code definitions returned by the Win32 Base
-- API functions.
--

-- #include <winerror.h>

-- Abnormal termination codes

   Tc_Normal  : constant := 0;
   Tc_Harderr : constant := 1;
   Tc_Gp_Trap : constant := 2;
   Tc_Signal  : constant := 3;

--
-- Power Management APIs
--

   Ac_Line_Offline      : constant := 16#00#;
   Ac_Line_Online       : constant := 16#01#;
   Ac_Line_Backup_Power : constant := 16#02#;
   Ac_Line_Unknown      : constant := 16#FF#;

   Battery_Flag_High       : constant := 16#01#;
   Battery_Flag_Low        : constant := 16#02#;
   Battery_Flag_Critical   : constant := 16#04#;
   Battery_Flag_Charging   : constant := 16#08#;
   Battery_Flag_No_Battery : constant := 16#80#;
   Battery_Flag_Unknown    : constant := 16#FF#;

   Battery_Percentage_Unknown : constant := 16#FF#;

   Battery_Life_Unknown : constant := 16#FFFF_FFFF#;

   type System_Power_Status_Type;
   type System_Power_Status_Ptr is access all System_Power_Status_Type;
   type System_Power_Status_CPtr is access constant System_Power_Status_Type;
   type System_Power_Status_Type is record
      AC_Line_Status : Unsigned_8;
      Battery_Flag : Unsigned_8;
      Battery_Life_Percent : Unsigned_8;
      Reserved1 : Unsigned_8;
      Battery_Life_Time : Unsigned_32;
      Battery_Full_Life_Time : Unsigned_32;
   end record;

--%% function GetSystemPowerStatus(var lpSystemPowerStatus: SYSTEM_POWER_STATUS): BOOL; stdcall;
--%% {$EXTERNALSYM GetSystemPowerStatus}

--%% function SetSystemPowerState(fSuspend, fForce: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM SetSystemPowerState}

--
-- Very Large Memory API Subset
--

--%% function AllocateUserPhysicalPages(hProcess: HANDLE; var NumberOfPages: ULONG_PTR;
--%%   PageArray: PULONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM AllocateUserPhysicalPages}

--%% function FreeUserPhysicalPages(hProcess: HANDLE; var NumberOfPages: ULONG_PTR;
--%%   PageArray: PULONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM FreeUserPhysicalPages}

--%% function MapUserPhysicalPages(VirtualAddress: PVOID; NumberOfPages: ULONG_PTR;
--%%   PageArray: PULONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM MapUserPhysicalPages}

--%% function MapUserPhysicalPagesScatter(VirtualAddresses: PVOID; NumberOfPages: ULONG_PTR;
--%%   PageArray: PULONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM MapUserPhysicalPagesScatter}

--%% function CreateJobObjectA(lpJobAttributes: LPSECURITY_ATTRIBUTES; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateJobObjectA}
--%% function CreateJobObjectW(lpJobAttributes: LPSECURITY_ATTRIBUTES; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateJobObjectW}
--%% function CreateJobObject(lpJobAttributes: LPSECURITY_ATTRIBUTES; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateJobObject}

--%% function OpenJobObjectA(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenJobObjectA}
--%% function OpenJobObjectW(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCWSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenJobObjectW}
--%% function OpenJobObject(dwDesiredAccess: DWORD; bInheritHandle: BOOL; lpName: LPCTSTR): HANDLE; stdcall;
--%% {$EXTERNALSYM OpenJobObject}

--%% function AssignProcessToJobObject(hJob, hProcess: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM AssignProcessToJobObject}

--%% function TerminateJobObject(hJob: HANDLE; uExitCode: UINT): BOOL; stdcall;
--%% {$EXTERNALSYM TerminateJobObject}

--%% function QueryInformationJobObject(hJob: HANDLE; JobObjectInformationClass: JOBOBJECTINFOCLASS;
--%%   lpJobObjectInformation: LPVOID; cbJobObjectInformationLength: DWORD;
--%%   lpReturnLength: LPDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM QueryInformationJobObject}

--%% function SetInformationJobObject(hJob: HANDLE; JobObjectInformationClass: JOBOBJECTINFOCLASS;
--%%   lpJobObjectInformation: LPVOID; cbJobObjectInformationLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM SetInformationJobObject}

--%% function IsProcessInJob(ProcessHandle, JobHandle: HANDLE; var Result_: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM IsProcessInJob}

--%% function CreateJobSet(NumJob: ULONG; UserJobSet: PJOB_SET_ARRAY; Flags: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM CreateJobSet}

--%% function AddVectoredExceptionHandler(FirstHandler: ULONG;
--%%   VectoredHandler: PVECTORED_EXCEPTION_HANDLER): PVOID; stdcall;
--%% {$EXTERNALSYM AddVectoredExceptionHandler}

--%% function RemoveVectoredExceptionHandler(VectoredHandlerHandle: PVOID): ULONG; stdcall;
--%% {$EXTERNALSYM RemoveVectoredExceptionHandler}

--
-- New Volume Mount Point API.
--

--%% function FindFirstVolumeA(lpszVolumeName: LPSTR; cchBufferLength: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstVolumeA}
--%% function FindFirstVolumeW(lpszVolumeName: LPWSTR; cchBufferLength: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstVolumeW}
--%% function FindFirstVolume(lpszVolumeName: LPTSTR; cchBufferLength: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstVolume}

--%% function FindNextVolumeA(hFindVolume: HANDLE; lpszVolumeName: LPSTR;
--%%   cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextVolumeA}
--%% function FindNextVolumeW(hFindVolume: HANDLE; lpszVolumeName: LPWSTR;
--%%   cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextVolumeW}
--%% function FindNextVolume(hFindVolume: HANDLE; lpszVolumeName: LPTSTR;
--%%   cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextVolume}

--%% function FindVolumeClose(hFindVolume: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM FindVolumeClose}

--%% function FindFirstVolumeMountPointA(lpszRootPathName: LPCSTR;
--%%   lpszVolumeMountPoint: LPSTR; cchBufferLength: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstVolumeMountPointA}
--%% function FindFirstVolumeMountPointW(lpszRootPathName: LPCWSTR;
--%%   lpszVolumeMountPoint: LPWSTR; cchBufferLength: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstVolumeMountPointW}
--%% function FindFirstVolumeMountPoint(lpszRootPathName: LPCTSTR;
--%%   lpszVolumeMountPoint: LPTSTR; cchBufferLength: DWORD): HANDLE; stdcall;
--%% {$EXTERNALSYM FindFirstVolumeMountPoint}

--%% function FindNextVolumeMountPointA(hFindVolumeMountPoint: HANDLE;
--%%   lpszVolumeMountPoint: LPSTR; cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextVolumeMountPointA}
--%% function FindNextVolumeMountPointW(hFindVolumeMountPoint: HANDLE;
--%%   lpszVolumeMountPoint: LPWSTR; cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextVolumeMountPointW}
--%% function FindNextVolumeMountPoint(hFindVolumeMountPoint: HANDLE;
--%%   lpszVolumeMountPoint: LPTSTR; cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM FindNextVolumeMountPoint}

--%% function FindVolumeMountPointClose(hFindVolumeMountPoint: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM FindVolumeMountPointClose}

--%% function SetVolumeMountPointA(lpszVolumeMountPoint, lpszVolumeName: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetVolumeMountPointA}
--%% function SetVolumeMountPointW(lpszVolumeMountPoint, lpszVolumeName: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetVolumeMountPointW}
--%% function SetVolumeMountPoint(lpszVolumeMountPoint, lpszVolumeName: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM SetVolumeMountPoint}

--%% function DeleteVolumeMountPointA(lpszVolumeMountPoint: LPCSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteVolumeMountPointA}
--%% function DeleteVolumeMountPointW(lpszVolumeMountPoint: LPCWSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteVolumeMountPointW}
--%% function DeleteVolumeMountPoint(lpszVolumeMountPoint: LPCTSTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeleteVolumeMountPoint}

--%% function GetVolumeNameForVolumeMountPointA(lpszVolumeMountPoint: LPCSTR;
--%%   lpszVolumeName: LPSTR; cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumeNameForVolumeMountPointA}
--%% function GetVolumeNameForVolumeMountPointW(lpszVolumeMountPoint: LPCWSTR;
--%%   lpszVolumeName: LPWSTR; cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumeNameForVolumeMountPointW}
--%% function GetVolumeNameForVolumeMountPoint(lpszVolumeMountPoint: LPCTSTR;
--%%   lpszVolumeName: LPTSTR; cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumeNameForVolumeMountPoint}

--%% function GetVolumePathNameA(lpszFileName: LPCSTR; lpszVolumePathName: LPSTR;
--%%   cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumePathNameA}
--%% function GetVolumePathNameW(lpszFileName: LPCWSTR; lpszVolumePathName: LPWSTR;
--%%   cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumePathNameW}
--%% function GetVolumePathName(lpszFileName: LPCTSTR; lpszVolumePathName: LPTSTR;
--%%   cchBufferLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumePathName}

--%% function GetVolumePathNamesForVolumeNameA(lpszVolumeName, lpszVolumePathNames: LPCSTR;
--%%   cchBufferLength: DWORD; var lpcchReturnLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumePathNamesForVolumeNameA}
--%% function GetVolumePathNamesForVolumeNameW(lpszVolumeName, lpszVolumePathNames: LPCWSTR;
--%%   cchBufferLength: DWORD; var lpcchReturnLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumePathNamesForVolumeNameW}
--%% function GetVolumePathNamesForVolumeName(lpszVolumeName, lpszVolumePathNames: LPCTSTR;
--%%   cchBufferLength: DWORD; var lpcchReturnLength: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetVolumePathNamesForVolumeName}

   Actctx_Flag_Processor_Architecture_Valid  : constant := 16#0000_0001#;
   Actctx_Flag_Langid_Valid                  : constant := 16#0000_0002#;
   Actctx_Flag_Assembly_Directory_Valid      : constant := 16#0000_0004#;
   Actctx_Flag_Resource_Name_Valid           : constant := 16#0000_0008#;
   Actctx_Flag_Set_Process_Default           : constant := 16#0000_0010#;
   Actctx_Flag_Application_Name_Valid        : constant := 16#0000_0020#;
   Actctx_Flag_Source_Is_Assemblyref         : constant := 16#0000_0040#;
   Actctx_Flag_Hmodule_Valid                 : constant := 16#0000_0080#;

--%%   tagACTCTXA = record
--%%     cbSize: ULONG;
--%%     dwFlags: DWORD;
--%%     lpSource: LPCSTR;
--%%     wProcessorArchitecture: USHORT;
--%%     wLangId: LANGID;
--%%     lpAssemblyDirectory: LPCSTR;
--%%     lpResourceName: LPCSTR;
--%%     lpApplicationName: LPCSTR;
--%%     hModule: HMODULE;
--%%   end;
--%%   {$EXTERNALSYM tagACTCTXA}
--%%   ACTCTXA = tagACTCTXA;
--%%   {$EXTERNALSYM ACTCTXA}
--%%   PACTCTXA = ^ACTCTXA;
--%%   {$EXTERNALSYM PACTCTXA}
--%%   TActCtxA = ACTCTXA;

--%%   tagACTCTXW = record
--%%     cbSize: ULONG;
--%%     dwFlags: DWORD;
--%%     lpSource: LPCWSTR;
--%%     wProcessorArchitecture: USHORT;
--%%     wLangId: LANGID;
--%%     lpAssemblyDirectory: LPCWSTR;
--%%     lpResourceName: LPCWSTR;
--%%     lpApplicationName: LPCWSTR;
--%%     hModule: HMODULE;
--%%   end;
--%%   {$EXTERNALSYM tagACTCTXW}
--%%   ACTCTXW = tagACTCTXW;
--%%   {$EXTERNALSYM ACTCTXW}
--%%   PACTCTXW = ^ACTCTXW;
--%%   {$EXTERNALSYM PACTCTXW}
--%%   TActCtxW = ACTCTXW;

--%%   {$IFDEF UNICODE}
--%%   ACTCTX = ACTCTXW;
--%%   {$EXTERNALSYM ACTCTX}
--%%   PACTCTX = PACTCTXW;
--%%   {$EXTERNALSYM PACTCTX}
--%%   TActCtx = TActCtxW;
--%%   {$ELSE}
--%%   ACTCTX = ACTCTXA;
--%%   {$EXTERNALSYM ACTCTX}
--%%   PACTCTX = PACTCTXA;
--%%   {$EXTERNALSYM PACTCTX}
--%%   TActCtx = TActCtxA;
--%%   {$ENDIF UNICODE}

--%% function CreateActCtxA(var pActCtx: ACTCTXA): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateActCtxA}
--%% function CreateActCtxW(var pActCtx: ACTCTXW): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateActCtxW}
--%% function CreateActCtx(var pActCtx: ACTCTX): HANDLE; stdcall;
--%% {$EXTERNALSYM CreateActCtx}

--%% procedure AddRefActCtx(hActCtx: HANDLE); stdcall;
--%% {$EXTERNALSYM AddRefActCtx}

--%% procedure ReleaseActCtx(hActCtx: HANDLE); stdcall;
--%% {$EXTERNALSYM ReleaseActCtx}

--%% function ZombifyActCtx(hActCtx: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM ZombifyActCtx}

--%% function ActivateActCtx(hActCtx: HANDLE; var lpCookie: ULONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM ActivateActCtx}

   Deactivate_Actctx_Flag_Force_Early_Deactivation : constant := 16#0000_0001#;

--%% function DeactivateActCtx(dwFlags: DWORD; ulCookie: ULONG_PTR): BOOL; stdcall;
--%% {$EXTERNALSYM DeactivateActCtx}

--%% function GetCurrentActCtx(var lphActCtx: HANDLE): BOOL; stdcall;
--%% {$EXTERNALSYM GetCurrentActCtx}

--%%   tagACTCTX_SECTION_KEYED_DATA_2600 = record
--%%     cbSize: ULONG;
--%%     ulDataFormatVersion: ULONG;
--%%     lpData: PVOID;
--%%     ulLength: ULONG;
--%%     lpSectionGlobalData: PVOID;
--%%     ulSectionGlobalDataLength: ULONG;
--%%     lpSectionBase: PVOID;
--%%     ulSectionTotalLength: ULONG;
--%%     hActCtx: HANDLE;
--%%     ulAssemblyRosterIndex: ULONG;
--%%   end;
--%%   {$EXTERNALSYM tagACTCTX_SECTION_KEYED_DATA_2600}
--%%   ACTCTX_SECTION_KEYED_DATA_2600 = tagACTCTX_SECTION_KEYED_DATA_2600;
--%%   {$EXTERNALSYM ACTCTX_SECTION_KEYED_DATA_2600}
--%%   PACTCTX_SECTION_KEYED_DATA_2600 = ^ACTCTX_SECTION_KEYED_DATA_2600;
--%%   {$EXTERNALSYM PACTCTX_SECTION_KEYED_DATA_2600}
--%%   PCACTCTX_SECTION_KEYED_DATA_2600 = ^ACTCTX_SECTION_KEYED_DATA_2600;
--%%   {$EXTERNALSYM PCACTCTX_SECTION_KEYED_DATA_2600}
--%%   TActCtxSectionKeyedData2600 = ACTCTX_SECTION_KEYED_DATA_2600;
--%%   PActCtxSectionKeyedData2600 = PACTCTX_SECTION_KEYED_DATA_2600;

--%%   tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = record
--%%     lpInformation: PVOID;
--%%     lpSectionBase: PVOID;
--%%     ulSectionLength: ULONG;
--%%     lpSectionGlobalDataBase: PVOID;
--%%     ulSectionGlobalDataLength: ULONG;
--%%   end;
--%%   {$EXTERNALSYM tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA}
--%%   ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
--%%   {$EXTERNALSYM ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA}
--%%   PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
--%%   {$EXTERNALSYM PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA}
--%%   PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
--%%   {$EXTERNALSYM PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA}
--%%   TActCtxSectionKeyedDataAssemblyMetadata = ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
--%%   PActCtxSectionKeyedDataAssemblyMetadata = PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
--%%   
--%%   tagACTCTX_SECTION_KEYED_DATA = record
--%%     cbSize: ULONG;
--%%     ulDataFormatVersion: ULONG;
--%%     lpData: PVOID;
--%%     ulLength: ULONG;
--%%     lpSectionGlobalData: PVOID;
--%%     ulSectionGlobalDataLength: ULONG;
--%%     lpSectionBase: PVOID;
--%%     ulSectionTotalLength: ULONG;
--%%     hActCtx: HANDLE;
--%%     ulAssemblyRosterIndex: ULONG;
--%%     // 2600 stops here
--%%     ulFlags: ULONG;
--%%     AssemblyMetadata: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
--%%   end;
--%%   {$EXTERNALSYM tagACTCTX_SECTION_KEYED_DATA}
--%%   ACTCTX_SECTION_KEYED_DATA = tagACTCTX_SECTION_KEYED_DATA;
--%%   {$EXTERNALSYM ACTCTX_SECTION_KEYED_DATA}
--%%   PACTCTX_SECTION_KEYED_DATA = ^ACTCTX_SECTION_KEYED_DATA;
--%%   {$EXTERNALSYM PACTCTX_SECTION_KEYED_DATA}
--%%   PCACTCTX_SECTION_KEYED_DATA = ^ACTCTX_SECTION_KEYED_DATA;
--%%   {$EXTERNALSYM PCACTCTX_SECTION_KEYED_DATA}
--%%   TActCtxSectionKeyedData = ACTCTX_SECTION_KEYED_DATA;
--%%   PActCtxSectionKeyedData = PACTCTX_SECTION_KEYED_DATA;

   Find_Actctx_Section_Key_Return_Hactctx : constant := 16#0000_0001#;
   Find_Actctx_Section_Key_Return_Flags   : constant := 16#0000_0002#;
   Find_Actctx_Section_Key_Return_Assembly_Metadata : constant := 16#0000_0004#;

--%% function FindActCtxSectionStringA(dwFlags: DWORD; const lpExtensionGuid: TGUID;
--%%   ulSectionId: ULONG; lpStringToFind: LPCSTR; ReturnedData: PACTCTX_SECTION_KEYED_DATA): BOOL; stdcall;
--%% {$EXTERNALSYM FindActCtxSectionStringA}
--%% function FindActCtxSectionStringW(dwFlags: DWORD; const lpExtensionGuid: TGUID;
--%%   ulSectionId: ULONG; lpStringToFind: LPCWSTR; ReturnedData: PACTCTX_SECTION_KEYED_DATA): BOOL; stdcall;
--%% {$EXTERNALSYM FindActCtxSectionStringW}
--%% function FindActCtxSectionString(dwFlags: DWORD; const lpExtensionGuid: TGUID;
--%%   ulSectionId: ULONG; lpStringToFind: LPCTSTR; ReturnedData: PACTCTX_SECTION_KEYED_DATA): BOOL; stdcall;
--%% {$EXTERNALSYM FindActCtxSectionString}

--%% function FindActCtxSectionGuid(dwFlags: DWORD; const lpExtensionGuid: TGUID;
--%%   ulSectionId: ULONG; const lpGuidToFind: TGUID; ReturnedData: PACTCTX_SECTION_KEYED_DATA): BOOL; stdcall;
--%% {$EXTERNALSYM FindActCtxSectionGuid}

   type Activation_Context_Basic_Information_Type;
   type Activation_Context_Basic_Information_Ptr is access all Activation_Context_Basic_Information_Type;
   type Activation_Context_Basic_Information_CPtr is access constant Activation_Context_Basic_Information_Type;
   type Activation_Context_Basic_Information_Type is record
      Act_Ctx : Handle_Type;
      Flags : Unsigned_32;
   end record;

--%%   PCACTIVATION_CONTEXT_BASIC_INFORMATION = ^_ACTIVATION_CONTEXT_BASIC_INFORMATION;
--%%   {$EXTERNALSYM PCACTIVATION_CONTEXT_BASIC_INFORMATION}

   Activation_Context_Basic_Information_Defined : constant := 1;

   Query_Actctx_Flag_Use_Active_Actctx : constant := 16#0000_0004#;
   Query_Actctx_Flag_Actctx_Is_Hmodule : constant := 16#0000_0008#;
   Query_Actctx_Flag_Actctx_Is_Address : constant := 16#0000_0010#;
   Query_Actctx_Flag_No_Addref         : constant := 16#8000_0000#;

--
-- switch (ulInfoClass)
--
--  case ActivationContextBasicInformation:
--    pvSubInstance == NULL
--    pvBuffer is of type PACTIVATION_CONTEXT_BASIC_INFORMATION
--
--  case ActivationContextDetailedInformation:
--    pvSubInstance == NULL
--    pvBuffer is of type PACTIVATION_CONTEXT_DETAILED_INFORMATION
--
--  case AssemblyDetailedInformationInActivationContext:
--    pvSubInstance is of type PULONG
--      *pvSubInstance < ACTIVATION_CONTEXT_DETAILED_INFORMATION::ulAssemblyCount
--    pvBuffer is of type PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
--
--  case FileInformationInAssemblyOfAssemblyInActivationContext:
--    pvSubInstance is of type PACTIVATION_CONTEXT_QUERY_INDEX
--      pvSubInstance->ulAssemblyIndex < ACTIVATION_CONTEXT_DETAILED_INFORMATION::ulAssemblyCount
--      pvSubInstance->ulFileIndexInAssembly < ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION::ulFileCount
--    pvBuffer is of type PASSEMBLY_FILE_DETAILED_INFORMATION
--
-- String are placed after the structs.
--
--%%   
--%% function QueryActCtxW(dwFlags: DWORD; hActCtx: HANDLE; pvSubInstance: PVOID;
--%%   ulInfoClass: ULONG; pvBuffer: PVOID; cbBuffer: SIZE_T;
--%%   pcbWrittenOrRequired: PSIZE_T): BOOL; stdcall;
--%% {$EXTERNALSYM QueryActCtxW}

--%%   PQUERYACTCTXW_FUNC = function(dwFlags: DWORD; hActCtx: HANDLE;
--%%     pvSubInstance: PVOID; ulInfoClass: ULONG; pvBuffer: PVOID; cbBuffer: SIZE_T;
--%%     pcbWrittenOrRequired: PSIZE_T): BOOL; stdcall;
--%%   {$EXTERNALSYM PQUERYACTCTXW_FUNC}

--%% function ProcessIdToSessionId(dwProcessId: DWORD; var pSessionId: DWORD): BOOL; stdcall;
--%% {$EXTERNALSYM ProcessIdToSessionId}

--%% function WTSGetActiveConsoleSessionId: DWORD; stdcall;
--%% {$EXTERNALSYM WTSGetActiveConsoleSessionId}

--%% function IsWow64Process(hProcess: HANDLE; var Wow64Process: BOOL): BOOL; stdcall;
--%% {$EXTERNALSYM IsWow64Process}

--%% function GetLogicalProcessorInformation(Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION; ReturnedLength: PDWORD): BOOL; stdcall;
--%% {$EXTERNALSYM GetLogicalProcessorInformation}

--
-- NUMA Information routines.
--

--%% function GetNumaHighestNodeNumber(var HighestNodeNumber: ULONG): BOOL; stdcall;
--%% {$EXTERNALSYM GetNumaHighestNodeNumber}

--%% function GetNumaProcessorNode(Processor: UCHAR; var NodeNumber: UCHAR): BOOL; stdcall;
--%% {$EXTERNALSYM GetNumaProcessorNode}

--%% function GetNumaNodeProcessorMask(Node: UCHAR; ProcessorMask: ULONGLONG): BOOL; stdcall;
--%% {$EXTERNALSYM GetNumaNodeProcessorMask}

--%% function GetNumaAvailableMemoryNode(Node: UCHAR; var AvailableBytes: ULONGLONG): BOOL; stdcall;
--%% {$EXTERNALSYM GetNumaAvailableMemoryNode}

--%% {$ENDIF JWA_IMPLEMENTATIONSECTION}

--%% {$IFNDEF JWA_OMIT_SECTIONS}
--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
--%% implementation
--%% {$ENDIF JWA_OMIT_SECTIONS}
--%%
--%% {$IFNDEF JWA_OMIT_SECTIONS}
--%% const
--%%   kernel32 = 'kernel32.dll';
--%%   advapi32 = 'advapi32.dll';
--%%   {$IFDEF UNICODE}
--%%   AWSuffix = 'W';
--%%   {$ELSE}
--%%   AWSuffix = 'A';
--%%   {$ENDIF UNICODE}
--%% {$ENDIF JWA_OMIT_SECTIONS}
--%%
--%% {$IFNDEF JWA_INTERFACESECTION}
--%%
--%% procedure MoveMemory(Destination, Source: PVOID; Length: SIZE_T);
--%% begin
--%%   Move(Source^, Destination^, Length);
--%% end;
--%%
--%% procedure CopyMemory(Destination, Source: PVOID; Length: SIZE_T);
--%% begin
--%%   Move(Source^, Destination^, Length);
--%% end;
--%%
--%% procedure FillMemory(Destination: PVOID; Length: SIZE_T; Fill: BYTE);
--%% begin
--%%   FillChar(Destination^, Length, Fill);
--%% end;
--%%
--%% procedure ZeroMemory(Destination: PVOID; Length: SIZE_T);
--%% begin
--%%   FillChar(Destination^, Length, 0);
--%% end;
--%%
--%% function FreeModule(hLibModule: HMODULE): BOOL;
--%% begin
--%%   Result := FreeLibrary(hLibModule);
--%% end;
--%%
--%% function MakeProcInstance(lpProc: FARPROC; hInstance: HINST): FARPROC;
--%% begin
--%%   Result := lpProc;
--%% end;
--%%
--%% procedure FreeProcInstance(lpProc: FARPROC);
--%% begin
--%%   { nothing }
--%% end;
--%%
--%% function GlobalLRUNewest(h: HANDLE): HANDLE;
--%% begin
--%%   Result := H;
--%% end;
--%%
--%% function GlobalLRUOldest(h: HANDLE): HANDLE;
--%% begin
--%%   Result := H;
--%% end;
--%%
--%% function GlobalDiscard(h: HANDLE): HANDLE;
--%% begin
--%%  Result := GlobalReAlloc(h, 0, GMEM_MOVEABLE);
--%% end;
--%%
--%% function LocalDiscard(h: HLOCAL): HLOCAL;
--%% begin
--%%   Result := LocalReAlloc(h, 0, LMEM_MOVEABLE);
--%% end;
--%%
--%% function GetFreeSpace(w: WORD): DWORD;
--%% begin
--%%   Result := $100000;
--%% end;
--%%
--%% {added tweak from
--%% http://sourceforge.net/tracker/index.php?func=detail&aid=1662760&group_id=121894&atid=694029
--%% by
--%% Marco
--%% }
--%% function InterlockedExchangePointer(var Target: PVOID; Value: PVOID): PVOID;
--%% begin
--%% {$ifdef CPU64}
--%%   Result := PVOID(InterlockedExchange64(LONGLONG(Target), LONGLONG(Value)));
--%% {$else}
--%%   Result := PVOID(InterlockedExchange(LONG(Target), LONG(Value)));
--%% {$endif CPU64}
--%% end;
--%%
--%% {added tweak from
--%% http://sourceforge.net/tracker/index.php?func=detail&aid=1662760&group_id=121894&atid=694029
--%% by Marco
--%% }
--%% function InterlockedCompareExchangePointer(var Destination: PVOID; Exchange, Comperand: PVOID): PVOID;
--%% begin
--%% {$ifdef CPU64}
--%%   Result := PVOID(InterlockedCompareExchange64(LONGLONG(Destination),
--%%               LONGLONG(Exchange), LONGLONG(Comperand)));
--%% {$else CPU64}
--%%   Result := PVOID(InterlockedCompareExchange(LONG(Destination),
--%%     LONG(Exchange), LONG(Comperand)));
--%% {$endif CPU64}
--%% end;
--%%
--%% function UnlockResource(hResData: HANDLE): BOOL;
--%% begin
--%%   Result := False;
--%% end;
--%%
--%% function HasOverlappedIoCompleted(const lpOverlapped: OVERLAPPED): BOOL;
--%% begin
--%%   Result := NTSTATUS(lpOverlapped.Internal) <> STATUS_PENDING;
--%% end;
--%%
--%% // 64 bit interlocked functions from Will
--%%
--%% function  InterlockedAnd64(var Destination: LONGLONG; Value: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Destination;
--%%   until (InterlockedCompareExchange64(Destination, Result and Value, Result) = Result);
--%% end;
--%%
--%% function  InterlockedOr64(var Destination: LONGLONG; Value: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Destination;
--%%   until (InterlockedCompareExchange64(Destination, Result or Value, Result) = Result);
--%% end;
--%%
--%% function  InterlockedXor64(var Destination: LONGLONG; Value: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Destination;
--%%   until (InterlockedCompareExchange64(Destination, Result xor Value, Result) = Result);
--%% end;
--%%
--%% function  InterlockedIncrement64(var Addend: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Addend;
--%%   until (InterlockedCompareExchange64(Addend, Result + 1, Result) = Result);
--%%   Inc(Result);
--%% end;
--%%
--%% function  InterlockedDecrement64(var Addend: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Addend;
--%%   until (InterlockedCompareExchange64(Addend, Result - 1, Result) = Result);
--%%   Dec(Result);
--%% end;
--%%
--%% function  InterlockedExchange64(var Target: LONGLONG; Value: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Target;
--%%   until (InterlockedCompareExchange64(Target, Value, Result) = Result);
--%% end;
--%%
--%% function  InterlockedExchangeAdd64(var Addend: LONGLONG; Value: LONGLONG): LONGLONG;
--%% begin
--%%   repeat
--%%     Result := Addend;
--%%   until (InterlockedCompareExchange64(Addend, Result + Value, Result) = Result);
--%% end;
--%%
--%% { MVB:
--%%   The implementation of CreateMutex only interpretes bInitialOwner as True if
--%%   it's ordinal value is 1, all other values are interpreted as False. Delphi
--%%   compiles Longbool(True) as $FFFFFFFF which is consequently interpreted as
--%%   False. Changing the bInitalOwner parameter type to Boolean fixes the problem
--%%   (Boolean(True) = 1) but that would be implementation specific and might break
--%%   in the future, though unlikely. Hence the CreateMutex function here which
--%%   explicitly passes LongBool(1) instead of LongBool(True). }
--%%
--%% type
--%%   TCreateMutexA = function(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: LongBool; lpName: LPCSTR): HANDLE; stdcall;
--%%   TCreateMutexW = function(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: LongBool; lpName: LPCWSTR): HANDLE; stdcall;
--%%
--%% var
--%%   _CreateMutexA: Pointer;
--%%   _CreateMutexW: Pointer;
--%%
--%% function CreateMutexA(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: BOOL; lpName: LPCSTR): HANDLE;
--%% begin
--%%   GetProcedureAddress(_CreateMutexA, kernel32, 'CreateMutexA');
--%%   if bInitialOwner then
--%%     Result := TCreateMutexA(_CreateMutexA)(lpMutexAttributes, LongBool(1), lpName)
--%%   else
--%%     Result := TCreateMutexA(_CreateMutexA)(lpMutexAttributes, LongBool(0), lpName)
--%% end;
--%%
--%% function CreateMutexW(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: BOOL; lpName: LPCWSTR): HANDLE;
--%% begin
--%%   GetProcedureAddress(_CreateMutexW, kernel32, 'CreateMutexW');
--%%   if bInitialOwner then
--%%     Result := TCreateMutexW(_CreateMutexW)(lpMutexAttributes, LongBool(1), lpName)
--%%   else
--%%     Result := TCreateMutexW(_CreateMutexW)(lpMutexAttributes, LongBool(0), lpName)
--%% end;
--%%
--%% {$IFDEF UNICODE}
--%% function CreateMutex(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: BOOL; lpName: LPCWSTR): HANDLE;
--%% begin
--%%   GetProcedureAddress(_CreateMutexW, kernel32, 'CreateMutexW');
--%%   if bInitialOwner then
--%%     Result := TCreateMutexW(_CreateMutexW)(lpMutexAttributes, LongBool(1), lpName)
--%%   else
--%%     Result := TCreateMutexW(_CreateMutexW)(lpMutexAttributes, LongBool(0), lpName)
--%% end;
--%% {$ELSE}
--%% function CreateMutex(lpMutexAttributes: LPSECURITY_ATTRIBUTES; bInitialOwner: BOOL; lpName: LPCSTR): HANDLE;
--%% begin
--%%   GetProcedureAddress(_CreateMutexA, kernel32, 'CreateMutexA');
--%%   if bInitialOwner then
--%%     Result := TCreateMutexA(_CreateMutexA)(lpMutexAttributes, LongBool(1), lpName)
--%%   else
--%%     Result := TCreateMutexA(_CreateMutexA)(lpMutexAttributes, LongBool(0), lpName)
--%% end;
--%% {$ENDIF UNICODE}
--%%
--%% {$IFDEF DYNAMIC_LINK}
--%%
--%% var
--%%   _InterlockedCompareExchange64: Pointer;
--%%
--%% function InterlockedCompareExchange64;
--%% begin
--%%   GetProcedureAddress(_InterlockedCompareExchange64, kernel32, 'InterlockedCompareExchange64');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedCompareExchange64]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedIncrement: Pointer;
--%%
--%% function InterlockedIncrement;
--%% begin
--%%   GetProcedureAddress(_InterlockedIncrement, kernel32, 'InterlockedIncrement');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedIncrement]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedDecrement: Pointer;
--%%
--%% function InterlockedDecrement;
--%% begin
--%%   GetProcedureAddress(_InterlockedDecrement, kernel32, 'InterlockedDecrement');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedDecrement]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedExchange: Pointer;
--%%
--%% function InterlockedExchange;
--%% begin
--%%   GetProcedureAddress(_InterlockedExchange, kernel32, 'InterlockedExchange');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedExchange]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedExchangeAdd: Pointer;
--%%
--%% function InterlockedExchangeAdd;
--%% begin
--%%   GetProcedureAddress(_InterlockedExchangeAdd, kernel32, 'InterlockedExchangeAdd');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedExchangeAdd]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedCompareExchange: Pointer;
--%%
--%% function InterlockedCompareExchange;
--%% begin
--%%   GetProcedureAddress(_InterlockedCompareExchange, kernel32, 'InterlockedCompareExchange');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedCompareExchange]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitializeSListHead: Pointer;
--%%
--%% procedure InitializeSListHead;
--%% begin
--%%   GetProcedureAddress(_InitializeSListHead, kernel32, 'InitializeSListHead');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitializeSListHead]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedPopEntrySList: Pointer;
--%%
--%% function InterlockedPopEntrySList;
--%% begin
--%%   GetProcedureAddress(_InterlockedPopEntrySList, kernel32, 'InterlockedPopEntrySList');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedPopEntrySList]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedPushEntrySList: Pointer;
--%%
--%% function InterlockedPushEntrySList;
--%% begin
--%%   GetProcedureAddress(_InterlockedPushEntrySList, kernel32, 'InterlockedPushEntrySList');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedPushEntrySList]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InterlockedFlushSList: Pointer;
--%%
--%% function InterlockedFlushSList;
--%% begin
--%%   GetProcedureAddress(_InterlockedFlushSList, kernel32, 'InterlockedFlushSList');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InterlockedFlushSList]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryDepthSList: Pointer;
--%%
--%% function QueryDepthSList;
--%% begin
--%%   GetProcedureAddress(_QueryDepthSList, kernel32, 'QueryDepthSList');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryDepthSList]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeResource: Pointer;
--%%
--%% function FreeResource;
--%% begin
--%%   GetProcedureAddress(_FreeResource, kernel32, 'FreeResource');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LockResource: Pointer;
--%%
--%% function LockResource;
--%% begin
--%%   GetProcedureAddress(_LockResource, kernel32, 'LockResource');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LockResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeLibrary: Pointer;
--%%
--%% function FreeLibrary;
--%% begin
--%%   GetProcedureAddress(_FreeLibrary, kernel32, 'FreeLibrary');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeLibrary]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeLibraryAndExitThread: Pointer;
--%%
--%% procedure FreeLibraryAndExitThread;
--%% begin
--%%   GetProcedureAddress(_FreeLibraryAndExitThread, kernel32, 'FreeLibraryAndExitThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeLibraryAndExitThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DisableThreadLibraryCalls: Pointer;
--%%
--%% function DisableThreadLibraryCalls;
--%% begin
--%%   GetProcedureAddress(_DisableThreadLibraryCalls, kernel32, 'DisableThreadLibraryCalls');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DisableThreadLibraryCalls]
--%%   end;
--%% end;
--%%
--%% // MVB TODO Dynamic linking for GetProcAddress doesn't make much sense, does it? Same for LoadLibrary.
--%%
--%% var
--%%   _GetProcAddress: Pointer;
--%%
--%% function GetProcAddress;
--%% begin
--%%   GetProcedureAddress(_GetProcAddress, kernel32, 'GetProcAddress');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcAddress]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVersion: Pointer;
--%%
--%% function GetVersion;
--%% begin
--%%   GetProcedureAddress(_GetVersion, kernel32, 'GetVersion');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVersion]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalAlloc: Pointer;
--%%
--%% function GlobalAlloc;
--%% begin
--%%   GetProcedureAddress(_GlobalAlloc, kernel32, 'GlobalAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalReAlloc: Pointer;
--%%
--%% function GlobalReAlloc;
--%% begin
--%%   GetProcedureAddress(_GlobalReAlloc, kernel32, 'GlobalReAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalReAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalSize: Pointer;
--%%
--%% function GlobalSize;
--%% begin
--%%   GetProcedureAddress(_GlobalSize, kernel32, 'GlobalSize');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalFlags: Pointer;
--%%
--%% function GlobalFlags;
--%% begin
--%%   GetProcedureAddress(_GlobalFlags, kernel32, 'GlobalFlags');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalFlags]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalLock: Pointer;
--%%
--%% function GlobalLock;
--%% begin
--%%   GetProcedureAddress(_GlobalLock, kernel32, 'GlobalLock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalLock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalHandle: Pointer;
--%%
--%% function GlobalHandle;
--%% begin
--%%   GetProcedureAddress(_GlobalHandle, kernel32, 'GlobalHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalUnlock: Pointer;
--%%
--%% function GlobalUnlock;
--%% begin
--%%   GetProcedureAddress(_GlobalUnlock, kernel32, 'GlobalUnlock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalUnlock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalFree: Pointer;
--%%
--%% function GlobalFree;
--%% begin
--%%   GetProcedureAddress(_GlobalFree, kernel32, 'GlobalFree');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalFree]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalCompact: Pointer;
--%%
--%% function GlobalCompact;
--%% begin
--%%   GetProcedureAddress(_GlobalCompact, kernel32, 'GlobalCompact');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalCompact]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalFix: Pointer;
--%%
--%% procedure GlobalFix;
--%% begin
--%%   GetProcedureAddress(_GlobalFix, kernel32, 'GlobalFix');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalFix]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalUnfix: Pointer;
--%%
--%% procedure GlobalUnfix;
--%% begin
--%%   GetProcedureAddress(_GlobalUnfix, kernel32, 'GlobalUnfix');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalUnfix]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalWire: Pointer;
--%%
--%% function GlobalWire;
--%% begin
--%%   GetProcedureAddress(_GlobalWire, kernel32, 'GlobalWire');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalWire]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalUnWire: Pointer;
--%%
--%% function GlobalUnWire;
--%% begin
--%%   GetProcedureAddress(_GlobalUnWire, kernel32, 'GlobalUnWire');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalUnWire]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalMemoryStatus: Pointer;
--%%
--%% procedure GlobalMemoryStatus;
--%% begin
--%%   GetProcedureAddress(_GlobalMemoryStatus, kernel32, 'GlobalMemoryStatus');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalMemoryStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalMemoryStatusEx: Pointer;
--%%
--%% function GlobalMemoryStatusEx;
--%% begin
--%%   GetProcedureAddress(_GlobalMemoryStatusEx, kernel32, 'GlobalMemoryStatusEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalMemoryStatusEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalAlloc: Pointer;
--%%
--%% function LocalAlloc;
--%% begin
--%%   GetProcedureAddress(_LocalAlloc, kernel32, 'LocalAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalReAlloc: Pointer;
--%%
--%% function LocalReAlloc;
--%% begin
--%%   GetProcedureAddress(_LocalReAlloc, kernel32, 'LocalReAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalReAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalLock: Pointer;
--%%
--%% function LocalLock;
--%% begin
--%%   GetProcedureAddress(_LocalLock, kernel32, 'LocalLock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalLock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalHandle: Pointer;
--%%
--%% function LocalHandle;
--%% begin
--%%   GetProcedureAddress(_LocalHandle, kernel32, 'LocalHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalUnlock: Pointer;
--%%
--%% function LocalUnlock;
--%% begin
--%%   GetProcedureAddress(_LocalUnlock, kernel32, 'LocalUnlock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalUnlock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalSize: Pointer;
--%%
--%% function LocalSize;
--%% begin
--%%   GetProcedureAddress(_LocalSize, kernel32, 'LocalSize');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalFlags: Pointer;
--%%
--%% function LocalFlags;
--%% begin
--%%   GetProcedureAddress(_LocalFlags, kernel32, 'LocalFlags');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalFlags]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalFree: Pointer;
--%%
--%% function LocalFree;
--%% begin
--%%   GetProcedureAddress(_LocalFree, kernel32, 'LocalFree');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalFree]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalShrink: Pointer;
--%%
--%% function LocalShrink;
--%% begin
--%%   GetProcedureAddress(_LocalShrink, kernel32, 'LocalShrink');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalShrink]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalCompact: Pointer;
--%%
--%% function LocalCompact;
--%% begin
--%%   GetProcedureAddress(_LocalCompact, kernel32, 'LocalCompact');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalCompact]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlushInstructionCache: Pointer;
--%%
--%% function FlushInstructionCache;
--%% begin
--%%   GetProcedureAddress(_FlushInstructionCache, kernel32, 'FlushInstructionCache');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlushInstructionCache]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualAlloc: Pointer;
--%%
--%% function VirtualAlloc;
--%% begin
--%%   GetProcedureAddress(_VirtualAlloc, kernel32, 'VirtualAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualFree: Pointer;
--%%
--%% function VirtualFree;
--%% begin
--%%   GetProcedureAddress(_VirtualFree, kernel32, 'VirtualFree');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualFree]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualProtect: Pointer;
--%%
--%% function VirtualProtect;
--%% begin
--%%   GetProcedureAddress(_VirtualProtect, kernel32, 'VirtualProtect');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualProtect]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualQuery: Pointer;
--%%
--%% function VirtualQuery;
--%% begin
--%%   GetProcedureAddress(_VirtualQuery, kernel32, 'VirtualQuery');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualQuery]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualAllocEx: Pointer;
--%%
--%% function VirtualAllocEx;
--%% begin
--%%   GetProcedureAddress(_VirtualAllocEx, kernel32, 'VirtualAllocEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualAllocEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetWriteWatch: Pointer;
--%%
--%% function GetWriteWatch;
--%% begin
--%%   GetProcedureAddress(_GetWriteWatch, kernel32, 'GetWriteWatch');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetWriteWatch]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ResetWriteWatch: Pointer;
--%%
--%% function ResetWriteWatch;
--%% begin
--%%   GetProcedureAddress(_ResetWriteWatch, kernel32, 'ResetWriteWatch');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ResetWriteWatch]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLargePageMinimum: Pointer;
--%%
--%% function GetLargePageMinimum;
--%% begin
--%%   GetProcedureAddress(_GetLargePageMinimum, kernel32, 'GetLargePageMinimum');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLargePageMinimum]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualFreeEx: Pointer;
--%%
--%% function VirtualFreeEx;
--%% begin
--%%   GetProcedureAddress(_VirtualFreeEx, kernel32, 'VirtualFreeEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualFreeEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualProtectEx: Pointer;
--%%
--%% function VirtualProtectEx;
--%% begin
--%%   GetProcedureAddress(_VirtualProtectEx, kernel32, 'VirtualProtectEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualProtectEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualQueryEx: Pointer;
--%%
--%% function VirtualQueryEx;
--%% begin
--%%   GetProcedureAddress(_VirtualQueryEx, kernel32, 'VirtualQueryEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualQueryEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapCreate: Pointer;
--%%
--%% function HeapCreate;
--%% begin
--%%   GetProcedureAddress(_HeapCreate, kernel32, 'HeapCreate');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapCreate]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapDestroy: Pointer;
--%%
--%% function HeapDestroy;
--%% begin
--%%   GetProcedureAddress(_HeapDestroy, kernel32, 'HeapDestroy');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapDestroy]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapAlloc: Pointer;
--%%
--%% function HeapAlloc;
--%% begin
--%%   GetProcedureAddress(_HeapAlloc, kernel32, 'HeapAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapReAlloc: Pointer;
--%%
--%% function HeapReAlloc;
--%% begin
--%%   GetProcedureAddress(_HeapReAlloc, kernel32, 'HeapReAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapReAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapFree: Pointer;
--%%
--%% function HeapFree;
--%% begin
--%%   GetProcedureAddress(_HeapFree, kernel32, 'HeapFree');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapFree]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapSize: Pointer;
--%%
--%% function HeapSize;
--%% begin
--%%   GetProcedureAddress(_HeapSize, kernel32, 'HeapSize');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapValidate: Pointer;
--%%
--%% function HeapValidate;
--%% begin
--%%   GetProcedureAddress(_HeapValidate, kernel32, 'HeapValidate');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapValidate]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapCompact: Pointer;
--%%
--%% function HeapCompact;
--%% begin
--%%   GetProcedureAddress(_HeapCompact, kernel32, 'HeapCompact');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapCompact]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessHeap: Pointer;
--%%
--%% function GetProcessHeap;
--%% begin
--%%   GetProcedureAddress(_GetProcessHeap, kernel32, 'GetProcessHeap');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessHeap]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessHeaps: Pointer;
--%%
--%% function GetProcessHeaps;
--%% begin
--%%   GetProcedureAddress(_GetProcessHeaps, kernel32, 'GetProcessHeaps');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessHeaps]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapLock: Pointer;
--%%
--%% function HeapLock;
--%% begin
--%%   GetProcedureAddress(_HeapLock, kernel32, 'HeapLock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapLock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapUnlock: Pointer;
--%%
--%% function HeapUnlock;
--%% begin
--%%   GetProcedureAddress(_HeapUnlock, kernel32, 'HeapUnlock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapUnlock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapWalk: Pointer;
--%%
--%% function HeapWalk;
--%% begin
--%%   GetProcedureAddress(_HeapWalk, kernel32, 'HeapWalk');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapWalk]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapSetInformation: Pointer;
--%%
--%% function HeapSetInformation;
--%% begin
--%%   GetProcedureAddress(_HeapSetInformation, kernel32, 'HeapSetInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapSetInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _HeapQueryInformation: Pointer;
--%%
--%% function HeapQueryInformation;
--%% begin
--%%   GetProcedureAddress(_HeapQueryInformation, kernel32, 'HeapQueryInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_HeapQueryInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetBinaryTypeA: Pointer;
--%%
--%% function GetBinaryTypeA;
--%% begin
--%%   GetProcedureAddress(_GetBinaryTypeA, kernel32, 'GetBinaryTypeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetBinaryTypeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetBinaryTypeW: Pointer;
--%%
--%% function GetBinaryTypeW;
--%% begin
--%%   GetProcedureAddress(_GetBinaryTypeW, kernel32, 'GetBinaryTypeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetBinaryTypeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetBinaryType: Pointer;
--%%
--%% function GetBinaryType;
--%% begin
--%%   GetProcedureAddress(_GetBinaryType, kernel32, 'GetBinaryType' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetBinaryType]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetShortPathNameA: Pointer;
--%%
--%% function GetShortPathNameA;
--%% begin
--%%   GetProcedureAddress(_GetShortPathNameA, kernel32, 'GetShortPathNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetShortPathNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetShortPathNameW: Pointer;
--%%
--%% function GetShortPathNameW;
--%% begin
--%%   GetProcedureAddress(_GetShortPathNameW, kernel32, 'GetShortPathNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetShortPathNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetShortPathName: Pointer;
--%%
--%% function GetShortPathName;
--%% begin
--%%   GetProcedureAddress(_GetShortPathName, kernel32, 'GetShortPathName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetShortPathName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLongPathNameA: Pointer;
--%%
--%% function GetLongPathNameA;
--%% begin
--%%   GetProcedureAddress(_GetLongPathNameA, kernel32, 'GetLongPathNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLongPathNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLongPathNameW: Pointer;
--%%
--%% function GetLongPathNameW;
--%% begin
--%%   GetProcedureAddress(_GetLongPathNameW, kernel32, 'GetLongPathNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLongPathNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLongPathName: Pointer;
--%%
--%% function GetLongPathName;
--%% begin
--%%   GetProcedureAddress(_GetLongPathName, kernel32, 'GetLongPathName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLongPathName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessAffinityMask: Pointer;
--%%
--%% function GetProcessAffinityMask;
--%% begin
--%%   GetProcedureAddress(_GetProcessAffinityMask, kernel32, 'GetProcessAffinityMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessAffinityMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetProcessAffinityMask: Pointer;
--%%
--%% function SetProcessAffinityMask;
--%% begin
--%%   GetProcedureAddress(_SetProcessAffinityMask, kernel32, 'SetProcessAffinityMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetProcessAffinityMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessHandleCount: Pointer;
--%%
--%% function GetProcessHandleCount;
--%% begin
--%%   GetProcedureAddress(_GetProcessHandleCount, kernel32, 'GetProcessHandleCount');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessHandleCount]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessTimes: Pointer;
--%%
--%% function GetProcessTimes;
--%% begin
--%%   GetProcedureAddress(_GetProcessTimes, kernel32, 'GetProcessTimes');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessTimes]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessIoCounters: Pointer;
--%%
--%% function GetProcessIoCounters;
--%% begin
--%%   GetProcedureAddress(_GetProcessIoCounters, kernel32, 'GetProcessIoCounters');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessIoCounters]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessWorkingSetSize: Pointer;
--%%
--%% function GetProcessWorkingSetSize;
--%% begin
--%%   GetProcedureAddress(_GetProcessWorkingSetSize, kernel32, 'GetProcessWorkingSetSize');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessWorkingSetSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessWorkingSetSizeEx: Pointer;
--%%
--%% function GetProcessWorkingSetSizeEx;
--%% begin
--%%   GetProcedureAddress(_GetProcessWorkingSetSizeEx, kernel32, 'GetProcessWorkingSetSizeEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessWorkingSetSizeEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetProcessWorkingSetSize: Pointer;
--%%
--%% function SetProcessWorkingSetSize;
--%% begin
--%%   GetProcedureAddress(_SetProcessWorkingSetSize, kernel32, 'SetProcessWorkingSetSize');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetProcessWorkingSetSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetProcessWorkingSetSizeEx: Pointer;
--%%
--%% function SetProcessWorkingSetSizeEx;
--%% begin
--%%   GetProcedureAddress(_SetProcessWorkingSetSizeEx, kernel32, 'SetProcessWorkingSetSizeEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetProcessWorkingSetSizeEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenProcess: Pointer;
--%%
--%% function OpenProcess;
--%% begin
--%%   GetProcedureAddress(_OpenProcess, kernel32, 'OpenProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentProcess: Pointer;
--%%
--%% function GetCurrentProcess;
--%% begin
--%%   GetProcedureAddress(_GetCurrentProcess, kernel32, 'GetCurrentProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentProcessId: Pointer;
--%%
--%% function GetCurrentProcessId;
--%% begin
--%%   GetProcedureAddress(_GetCurrentProcessId, kernel32, 'GetCurrentProcessId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentProcessId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ExitProcess: Pointer;
--%%
--%% procedure ExitProcess;
--%% begin
--%%   GetProcedureAddress(_ExitProcess, kernel32, 'ExitProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ExitProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TerminateProcess: Pointer;
--%%
--%% function TerminateProcess;
--%% begin
--%%   GetProcedureAddress(_TerminateProcess, kernel32, 'TerminateProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TerminateProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetExitCodeProcess: Pointer;
--%%
--%% function GetExitCodeProcess;
--%% begin
--%%   GetProcedureAddress(_GetExitCodeProcess, kernel32, 'GetExitCodeProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetExitCodeProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FatalExit: Pointer;
--%%
--%% procedure FatalExit;
--%% begin
--%%   GetProcedureAddress(_FatalExit, kernel32, 'FatalExit');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FatalExit]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetEnvironmentStringsW: Pointer;
--%%
--%% function GetEnvironmentStringsW;
--%% begin
--%%   GetProcedureAddress(_GetEnvironmentStringsW, kernel32, 'GetEnvironmentStringsW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEnvironmentStringsW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetEnvironmentStrings: Pointer;
--%%
--%% function GetEnvironmentStrings;
--%% begin
--%%   GetProcedureAddress(_GetEnvironmentStrings, kernel32, 'GetEnvironmentStrings' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEnvironmentStrings]
--%%   end;
--%% end;
--%%
--%% {$IFNDEF UNICODE}
--%%
--%% var
--%%   _GetEnvironmentStringsA: Pointer;
--%%
--%% function GetEnvironmentStringsA;
--%% begin
--%%   GetProcedureAddress(_GetEnvironmentStringsA, kernel32, 'GetEnvironmentStringsA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEnvironmentStringsA]
--%%   end;
--%% end;
--%%
--%% {$ENDIF !UNICODE}
--%%
--%% {$IFDEF WIN2003_UP}
--%% var
--%%   _SetEnvironmentStringsA: Pointer;
--%%
--%% function SetEnvironmentStringsA;
--%% begin
--%%   GetProcedureAddress(_SetEnvironmentStringsA, kernel32, 'SetEnvironmentStringsA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEnvironmentStringsA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEnvironmentStringsW: Pointer;
--%%
--%% function SetEnvironmentStringsW;
--%% begin
--%%   GetProcedureAddress(_SetEnvironmentStringsW, kernel32, 'SetEnvironmentStringsW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEnvironmentStringsW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEnvironmentStrings: Pointer;
--%%
--%% function SetEnvironmentStrings;
--%% begin
--%%   GetProcedureAddress(_SetEnvironmentStrings, kernel32, 'SetEnvironmentStrings' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEnvironmentStrings]
--%%   end;
--%% end;
--%%
--%% {$ENDIF WIN2003_UP}
--%%
--%% var
--%%   _FreeEnvironmentStringsA: Pointer;
--%%
--%% function FreeEnvironmentStringsA;
--%% begin
--%%   GetProcedureAddress(_FreeEnvironmentStringsA, kernel32, 'FreeEnvironmentStringsA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeEnvironmentStringsA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeEnvironmentStringsW: Pointer;
--%%
--%% function FreeEnvironmentStringsW;
--%% begin
--%%   GetProcedureAddress(_FreeEnvironmentStringsW, kernel32, 'FreeEnvironmentStringsW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeEnvironmentStringsW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeEnvironmentStrings: Pointer;
--%%
--%% function FreeEnvironmentStrings;
--%% begin
--%%   GetProcedureAddress(_FreeEnvironmentStrings, kernel32, 'FreeEnvironmentStrings' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeEnvironmentStrings]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RaiseException: Pointer;
--%%
--%% procedure RaiseException;
--%% begin
--%%   GetProcedureAddress(_RaiseException, kernel32, 'RaiseException');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RaiseException]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UnhandledExceptionFilter: Pointer;
--%%
--%% function UnhandledExceptionFilter;
--%% begin
--%%   GetProcedureAddress(_UnhandledExceptionFilter, kernel32, 'UnhandledExceptionFilter');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UnhandledExceptionFilter]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetUnhandledExceptionFilter: Pointer;
--%%
--%% function SetUnhandledExceptionFilter;
--%% begin
--%%   GetProcedureAddress(_SetUnhandledExceptionFilter, kernel32, 'SetUnhandledExceptionFilter');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetUnhandledExceptionFilter]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFiber: Pointer;
--%%
--%% function CreateFiber;
--%% begin
--%%   GetProcedureAddress(_CreateFiber, kernel32, 'CreateFiber');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFiber]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFiberEx: Pointer;
--%%
--%% function CreateFiberEx;
--%% begin
--%%   GetProcedureAddress(_CreateFiberEx, kernel32, 'CreateFiberEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFiberEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteFiber: Pointer;
--%%
--%% procedure DeleteFiber;
--%% begin
--%%   GetProcedureAddress(_DeleteFiber, kernel32, 'DeleteFiber');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteFiber]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ConvertThreadToFiber: Pointer;
--%%
--%% function ConvertThreadToFiber;
--%% begin
--%%   GetProcedureAddress(_ConvertThreadToFiber, kernel32, 'ConvertThreadToFiber');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ConvertThreadToFiber]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ConvertThreadToFiberEx: Pointer;
--%%
--%% function ConvertThreadToFiberEx;
--%% begin
--%%   GetProcedureAddress(_ConvertThreadToFiberEx, kernel32, 'ConvertThreadToFiberEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ConvertThreadToFiberEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ConvertFiberToThread: Pointer;
--%%
--%% function ConvertFiberToThread;
--%% begin
--%%   GetProcedureAddress(_ConvertFiberToThread, kernel32, 'ConvertFiberToThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ConvertFiberToThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SwitchToFiber: Pointer;
--%%
--%% procedure SwitchToFiber;
--%% begin
--%%   GetProcedureAddress(_SwitchToFiber, kernel32, 'SwitchToFiber');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SwitchToFiber]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SwitchToThread: Pointer;
--%%
--%% function SwitchToThread;
--%% begin
--%%   GetProcedureAddress(_SwitchToThread, kernel32, 'SwitchToThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SwitchToThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateThread: Pointer;
--%%
--%% function CreateThread;
--%% begin
--%%   GetProcedureAddress(_CreateThread, kernel32, 'CreateThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateRemoteThread: Pointer;
--%%
--%% function CreateRemoteThread;
--%% begin
--%%   GetProcedureAddress(_CreateRemoteThread, kernel32, 'CreateRemoteThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateRemoteThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentThread: Pointer;
--%%
--%% function GetCurrentThread;
--%% begin
--%%   GetProcedureAddress(_GetCurrentThread, kernel32, 'GetCurrentThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentThreadId: Pointer;
--%%
--%% function GetCurrentThreadId;
--%% begin
--%%   GetProcedureAddress(_GetCurrentThreadId, kernel32, 'GetCurrentThreadId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentThreadId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessIdOfThread: Pointer;
--%%
--%% function GetProcessIdOfThread;
--%% begin
--%%   GetProcedureAddress(_GetProcessIdOfThread, kernel32, 'GetProcessIdOfThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessIdOfThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadId: Pointer;
--%%
--%% function GetThreadId;
--%% begin
--%%   GetProcedureAddress(_GetThreadId, kernel32, 'GetThreadId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessId: Pointer;
--%%
--%% function GetProcessId;
--%% begin
--%%   GetProcedureAddress(_GetProcessId, kernel32, 'GetProcessId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentProcessorNumber: Pointer;
--%%
--%% function GetCurrentProcessorNumber;
--%% begin
--%%   GetProcedureAddress(_GetCurrentProcessorNumber, kernel32, 'GetCurrentProcessorNumber');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentProcessorNumber]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadAffinityMask: Pointer;
--%%
--%% function SetThreadAffinityMask;
--%% begin
--%%   GetProcedureAddress(_SetThreadAffinityMask, kernel32, 'SetThreadAffinityMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadAffinityMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadIdealProcessor: Pointer;
--%%
--%% function SetThreadIdealProcessor;
--%% begin
--%%   GetProcedureAddress(_SetThreadIdealProcessor, kernel32, 'SetThreadIdealProcessor');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadIdealProcessor]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetProcessPriorityBoost: Pointer;
--%%
--%% function SetProcessPriorityBoost;
--%% begin
--%%   GetProcedureAddress(_SetProcessPriorityBoost, kernel32, 'SetProcessPriorityBoost');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetProcessPriorityBoost]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessPriorityBoost: Pointer;
--%%
--%% function GetProcessPriorityBoost;
--%% begin
--%%   GetProcedureAddress(_GetProcessPriorityBoost, kernel32, 'GetProcessPriorityBoost');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessPriorityBoost]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RequestWakeupLatency: Pointer;
--%%
--%% function RequestWakeupLatency;
--%% begin
--%%   GetProcedureAddress(_RequestWakeupLatency, kernel32, 'RequestWakeupLatency');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RequestWakeupLatency]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsSystemResumeAutomatic: Pointer;
--%%
--%% function IsSystemResumeAutomatic;
--%% begin
--%%   GetProcedureAddress(_IsSystemResumeAutomatic, kernel32, 'IsSystemResumeAutomatic');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsSystemResumeAutomatic]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenThread: Pointer;
--%%
--%% function OpenThread;
--%% begin
--%%   GetProcedureAddress(_OpenThread, kernel32, 'OpenThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadPriority: Pointer;
--%%
--%% function SetThreadPriority;
--%% begin
--%%   GetProcedureAddress(_SetThreadPriority, kernel32, 'SetThreadPriority');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadPriority]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadPriorityBoost: Pointer;
--%%
--%% function SetThreadPriorityBoost;
--%% begin
--%%   GetProcedureAddress(_SetThreadPriorityBoost, kernel32, 'SetThreadPriorityBoost');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadPriorityBoost]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadPriorityBoost: Pointer;
--%%
--%% function GetThreadPriorityBoost;
--%% begin
--%%   GetProcedureAddress(_GetThreadPriorityBoost, kernel32, 'GetThreadPriorityBoost');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadPriorityBoost]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadPriority: Pointer;
--%%
--%% function GetThreadPriority;
--%% begin
--%%   GetProcedureAddress(_GetThreadPriority, kernel32, 'GetThreadPriority');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadPriority]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadTimes: Pointer;
--%%
--%% function GetThreadTimes;
--%% begin
--%%   GetProcedureAddress(_GetThreadTimes, kernel32, 'GetThreadTimes');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadTimes]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadIOPendingFlag: Pointer;
--%%
--%% function GetThreadIOPendingFlag;
--%% begin
--%%   GetProcedureAddress(_GetThreadIOPendingFlag, kernel32, 'GetThreadIOPendingFlag');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadIOPendingFlag]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ExitThread: Pointer;
--%%
--%% procedure ExitThread;
--%% begin
--%%   GetProcedureAddress(_ExitThread, kernel32, 'ExitThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ExitThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TerminateThread: Pointer;
--%%
--%% function TerminateThread;
--%% begin
--%%   GetProcedureAddress(_TerminateThread, kernel32, 'TerminateThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TerminateThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetExitCodeThread: Pointer;
--%%
--%% function GetExitCodeThread;
--%% begin
--%%   GetProcedureAddress(_GetExitCodeThread, kernel32, 'GetExitCodeThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetExitCodeThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadSelectorEntry: Pointer;
--%%
--%% function GetThreadSelectorEntry;
--%% begin
--%%   GetProcedureAddress(_GetThreadSelectorEntry, kernel32, 'GetThreadSelectorEntry');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadSelectorEntry]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadExecutionState: Pointer;
--%%
--%% function SetThreadExecutionState;
--%% begin
--%%   GetProcedureAddress(_SetThreadExecutionState, kernel32, 'SetThreadExecutionState');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadExecutionState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLastError: Pointer;
--%%
--%% function GetLastError;
--%% begin
--%%   GetProcedureAddress(_GetLastError, kernel32, 'GetLastError');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLastError]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetLastError: Pointer;
--%%
--%% procedure SetLastError;
--%% begin
--%%   GetProcedureAddress(_SetLastError, kernel32, 'SetLastError');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetLastError]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RestoreLastError: Pointer;
--%%
--%% procedure RestoreLastError;
--%% begin
--%%   GetProcedureAddress(_RestoreLastError, kernel32, 'RestoreLastError');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RestoreLastError]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetOverlappedResult: Pointer;
--%%
--%% function GetOverlappedResult;
--%% begin
--%%   GetProcedureAddress(_GetOverlappedResult, kernel32, 'GetOverlappedResult');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetOverlappedResult]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateIoCompletionPort: Pointer;
--%%
--%% function CreateIoCompletionPort;
--%% begin
--%%   GetProcedureAddress(_CreateIoCompletionPort, kernel32, 'CreateIoCompletionPort');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateIoCompletionPort]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetQueuedCompletionStatus: Pointer;
--%%
--%% function GetQueuedCompletionStatus;
--%% begin
--%%   GetProcedureAddress(_GetQueuedCompletionStatus, kernel32, 'GetQueuedCompletionStatus');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetQueuedCompletionStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PostQueuedCompletionStatus: Pointer;
--%%
--%% function PostQueuedCompletionStatus;
--%% begin
--%%   GetProcedureAddress(_PostQueuedCompletionStatus, kernel32, 'PostQueuedCompletionStatus');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PostQueuedCompletionStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetErrorMode: Pointer;
--%%
--%% function SetErrorMode;
--%% begin
--%%   GetProcedureAddress(_SetErrorMode, kernel32, 'SetErrorMode');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetErrorMode]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadProcessMemory: Pointer;
--%%
--%% function ReadProcessMemory;
--%% begin
--%%   GetProcedureAddress(_ReadProcessMemory, kernel32, 'ReadProcessMemory');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadProcessMemory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProcessMemory: Pointer;
--%%
--%% function WriteProcessMemory;
--%% begin
--%%   GetProcedureAddress(_WriteProcessMemory, kernel32, 'WriteProcessMemory');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProcessMemory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetThreadContext: Pointer;
--%%
--%% function GetThreadContext;
--%% begin
--%%   GetProcedureAddress(_GetThreadContext, kernel32, 'GetThreadContext');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetThreadContext]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadContext: Pointer;
--%%
--%% function SetThreadContext;
--%% begin
--%%   GetProcedureAddress(_SetThreadContext, kernel32, 'SetThreadContext');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadContext]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SuspendThread: Pointer;
--%%
--%% function SuspendThread;
--%% begin
--%%   GetProcedureAddress(_SuspendThread, kernel32, 'SuspendThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SuspendThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ResumeThread: Pointer;
--%%
--%% function ResumeThread;
--%% begin
--%%   GetProcedureAddress(_ResumeThread, kernel32, 'ResumeThread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ResumeThread]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueueUserAPC: Pointer;
--%%
--%% function QueueUserAPC;
--%% begin
--%%   GetProcedureAddress(_QueueUserAPC, kernel32, 'QueueUserAPC');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueueUserAPC]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsDebuggerPresent: Pointer;
--%%
--%% function IsDebuggerPresent;
--%% begin
--%%   GetProcedureAddress(_IsDebuggerPresent, kernel32, 'IsDebuggerPresent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsDebuggerPresent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CheckRemoteDebuggerPresent: Pointer;
--%%
--%% function CheckRemoteDebuggerPresent;
--%% begin
--%%   GetProcedureAddress(_CheckRemoteDebuggerPresent, kernel32, 'CheckRemoteDebuggerPresent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CheckRemoteDebuggerPresent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DebugBreak: Pointer;
--%%
--%% procedure DebugBreak;
--%% begin
--%%   GetProcedureAddress(_DebugBreak, kernel32, 'DebugBreak');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DebugBreak]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitForDebugEvent: Pointer;
--%%
--%% function WaitForDebugEvent;
--%% begin
--%%   GetProcedureAddress(_WaitForDebugEvent, kernel32, 'WaitForDebugEvent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitForDebugEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ContinueDebugEvent: Pointer;
--%%
--%% function ContinueDebugEvent;
--%% begin
--%%   GetProcedureAddress(_ContinueDebugEvent, kernel32, 'ContinueDebugEvent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ContinueDebugEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DebugActiveProcess: Pointer;
--%%
--%% function DebugActiveProcess;
--%% begin
--%%   GetProcedureAddress(_DebugActiveProcess, kernel32, 'DebugActiveProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DebugActiveProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DebugActiveProcessStop: Pointer;
--%%
--%% function DebugActiveProcessStop;
--%% begin
--%%   GetProcedureAddress(_DebugActiveProcessStop, kernel32, 'DebugActiveProcessStop');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DebugActiveProcessStop]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DebugSetProcessKillOnExit: Pointer;
--%%
--%% function DebugSetProcessKillOnExit;
--%% begin
--%%   GetProcedureAddress(_DebugSetProcessKillOnExit, kernel32, 'DebugSetProcessKillOnExit');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DebugSetProcessKillOnExit]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DebugBreakProcess: Pointer;
--%%
--%% function DebugBreakProcess;
--%% begin
--%%   GetProcedureAddress(_DebugBreakProcess, kernel32, 'DebugBreakProcess');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DebugBreakProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitializeCriticalSection: Pointer;
--%%
--%% procedure InitializeCriticalSection;
--%% begin
--%%   GetProcedureAddress(_InitializeCriticalSection, kernel32, 'InitializeCriticalSection');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitializeCriticalSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnterCriticalSection: Pointer;
--%%
--%% procedure EnterCriticalSection;
--%% begin
--%%   GetProcedureAddress(_EnterCriticalSection, kernel32, 'EnterCriticalSection');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnterCriticalSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LeaveCriticalSection: Pointer;
--%%
--%% procedure LeaveCriticalSection;
--%% begin
--%%   GetProcedureAddress(_LeaveCriticalSection, kernel32, 'LeaveCriticalSection');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LeaveCriticalSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitCritSectAndSpinCount: Pointer;
--%%
--%% function InitializeCriticalSectionAndSpinCount;
--%% begin
--%%   GetProcedureAddress(_InitCritSectAndSpinCount, kernel32, 'InitializeCriticalSectionAndSpinCount');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitCritSectAndSpinCount]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCriticalSectionSpinCount: Pointer;
--%%
--%% function SetCriticalSectionSpinCount;
--%% begin
--%%   GetProcedureAddress(_SetCriticalSectionSpinCount, kernel32, 'SetCriticalSectionSpinCount');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCriticalSectionSpinCount]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TryEnterCriticalSection: Pointer;
--%%
--%% function TryEnterCriticalSection;
--%% begin
--%%   GetProcedureAddress(_TryEnterCriticalSection, kernel32, 'TryEnterCriticalSection');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TryEnterCriticalSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteCriticalSection: Pointer;
--%%
--%% procedure DeleteCriticalSection;
--%% begin
--%%   GetProcedureAddress(_DeleteCriticalSection, kernel32, 'DeleteCriticalSection');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteCriticalSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEvent: Pointer;
--%%
--%% function SetEvent;
--%% begin
--%%   GetProcedureAddress(_SetEvent, kernel32, 'SetEvent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ResetEvent: Pointer;
--%%
--%% function ResetEvent;
--%% begin
--%%   GetProcedureAddress(_ResetEvent, kernel32, 'ResetEvent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ResetEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PulseEvent: Pointer;
--%%
--%% function PulseEvent;
--%% begin
--%%   GetProcedureAddress(_PulseEvent, kernel32, 'PulseEvent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PulseEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReleaseSemaphore: Pointer;
--%%
--%% function ReleaseSemaphore;
--%% begin
--%%   GetProcedureAddress(_ReleaseSemaphore, kernel32, 'ReleaseSemaphore');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReleaseSemaphore]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReleaseMutex: Pointer;
--%%
--%% function ReleaseMutex;
--%% begin
--%%   GetProcedureAddress(_ReleaseMutex, kernel32, 'ReleaseMutex');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReleaseMutex]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitForSingleObject: Pointer;
--%%
--%% function WaitForSingleObject;
--%% begin
--%%   GetProcedureAddress(_WaitForSingleObject, kernel32, 'WaitForSingleObject');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitForSingleObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitForMultipleObjects: Pointer;
--%%
--%% function WaitForMultipleObjects;
--%% begin
--%%   GetProcedureAddress(_WaitForMultipleObjects, kernel32, 'WaitForMultipleObjects');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitForMultipleObjects]
--%%   end;
--%% end;
--%%
--%% var
--%%   _Sleep: Pointer;
--%%
--%% procedure Sleep;
--%% begin
--%%   GetProcedureAddress(_Sleep, kernel32, 'Sleep');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_Sleep]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadResource: Pointer;
--%%
--%% function LoadResource;
--%% begin
--%%   GetProcedureAddress(_LoadResource, kernel32, 'LoadResource');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SizeofResource: Pointer;
--%%
--%% function SizeofResource;
--%% begin
--%%   GetProcedureAddress(_SizeofResource, kernel32, 'SizeofResource');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SizeofResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalDeleteAtom: Pointer;
--%%
--%% function GlobalDeleteAtom;
--%% begin
--%%   GetProcedureAddress(_GlobalDeleteAtom, kernel32, 'GlobalDeleteAtom');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalDeleteAtom]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitAtomTable: Pointer;
--%%
--%% function InitAtomTable;
--%% begin
--%%   GetProcedureAddress(_InitAtomTable, kernel32, 'InitAtomTable');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitAtomTable]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteAtom: Pointer;
--%%
--%% function DeleteAtom;
--%% begin
--%%   GetProcedureAddress(_DeleteAtom, kernel32, 'DeleteAtom');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteAtom]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetHandleCount: Pointer;
--%%
--%% function SetHandleCount;
--%% begin
--%%   GetProcedureAddress(_SetHandleCount, kernel32, 'SetHandleCount');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetHandleCount]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLogicalDrives: Pointer;
--%%
--%% function GetLogicalDrives;
--%% begin
--%%   GetProcedureAddress(_GetLogicalDrives, kernel32, 'GetLogicalDrives');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLogicalDrives]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LockFile: Pointer;
--%%
--%% function LockFile;
--%% begin
--%%   GetProcedureAddress(_LockFile, kernel32, 'LockFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LockFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UnlockFile: Pointer;
--%%
--%% function UnlockFile;
--%% begin
--%%   GetProcedureAddress(_UnlockFile, kernel32, 'UnlockFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UnlockFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LockFileEx: Pointer;
--%%
--%% function LockFileEx;
--%% begin
--%%   GetProcedureAddress(_LockFileEx, kernel32, 'LockFileEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LockFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UnlockFileEx: Pointer;
--%%
--%% function UnlockFileEx;
--%% begin
--%%   GetProcedureAddress(_UnlockFileEx, kernel32, 'UnlockFileEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UnlockFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileInformationByHandle: Pointer;
--%%
--%% function GetFileInformationByHandle;
--%% begin
--%%   GetProcedureAddress(_GetFileInformationByHandle, kernel32, 'GetFileInformationByHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileInformationByHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileType: Pointer;
--%%
--%% function GetFileType;
--%% begin
--%%   GetProcedureAddress(_GetFileType, kernel32, 'GetFileType');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileType]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileSize: Pointer;
--%%
--%% function GetFileSize;
--%% begin
--%%   GetProcedureAddress(_GetFileSize, kernel32, 'GetFileSize');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileSizeEx: Pointer;
--%%
--%% function GetFileSizeEx;
--%% begin
--%%   GetProcedureAddress(_GetFileSizeEx, kernel32, 'GetFileSizeEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileSizeEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetStdHandle: Pointer;
--%%
--%% function GetStdHandle;
--%% begin
--%%   GetProcedureAddress(_GetStdHandle, kernel32, 'GetStdHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetStdHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetStdHandle: Pointer;
--%%
--%% function SetStdHandle;
--%% begin
--%%   GetProcedureAddress(_SetStdHandle, kernel32, 'SetStdHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetStdHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteFile: Pointer;
--%%
--%% function WriteFile;
--%% begin
--%%   GetProcedureAddress(_WriteFile, kernel32, 'WriteFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadFile: Pointer;
--%%
--%% function ReadFile;
--%% begin
--%%   GetProcedureAddress(_ReadFile, kernel32, 'ReadFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlushFileBuffers: Pointer;
--%%
--%% function FlushFileBuffers;
--%% begin
--%%   GetProcedureAddress(_FlushFileBuffers, kernel32, 'FlushFileBuffers');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlushFileBuffers]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeviceIoControl: Pointer;
--%%
--%% function DeviceIoControl;
--%% begin
--%%   GetProcedureAddress(_DeviceIoControl, kernel32, 'DeviceIoControl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeviceIoControl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RequestDeviceWakeup: Pointer;
--%%
--%% function RequestDeviceWakeup;
--%% begin
--%%   GetProcedureAddress(_RequestDeviceWakeup, kernel32, 'RequestDeviceWakeup');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RequestDeviceWakeup]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CancelDeviceWakeupRequest: Pointer;
--%%
--%% function CancelDeviceWakeupRequest;
--%% begin
--%%   GetProcedureAddress(_CancelDeviceWakeupRequest, kernel32, 'CancelDeviceWakeupRequest');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CancelDeviceWakeupRequest]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDevicePowerState: Pointer;
--%%
--%% function GetDevicePowerState;
--%% begin
--%%   GetProcedureAddress(_GetDevicePowerState, kernel32, 'GetDevicePowerState');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDevicePowerState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetMessageWaitingIndicator: Pointer;
--%%
--%% function SetMessageWaitingIndicator;
--%% begin
--%%   GetProcedureAddress(_SetMessageWaitingIndicator, kernel32, 'SetMessageWaitingIndicator');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetMessageWaitingIndicator]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEndOfFile: Pointer;
--%%
--%% function SetEndOfFile;
--%% begin
--%%   GetProcedureAddress(_SetEndOfFile, kernel32, 'SetEndOfFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEndOfFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFilePointer: Pointer;
--%%
--%% function SetFilePointer;
--%% begin
--%%   GetProcedureAddress(_SetFilePointer, kernel32, 'SetFilePointer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFilePointer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFilePointerEx: Pointer;
--%%
--%% function SetFilePointerEx;
--%% begin
--%%   GetProcedureAddress(_SetFilePointerEx, kernel32, 'SetFilePointerEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFilePointerEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindClose: Pointer;
--%%
--%% function FindClose;
--%% begin
--%%   GetProcedureAddress(_FindClose, kernel32, 'FindClose');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindClose]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileTime: Pointer;
--%%
--%% function GetFileTime;
--%% begin
--%%   GetProcedureAddress(_GetFileTime, kernel32, 'GetFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileTime: Pointer;
--%%
--%% function SetFileTime;
--%% begin
--%%   GetProcedureAddress(_SetFileTime, kernel32, 'SetFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileValidData: Pointer;
--%%
--%% function SetFileValidData;
--%% begin
--%%   GetProcedureAddress(_SetFileValidData, kernel32, 'SetFileValidData');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileValidData]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileShortNameA: Pointer;
--%%
--%% function SetFileShortNameA;
--%% begin
--%%   GetProcedureAddress(_SetFileShortNameA, kernel32, 'SetFileShortNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileShortNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileShortNameW: Pointer;
--%%
--%% function SetFileShortNameW;
--%% begin
--%%   GetProcedureAddress(_SetFileShortNameW, kernel32, 'SetFileShortNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileShortNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileShortName: Pointer;
--%%
--%% function SetFileShortName;
--%% begin
--%%   GetProcedureAddress(_SetFileShortName, kernel32, 'SetFileShortName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileShortName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CloseHandle: Pointer;
--%%
--%% function CloseHandle;
--%% begin
--%%   GetProcedureAddress(_CloseHandle, kernel32, 'CloseHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CloseHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DuplicateHandle: Pointer;
--%%
--%% function DuplicateHandle;
--%% begin
--%%   GetProcedureAddress(_DuplicateHandle, kernel32, 'DuplicateHandle');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DuplicateHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetHandleInformation: Pointer;
--%%
--%% function GetHandleInformation;
--%% begin
--%%   GetProcedureAddress(_GetHandleInformation, kernel32, 'GetHandleInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetHandleInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetHandleInformation: Pointer;
--%%
--%% function SetHandleInformation;
--%% begin
--%%   GetProcedureAddress(_SetHandleInformation, kernel32, 'SetHandleInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetHandleInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadModule: Pointer;
--%%
--%% function LoadModule;
--%% begin
--%%   GetProcedureAddress(_LoadModule, kernel32, 'LoadModule');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadModule]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WinExec: Pointer;
--%%
--%% function WinExec;
--%% begin
--%%   GetProcedureAddress(_WinExec, kernel32, 'WinExec');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WinExec]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ClearCommBreak: Pointer;
--%%
--%% function ClearCommBreak;
--%% begin
--%%   GetProcedureAddress(_ClearCommBreak, kernel32, 'ClearCommBreak');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ClearCommBreak]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ClearCommError: Pointer;
--%%
--%% function ClearCommError;
--%% begin
--%%   GetProcedureAddress(_ClearCommError, kernel32, 'ClearCommError');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ClearCommError]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetupComm: Pointer;
--%%
--%% function SetupComm;
--%% begin
--%%   GetProcedureAddress(_SetupComm, kernel32, 'SetupComm');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetupComm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EscapeCommFunction: Pointer;
--%%
--%% function EscapeCommFunction;
--%% begin
--%%   GetProcedureAddress(_EscapeCommFunction, kernel32, 'EscapeCommFunction');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EscapeCommFunction]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommConfig: Pointer;
--%%
--%% function GetCommConfig;
--%% begin
--%%   GetProcedureAddress(_GetCommConfig, kernel32, 'GetCommConfig');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommConfig]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommMask: Pointer;
--%%
--%% function GetCommMask;
--%% begin
--%%   GetProcedureAddress(_GetCommMask, kernel32, 'GetCommMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommProperties: Pointer;
--%%
--%% function GetCommProperties;
--%% begin
--%%   GetProcedureAddress(_GetCommProperties, kernel32, 'GetCommProperties');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommProperties]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommModemStatus: Pointer;
--%%
--%% function GetCommModemStatus;
--%% begin
--%%   GetProcedureAddress(_GetCommModemStatus, kernel32, 'GetCommModemStatus');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommModemStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommState: Pointer;
--%%
--%% function GetCommState;
--%% begin
--%%   GetProcedureAddress(_GetCommState, kernel32, 'GetCommState');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommTimeouts: Pointer;
--%%
--%% function GetCommTimeouts;
--%% begin
--%%   GetProcedureAddress(_GetCommTimeouts, kernel32, 'GetCommTimeouts');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommTimeouts]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PurgeComm: Pointer;
--%%
--%% function PurgeComm;
--%% begin
--%%   GetProcedureAddress(_PurgeComm, kernel32, 'PurgeComm');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PurgeComm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCommBreak: Pointer;
--%%
--%% function SetCommBreak;
--%% begin
--%%   GetProcedureAddress(_SetCommBreak, kernel32, 'SetCommBreak');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCommBreak]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCommConfig: Pointer;
--%%
--%% function SetCommConfig;
--%% begin
--%%   GetProcedureAddress(_SetCommConfig, kernel32, 'SetCommConfig');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCommConfig]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCommMask: Pointer;
--%%
--%% function SetCommMask;
--%% begin
--%%   GetProcedureAddress(_SetCommMask, kernel32, 'SetCommMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCommMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCommState: Pointer;
--%%
--%% function SetCommState;
--%% begin
--%%   GetProcedureAddress(_SetCommState, kernel32, 'SetCommState');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCommState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCommTimeouts: Pointer;
--%%
--%% function SetCommTimeouts;
--%% begin
--%%   GetProcedureAddress(_SetCommTimeouts, kernel32, 'SetCommTimeouts');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCommTimeouts]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TransmitCommChar: Pointer;
--%%
--%% function TransmitCommChar;
--%% begin
--%%   GetProcedureAddress(_TransmitCommChar, kernel32, 'TransmitCommChar');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TransmitCommChar]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitCommEvent: Pointer;
--%%
--%% function WaitCommEvent;
--%% begin
--%%   GetProcedureAddress(_WaitCommEvent, kernel32, 'WaitCommEvent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitCommEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetTapePosition: Pointer;
--%%
--%% function SetTapePosition;
--%% begin
--%%   GetProcedureAddress(_SetTapePosition, kernel32, 'SetTapePosition');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetTapePosition]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTapePosition: Pointer;
--%%
--%% function GetTapePosition;
--%% begin
--%%   GetProcedureAddress(_GetTapePosition, kernel32, 'GetTapePosition');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTapePosition]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PrepareTape: Pointer;
--%%
--%% function PrepareTape;
--%% begin
--%%   GetProcedureAddress(_PrepareTape, kernel32, 'PrepareTape');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PrepareTape]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EraseTape: Pointer;
--%%
--%% function EraseTape;
--%% begin
--%%   GetProcedureAddress(_EraseTape, kernel32, 'EraseTape');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EraseTape]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateTapePartition: Pointer;
--%%
--%% function CreateTapePartition;
--%% begin
--%%   GetProcedureAddress(_CreateTapePartition, kernel32, 'CreateTapePartition');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateTapePartition]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteTapemark: Pointer;
--%%
--%% function WriteTapemark;
--%% begin
--%%   GetProcedureAddress(_WriteTapemark, kernel32, 'WriteTapemark');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteTapemark]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTapeStatus: Pointer;
--%%
--%% function GetTapeStatus;
--%% begin
--%%   GetProcedureAddress(_GetTapeStatus, kernel32, 'GetTapeStatus');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTapeStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTapeParameters: Pointer;
--%%
--%% function GetTapeParameters;
--%% begin
--%%   GetProcedureAddress(_GetTapeParameters, kernel32, 'GetTapeParameters');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTapeParameters]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetTapeParameters: Pointer;
--%%
--%% function SetTapeParameters;
--%% begin
--%%   GetProcedureAddress(_SetTapeParameters, kernel32, 'SetTapeParameters');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetTapeParameters]
--%%   end;
--%% end;
--%%
--%% var
--%%   _Beep: Pointer;
--%%
--%% function Beep;
--%% begin
--%%   GetProcedureAddress(_Beep, kernel32, 'Beep');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_Beep]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MulDiv: Pointer;
--%%
--%% function MulDiv;
--%% begin
--%%   GetProcedureAddress(_MulDiv, kernel32, 'MulDiv');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MulDiv]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemTime: Pointer;
--%%
--%% procedure GetSystemTime;
--%% begin
--%%   GetProcedureAddress(_GetSystemTime, kernel32, 'GetSystemTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemTimeAsFileTime: Pointer;
--%%
--%% procedure GetSystemTimeAsFileTime;
--%% begin
--%%   GetProcedureAddress(_GetSystemTimeAsFileTime, kernel32, 'GetSystemTimeAsFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemTimeAsFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSystemTime: Pointer;
--%%
--%% function SetSystemTime;
--%% begin
--%%   GetProcedureAddress(_SetSystemTime, kernel32, 'SetSystemTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSystemTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLocalTime: Pointer;
--%%
--%% procedure GetLocalTime;
--%% begin
--%%   GetProcedureAddress(_GetLocalTime, kernel32, 'GetLocalTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLocalTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetLocalTime: Pointer;
--%%
--%% function SetLocalTime;
--%% begin
--%%   GetProcedureAddress(_SetLocalTime, kernel32, 'SetLocalTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetLocalTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemInfo: Pointer;
--%%
--%% procedure GetSystemInfo;
--%% begin
--%%   GetProcedureAddress(_GetSystemInfo, kernel32, 'GetSystemInfo');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemRegistryQuota: Pointer;
--%%
--%% function GetSystemRegistryQuota;
--%% begin
--%%   GetProcedureAddress(_GetSystemRegistryQuota, kernel32, 'GetSystemRegistryQuota');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemRegistryQuota]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemTimes: Pointer;
--%%
--%% function GetSystemTimes;
--%% begin
--%%   GetProcedureAddress(_GetSystemTimes, kernel32, 'GetSystemTimes');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemTimes]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNativeSystemInfo: Pointer;
--%%
--%% procedure GetNativeSystemInfo;
--%% begin
--%%   GetProcedureAddress(_GetNativeSystemInfo, kernel32, 'GetNativeSystemInfo');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNativeSystemInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsProcessorFeaturePresent: Pointer;
--%%
--%% function IsProcessorFeaturePresent;
--%% begin
--%%   GetProcedureAddress(_IsProcessorFeaturePresent, kernel32, 'IsProcessorFeaturePresent');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsProcessorFeaturePresent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SystemTimeToTzSpecificLocalTime: Pointer;
--%%
--%% function SystemTimeToTzSpecificLocalTime;
--%% begin
--%%   GetProcedureAddress(_SystemTimeToTzSpecificLocalTime, kernel32, 'SystemTimeToTzSpecificLocalTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SystemTimeToTzSpecificLocalTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TzSpecificLocalTimeToSystemTime: Pointer;
--%%
--%% function TzSpecificLocalTimeToSystemTime;
--%% begin
--%%   GetProcedureAddress(_TzSpecificLocalTimeToSystemTime, kernel32, 'TzSpecificLocalTimeToSystemTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TzSpecificLocalTimeToSystemTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTimeZoneInformation: Pointer;
--%%
--%% function GetTimeZoneInformation;
--%% begin
--%%   GetProcedureAddress(_GetTimeZoneInformation, kernel32, 'GetTimeZoneInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTimeZoneInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetTimeZoneInformation: Pointer;
--%%
--%% function SetTimeZoneInformation;
--%% begin
--%%   GetProcedureAddress(_SetTimeZoneInformation, kernel32, 'SetTimeZoneInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetTimeZoneInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SystemTimeToFileTime: Pointer;
--%%
--%% function SystemTimeToFileTime;
--%% begin
--%%   GetProcedureAddress(_SystemTimeToFileTime, kernel32, 'SystemTimeToFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SystemTimeToFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FileTimeToLocalFileTime: Pointer;
--%%
--%% function FileTimeToLocalFileTime;
--%% begin
--%%   GetProcedureAddress(_FileTimeToLocalFileTime, kernel32, 'FileTimeToLocalFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FileTimeToLocalFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LocalFileTimeToFileTime: Pointer;
--%%
--%% function LocalFileTimeToFileTime;
--%% begin
--%%   GetProcedureAddress(_LocalFileTimeToFileTime, kernel32, 'LocalFileTimeToFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LocalFileTimeToFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FileTimeToSystemTime: Pointer;
--%%
--%% function FileTimeToSystemTime;
--%% begin
--%%   GetProcedureAddress(_FileTimeToSystemTime, kernel32, 'FileTimeToSystemTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FileTimeToSystemTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CompareFileTime: Pointer;
--%%
--%% function CompareFileTime;
--%% begin
--%%   GetProcedureAddress(_CompareFileTime, kernel32, 'CompareFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CompareFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FileTimeToDosDateTime: Pointer;
--%%
--%% function FileTimeToDosDateTime;
--%% begin
--%%   GetProcedureAddress(_FileTimeToDosDateTime, kernel32, 'FileTimeToDosDateTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FileTimeToDosDateTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DosDateTimeToFileTime: Pointer;
--%%
--%% function DosDateTimeToFileTime;
--%% begin
--%%   GetProcedureAddress(_DosDateTimeToFileTime, kernel32, 'DosDateTimeToFileTime');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DosDateTimeToFileTime]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTickCount: Pointer;
--%%
--%% function GetTickCount;
--%% begin
--%%   GetProcedureAddress(_GetTickCount, kernel32, 'GetTickCount');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTickCount]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSystemTimeAdjustment: Pointer;
--%%
--%% function SetSystemTimeAdjustment;
--%% begin
--%%   GetProcedureAddress(_SetSystemTimeAdjustment, kernel32, 'SetSystemTimeAdjustment');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSystemTimeAdjustment]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemTimeAdjustment: Pointer;
--%%
--%% function GetSystemTimeAdjustment;
--%% begin
--%%   GetProcedureAddress(_GetSystemTimeAdjustment, kernel32, 'GetSystemTimeAdjustment');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemTimeAdjustment]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FormatMessageA: Pointer;
--%%
--%% function FormatMessageA;
--%% begin
--%%   GetProcedureAddress(_FormatMessageA, kernel32, 'FormatMessageA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FormatMessageA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FormatMessageW: Pointer;
--%%
--%% function FormatMessageW;
--%% begin
--%%   GetProcedureAddress(_FormatMessageW, kernel32, 'FormatMessageW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FormatMessageW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FormatMessage: Pointer;
--%%
--%% function FormatMessage;
--%% begin
--%%   GetProcedureAddress(_FormatMessage, kernel32, 'FormatMessage' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FormatMessage]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreatePipe: Pointer;
--%%
--%% function CreatePipe;
--%% begin
--%%   GetProcedureAddress(_CreatePipe, kernel32, 'CreatePipe');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreatePipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ConnectNamedPipe: Pointer;
--%%
--%% function ConnectNamedPipe;
--%% begin
--%%   GetProcedureAddress(_ConnectNamedPipe, kernel32, 'ConnectNamedPipe');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ConnectNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DisconnectNamedPipe: Pointer;
--%%
--%% function DisconnectNamedPipe;
--%% begin
--%%   GetProcedureAddress(_DisconnectNamedPipe, kernel32, 'DisconnectNamedPipe');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DisconnectNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetNamedPipeHandleState: Pointer;
--%%
--%% function SetNamedPipeHandleState;
--%% begin
--%%   GetProcedureAddress(_SetNamedPipeHandleState, kernel32, 'SetNamedPipeHandleState');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetNamedPipeHandleState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNamedPipeInfo: Pointer;
--%%
--%% function GetNamedPipeInfo;
--%% begin
--%%   GetProcedureAddress(_GetNamedPipeInfo, kernel32, 'GetNamedPipeInfo');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNamedPipeInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PeekNamedPipe: Pointer;
--%%
--%% function PeekNamedPipe;
--%% begin
--%%   GetProcedureAddress(_PeekNamedPipe, kernel32, 'PeekNamedPipe');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PeekNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TransactNamedPipe: Pointer;
--%%
--%% function TransactNamedPipe;
--%% begin
--%%   GetProcedureAddress(_TransactNamedPipe, kernel32, 'TransactNamedPipe');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TransactNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateMailslotA: Pointer;
--%%
--%% function CreateMailslotA;
--%% begin
--%%   GetProcedureAddress(_CreateMailslotA, kernel32, 'CreateMailslotA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateMailslotA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateMailslotW: Pointer;
--%%
--%% function CreateMailslotW;
--%% begin
--%%   GetProcedureAddress(_CreateMailslotW, kernel32, 'CreateMailslotW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateMailslotW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateMailslot: Pointer;
--%%
--%% function CreateMailslot;
--%% begin
--%%   GetProcedureAddress(_CreateMailslot, kernel32, 'CreateMailslot' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateMailslot]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetMailslotInfo: Pointer;
--%%
--%% function GetMailslotInfo;
--%% begin
--%%   GetProcedureAddress(_GetMailslotInfo, kernel32, 'GetMailslotInfo');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetMailslotInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetMailslotInfo: Pointer;
--%%
--%% function SetMailslotInfo;
--%% begin
--%%   GetProcedureAddress(_SetMailslotInfo, kernel32, 'SetMailslotInfo');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetMailslotInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MapViewOfFile: Pointer;
--%%
--%% function MapViewOfFile;
--%% begin
--%%   GetProcedureAddress(_MapViewOfFile, kernel32, 'MapViewOfFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MapViewOfFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlushViewOfFile: Pointer;
--%%
--%% function FlushViewOfFile;
--%% begin
--%%   GetProcedureAddress(_FlushViewOfFile, kernel32, 'FlushViewOfFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlushViewOfFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UnmapViewOfFile: Pointer;
--%%
--%% function UnmapViewOfFile;
--%% begin
--%%   GetProcedureAddress(_UnmapViewOfFile, kernel32, 'UnmapViewOfFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UnmapViewOfFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EncryptFileA: Pointer;
--%%
--%% function EncryptFileA;
--%% begin
--%%   GetProcedureAddress(_EncryptFileA, advapi32, 'EncryptFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EncryptFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EncryptFileW: Pointer;
--%%
--%% function EncryptFileW;
--%% begin
--%%   GetProcedureAddress(_EncryptFileW, advapi32, 'EncryptFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EncryptFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EncryptFile: Pointer;
--%%
--%% function EncryptFile;
--%% begin
--%%   GetProcedureAddress(_EncryptFile, advapi32, 'EncryptFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EncryptFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DecryptFileA: Pointer;
--%%
--%% function DecryptFileA;
--%% begin
--%%   GetProcedureAddress(_DecryptFileA, advapi32, 'DecryptFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DecryptFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DecryptFileW: Pointer;
--%%
--%% function DecryptFileW;
--%% begin
--%%   GetProcedureAddress(_DecryptFileW, advapi32, 'DecryptFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DecryptFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DecryptFile: Pointer;
--%%
--%% function DecryptFile;
--%% begin
--%%   GetProcedureAddress(_DecryptFile, advapi32, 'DecryptFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DecryptFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FileEncryptionStatusA: Pointer;
--%%
--%% function FileEncryptionStatusA;
--%% begin
--%%   GetProcedureAddress(_FileEncryptionStatusA, advapi32, 'FileEncryptionStatusA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FileEncryptionStatusA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FileEncryptionStatusW: Pointer;
--%%
--%% function FileEncryptionStatusW;
--%% begin
--%%   GetProcedureAddress(_FileEncryptionStatusW, advapi32, 'FileEncryptionStatusW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FileEncryptionStatusW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FileEncryptionStatus: Pointer;
--%%
--%% function FileEncryptionStatus;
--%% begin
--%%   GetProcedureAddress(_FileEncryptionStatus, advapi32, 'FileEncryptionStatus' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FileEncryptionStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEncryptedFileRawA: Pointer;
--%%
--%% function OpenEncryptedFileRawA;
--%% begin
--%%   GetProcedureAddress(_OpenEncryptedFileRawA, advapi32, 'OpenEncryptedFileRawA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEncryptedFileRawA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEncryptedFileRawW: Pointer;
--%%
--%% function OpenEncryptedFileRawW;
--%% begin
--%%   GetProcedureAddress(_OpenEncryptedFileRawW, advapi32, 'OpenEncryptedFileRawW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEncryptedFileRawW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEncryptedFileRaw: Pointer;
--%%
--%% function OpenEncryptedFileRaw;
--%% begin
--%%   GetProcedureAddress(_OpenEncryptedFileRaw, advapi32, 'OpenEncryptedFileRaw' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEncryptedFileRaw]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadEncryptedFileRaw: Pointer;
--%%
--%% function ReadEncryptedFileRaw;
--%% begin
--%%   GetProcedureAddress(_ReadEncryptedFileRaw, advapi32, 'ReadEncryptedFileRaw');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadEncryptedFileRaw]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteEncryptedFileRaw: Pointer;
--%%
--%% function WriteEncryptedFileRaw;
--%% begin
--%%   GetProcedureAddress(_WriteEncryptedFileRaw, advapi32, 'WriteEncryptedFileRaw');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteEncryptedFileRaw]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CloseEncryptedFileRaw: Pointer;
--%%
--%% procedure CloseEncryptedFileRaw;
--%% begin
--%%   GetProcedureAddress(_CloseEncryptedFileRaw, advapi32, 'CloseEncryptedFileRaw');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CloseEncryptedFileRaw]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcmpA: Pointer;
--%%
--%% function lstrcmpA;
--%% begin
--%%   GetProcedureAddress(_lstrcmpA, kernel32, 'lstrcmpA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcmpA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcmpW: Pointer;
--%%
--%% function lstrcmpW;
--%% begin
--%%   GetProcedureAddress(_lstrcmpW, kernel32, 'lstrcmpW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcmpW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcmp: Pointer;
--%%
--%% function lstrcmp;
--%% begin
--%%   GetProcedureAddress(_lstrcmp, kernel32, 'lstrcmp' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcmp]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcmpiA: Pointer;
--%%
--%% function lstrcmpiA;
--%% begin
--%%   GetProcedureAddress(_lstrcmpiA, kernel32, 'lstrcmpiA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcmpiA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcmpiW: Pointer;
--%%
--%% function lstrcmpiW;
--%% begin
--%%   GetProcedureAddress(_lstrcmpiW, kernel32, 'lstrcmpiW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcmpiW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcmpi: Pointer;
--%%
--%% function lstrcmpi;
--%% begin
--%%   GetProcedureAddress(_lstrcmpi, kernel32, 'lstrcmpi' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcmpi]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcpynA: Pointer;
--%%
--%% function lstrcpynA;
--%% begin
--%%   GetProcedureAddress(_lstrcpynA, kernel32, 'lstrcpynA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcpynA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcpynW: Pointer;
--%%
--%% function lstrcpynW;
--%% begin
--%%   GetProcedureAddress(_lstrcpynW, kernel32, 'lstrcpynW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcpynW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcpyn: Pointer;
--%%
--%% function lstrcpyn;
--%% begin
--%%   GetProcedureAddress(_lstrcpyn, kernel32, 'lstrcpyn' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcpyn]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcpyA: Pointer;
--%%
--%% function lstrcpyA;
--%% begin
--%%   GetProcedureAddress(_lstrcpyA, kernel32, 'lstrcpyA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcpyA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcpyW: Pointer;
--%%
--%% function lstrcpyW;
--%% begin
--%%   GetProcedureAddress(_lstrcpyW, kernel32, 'lstrcpyW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcpyW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcpy: Pointer;
--%%
--%% function lstrcpy;
--%% begin
--%%   GetProcedureAddress(_lstrcpy, kernel32, 'lstrcpy' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcpy]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcatA: Pointer;
--%%
--%% function lstrcatA;
--%% begin
--%%   GetProcedureAddress(_lstrcatA, kernel32, 'lstrcatA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcatA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcatW: Pointer;
--%%
--%% function lstrcatW;
--%% begin
--%%   GetProcedureAddress(_lstrcatW, kernel32, 'lstrcatW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcatW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrcat: Pointer;
--%%
--%% function lstrcat;
--%% begin
--%%   GetProcedureAddress(_lstrcat, kernel32, 'lstrcat' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrcat]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrlenA: Pointer;
--%%
--%% function lstrlenA;
--%% begin
--%%   GetProcedureAddress(_lstrlenA, kernel32, 'lstrlenA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrlenA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrlenW: Pointer;
--%%
--%% function lstrlenW;
--%% begin
--%%   GetProcedureAddress(_lstrlenW, kernel32, 'lstrlenW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrlenW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _lstrlen: Pointer;
--%%
--%% function lstrlen;
--%% begin
--%%   GetProcedureAddress(_lstrlen, kernel32, 'lstrlen' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_lstrlen]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenFile: Pointer;
--%%
--%% function OpenFile;
--%% begin
--%%   GetProcedureAddress(_OpenFile, kernel32, 'OpenFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   __lopen: Pointer;
--%%
--%% function _lopen;
--%% begin
--%%   GetProcedureAddress(__lopen, kernel32, '_lopen');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__lopen]
--%%   end;
--%% end;
--%%
--%% var
--%%   __lcreat: Pointer;
--%%
--%% function _lcreat;
--%% begin
--%%   GetProcedureAddress(__lcreat, kernel32, '_lcreat');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__lcreat]
--%%   end;
--%% end;
--%%
--%% var
--%%   __lread: Pointer;
--%%
--%% function _lread;
--%% begin
--%%   GetProcedureAddress(__lread, kernel32, '_lread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__lread]
--%%   end;
--%% end;
--%%
--%% var
--%%   __lwrite: Pointer;
--%%
--%% function _lwrite;
--%% begin
--%%   GetProcedureAddress(__lwrite, kernel32, '_lwrite');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__lwrite]
--%%   end;
--%% end;
--%%
--%% var
--%%   __hread: Pointer;
--%%
--%% function _hread;
--%% begin
--%%   GetProcedureAddress(__hread, kernel32, '_hread');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__hread]
--%%   end;
--%% end;
--%%
--%% var
--%%   __hwrite: Pointer;
--%%
--%% function _hwrite;
--%% begin
--%%   GetProcedureAddress(__hwrite, kernel32, '_hwrite');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__hwrite]
--%%   end;
--%% end;
--%%
--%% var
--%%   __lclose: Pointer;
--%%
--%% function _lclose;
--%% begin
--%%   GetProcedureAddress(__lclose, kernel32, '_lclose');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__lclose]
--%%   end;
--%% end;
--%%
--%% var
--%%   __llseek: Pointer;
--%%
--%% function _llseek;
--%% begin
--%%   GetProcedureAddress(__llseek, kernel32, '_llseek');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [__llseek]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsTextUnicode: Pointer;
--%%
--%% function IsTextUnicode;
--%% begin
--%%   GetProcedureAddress(_IsTextUnicode, advapi32, 'IsTextUnicode');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsTextUnicode]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlsAlloc: Pointer;
--%%
--%% function FlsAlloc;
--%% begin
--%%   GetProcedureAddress(_FlsAlloc, kernel32, 'FlsAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlsAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlsGetValue: Pointer;
--%%
--%% function FlsGetValue;
--%% begin
--%%   GetProcedureAddress(_FlsGetValue, kernel32, 'FlsGetValue');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlsGetValue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlsSetValue: Pointer;
--%%
--%% function FlsSetValue;
--%% begin
--%%   GetProcedureAddress(_FlsSetValue, kernel32, 'FlsSetValue');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlsSetValue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FlsFree: Pointer;
--%%
--%% function FlsFree;
--%% begin
--%%   GetProcedureAddress(_FlsFree, kernel32, 'FlsFree');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FlsFree]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TlsAlloc: Pointer;
--%%
--%% function TlsAlloc;
--%% begin
--%%   GetProcedureAddress(_TlsAlloc, kernel32, 'TlsAlloc');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TlsAlloc]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TlsGetValue: Pointer;
--%%
--%% function TlsGetValue;
--%% begin
--%%   GetProcedureAddress(_TlsGetValue, kernel32, 'TlsGetValue');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TlsGetValue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TlsSetValue: Pointer;
--%%
--%% function TlsSetValue;
--%% begin
--%%   GetProcedureAddress(_TlsSetValue, kernel32, 'TlsSetValue');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TlsSetValue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TlsFree: Pointer;
--%%
--%% function TlsFree;
--%% begin
--%%   GetProcedureAddress(_TlsFree, kernel32, 'TlsFree');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TlsFree]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SleepEx: Pointer;
--%%
--%% function SleepEx;
--%% begin
--%%   GetProcedureAddress(_SleepEx, kernel32, 'SleepEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SleepEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitForSingleObjectEx: Pointer;
--%%
--%% function WaitForSingleObjectEx;
--%% begin
--%%   GetProcedureAddress(_WaitForSingleObjectEx, kernel32, 'WaitForSingleObjectEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitForSingleObjectEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitForMultipleObjectsEx: Pointer;
--%%
--%% function WaitForMultipleObjectsEx;
--%% begin
--%%   GetProcedureAddress(_WaitForMultipleObjectsEx, kernel32, 'WaitForMultipleObjectsEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitForMultipleObjectsEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SignalObjectAndWait: Pointer;
--%%
--%% function SignalObjectAndWait;
--%% begin
--%%   GetProcedureAddress(_SignalObjectAndWait, kernel32, 'SignalObjectAndWait');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SignalObjectAndWait]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadFileEx: Pointer;
--%%
--%% function ReadFileEx;
--%% begin
--%%   GetProcedureAddress(_ReadFileEx, kernel32, 'ReadFileEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteFileEx: Pointer;
--%%
--%% function WriteFileEx;
--%% begin
--%%   GetProcedureAddress(_WriteFileEx, kernel32, 'WriteFileEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BackupRead: Pointer;
--%%
--%% function BackupRead;
--%% begin
--%%   GetProcedureAddress(_BackupRead, kernel32, 'BackupRead');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BackupRead]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BackupSeek: Pointer;
--%%
--%% function BackupSeek;
--%% begin
--%%   GetProcedureAddress(_BackupSeek, kernel32, 'BackupSeek');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BackupSeek]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BackupWrite: Pointer;
--%%
--%% function BackupWrite;
--%% begin
--%%   GetProcedureAddress(_BackupWrite, kernel32, 'BackupWrite');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BackupWrite]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadFileScatter: Pointer;
--%%
--%% function ReadFileScatter;
--%% begin
--%%   GetProcedureAddress(_ReadFileScatter, kernel32, 'ReadFileScatter');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadFileScatter]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteFileGather: Pointer;
--%%
--%% function WriteFileGather;
--%% begin
--%%   GetProcedureAddress(_WriteFileGather, kernel32, 'WriteFileGather');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteFileGather]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenMutexA: Pointer;
--%%
--%% function OpenMutexA;
--%% begin
--%%   GetProcedureAddress(_OpenMutexA, kernel32, 'OpenMutexA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenMutexA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenMutexW: Pointer;
--%%
--%% function OpenMutexW;
--%% begin
--%%   GetProcedureAddress(_OpenMutexW, kernel32, 'OpenMutexW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenMutexW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenMutex: Pointer;
--%%
--%% function OpenMutex;
--%% begin
--%%   GetProcedureAddress(_OpenMutex, kernel32, 'OpenMutex' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenMutex]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateEventA: Pointer;
--%%
--%% function CreateEventA;
--%% begin
--%%   GetProcedureAddress(_CreateEventA, kernel32, 'CreateEventA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateEventA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateEventW: Pointer;
--%%
--%% function CreateEventW;
--%% begin
--%%   GetProcedureAddress(_CreateEventW, kernel32, 'CreateEventW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateEventW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateEvent: Pointer;
--%%
--%% function CreateEvent;
--%% begin
--%%   GetProcedureAddress(_CreateEvent, kernel32, 'CreateEvent' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEventA: Pointer;
--%%
--%% function OpenEventA;
--%% begin
--%%   GetProcedureAddress(_OpenEventA, kernel32, 'OpenEventA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEventA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEventW: Pointer;
--%%
--%% function OpenEventW;
--%% begin
--%%   GetProcedureAddress(_OpenEventW, kernel32, 'OpenEventW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEventW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEvent: Pointer;
--%%
--%% function OpenEvent;
--%% begin
--%%   GetProcedureAddress(_OpenEvent, kernel32, 'OpenEvent' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateSemaphoreA: Pointer;
--%%
--%% function CreateSemaphoreA;
--%% begin
--%%   GetProcedureAddress(_CreateSemaphoreA, kernel32, 'CreateSemaphoreA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateSemaphoreA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateSemaphoreW: Pointer;
--%%
--%% function CreateSemaphoreW;
--%% begin
--%%   GetProcedureAddress(_CreateSemaphoreW, kernel32, 'CreateSemaphoreW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateSemaphoreW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateSemaphore: Pointer;
--%%
--%% function CreateSemaphore;
--%% begin
--%%   GetProcedureAddress(_CreateSemaphore, kernel32, 'CreateSemaphore' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateSemaphore]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenSemaphoreA: Pointer;
--%%
--%% function OpenSemaphoreA;
--%% begin
--%%   GetProcedureAddress(_OpenSemaphoreA, kernel32, 'OpenSemaphoreA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenSemaphoreA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenSemaphoreW: Pointer;
--%%
--%% function OpenSemaphoreW;
--%% begin
--%%   GetProcedureAddress(_OpenSemaphoreW, kernel32, 'OpenSemaphoreW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenSemaphoreW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenSemaphore: Pointer;
--%%
--%% function OpenSemaphore;
--%% begin
--%%   GetProcedureAddress(_OpenSemaphore, kernel32, 'OpenSemaphore' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenSemaphore]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateWaitableTimerA: Pointer;
--%%
--%% function CreateWaitableTimerA;
--%% begin
--%%   GetProcedureAddress(_CreateWaitableTimerA, kernel32, 'CreateWaitableTimerA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateWaitableTimerA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateWaitableTimerW: Pointer;
--%%
--%% function CreateWaitableTimerW;
--%% begin
--%%   GetProcedureAddress(_CreateWaitableTimerW, kernel32, 'CreateWaitableTimerW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateWaitableTimerW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateWaitableTimer: Pointer;
--%%
--%% function CreateWaitableTimer;
--%% begin
--%%   GetProcedureAddress(_CreateWaitableTimer, kernel32, 'CreateWaitableTimer' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateWaitableTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenWaitableTimerA: Pointer;
--%%
--%% function OpenWaitableTimerA;
--%% begin
--%%   GetProcedureAddress(_OpenWaitableTimerA, kernel32, 'OpenWaitableTimerA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenWaitableTimerA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenWaitableTimerW: Pointer;
--%%
--%% function OpenWaitableTimerW;
--%% begin
--%%   GetProcedureAddress(_OpenWaitableTimerW, kernel32, 'OpenWaitableTimerW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenWaitableTimerW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenWaitableTimer: Pointer;
--%%
--%% function OpenWaitableTimer;
--%% begin
--%%   GetProcedureAddress(_OpenWaitableTimer, kernel32, 'OpenWaitableTimer' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenWaitableTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetWaitableTimer: Pointer;
--%%
--%% function SetWaitableTimer;
--%% begin
--%%   GetProcedureAddress(_SetWaitableTimer, kernel32, 'SetWaitableTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetWaitableTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CancelWaitableTimer: Pointer;
--%%
--%% function CancelWaitableTimer;
--%% begin
--%%   GetProcedureAddress(_CancelWaitableTimer, kernel32, 'CancelWaitableTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CancelWaitableTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFileMappingA: Pointer;
--%%
--%% function CreateFileMappingA;
--%% begin
--%%   GetProcedureAddress(_CreateFileMappingA, kernel32, 'CreateFileMappingA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFileMappingA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFileMappingW: Pointer;
--%%
--%% function CreateFileMappingW;
--%% begin
--%%   GetProcedureAddress(_CreateFileMappingW, kernel32, 'CreateFileMappingW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFileMappingW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFileMapping: Pointer;
--%%
--%% function CreateFileMapping;
--%% begin
--%%   GetProcedureAddress(_CreateFileMapping, kernel32, 'CreateFileMapping' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFileMapping]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenFileMappingA: Pointer;
--%%
--%% function OpenFileMappingA;
--%% begin
--%%   GetProcedureAddress(_OpenFileMappingA, kernel32, 'OpenFileMappingA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenFileMappingA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenFileMappingW: Pointer;
--%%
--%% function OpenFileMappingW;
--%% begin
--%%   GetProcedureAddress(_OpenFileMappingW, kernel32, 'OpenFileMappingW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenFileMappingW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenFileMapping: Pointer;
--%%
--%% function OpenFileMapping;
--%% begin
--%%   GetProcedureAddress(_OpenFileMapping, kernel32, 'OpenFileMapping' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenFileMapping]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLogicalDriveStringsA: Pointer;
--%%
--%% function GetLogicalDriveStringsA;
--%% begin
--%%   GetProcedureAddress(_GetLogicalDriveStringsA, kernel32, 'GetLogicalDriveStringsA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLogicalDriveStringsA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLogicalDriveStringsW: Pointer;
--%%
--%% function GetLogicalDriveStringsW;
--%% begin
--%%   GetProcedureAddress(_GetLogicalDriveStringsW, kernel32, 'GetLogicalDriveStringsW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLogicalDriveStringsW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLogicalDriveStrings: Pointer;
--%%
--%% function GetLogicalDriveStrings;
--%% begin
--%%   GetProcedureAddress(_GetLogicalDriveStrings, kernel32, 'GetLogicalDriveStrings' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLogicalDriveStrings]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateMemResNotification: Pointer;
--%%
--%% function CreateMemoryResourceNotification;
--%% begin
--%%   GetProcedureAddress(_CreateMemResNotification, kernel32, 'CreateMemoryResourceNotification');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateMemResNotification]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryMemoryResourceNotification: Pointer;
--%%
--%% function QueryMemoryResourceNotification;
--%% begin
--%%   GetProcedureAddress(_QueryMemoryResourceNotification, kernel32, 'QueryMemoryResourceNotification');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryMemoryResourceNotification]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadLibraryA: Pointer;
--%%
--%% function LoadLibraryA;
--%% begin
--%%   GetProcedureAddress(_LoadLibraryA, kernel32, 'LoadLibraryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadLibraryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadLibraryW: Pointer;
--%%
--%% function LoadLibraryW;
--%% begin
--%%   GetProcedureAddress(_LoadLibraryW, kernel32, 'LoadLibraryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadLibraryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadLibrary: Pointer;
--%%
--%% function LoadLibrary;
--%% begin
--%%   GetProcedureAddress(_LoadLibrary, kernel32, 'LoadLibrary' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadLibrary]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadLibraryExA: Pointer;
--%%
--%% function LoadLibraryExA;
--%% begin
--%%   GetProcedureAddress(_LoadLibraryExA, kernel32, 'LoadLibraryExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadLibraryExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadLibraryExW: Pointer;
--%%
--%% function LoadLibraryExW;
--%% begin
--%%   GetProcedureAddress(_LoadLibraryExW, kernel32, 'LoadLibraryExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadLibraryExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LoadLibraryEx: Pointer;
--%%
--%% function LoadLibraryEx;
--%% begin
--%%   GetProcedureAddress(_LoadLibraryEx, kernel32, 'LoadLibraryEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LoadLibraryEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleFileNameA: Pointer;
--%%
--%% function GetModuleFileNameA;
--%% begin
--%%   GetProcedureAddress(_GetModuleFileNameA, kernel32, 'GetModuleFileNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleFileNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleFileNameW: Pointer;
--%%
--%% function GetModuleFileNameW;
--%% begin
--%%   GetProcedureAddress(_GetModuleFileNameW, kernel32, 'GetModuleFileNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleFileNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleFileName: Pointer;
--%%
--%% function GetModuleFileName;
--%% begin
--%%   GetProcedureAddress(_GetModuleFileName, kernel32, 'GetModuleFileName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleFileName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleHandleA: Pointer;
--%%
--%% function GetModuleHandleA;
--%% begin
--%%   GetProcedureAddress(_GetModuleHandleA, kernel32, 'GetModuleHandleA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleHandleA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleHandleW: Pointer;
--%%
--%% function GetModuleHandleW;
--%% begin
--%%   GetProcedureAddress(_GetModuleHandleW, kernel32, 'GetModuleHandleW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleHandleW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleHandle: Pointer;
--%%
--%% function GetModuleHandle;
--%% begin
--%%   GetProcedureAddress(_GetModuleHandle, kernel32, 'GetModuleHandle' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleHandle]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessA: Pointer;
--%%
--%% function CreateProcessA;
--%% begin
--%%   GetProcedureAddress(_CreateProcessA, kernel32, 'CreateProcessA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessW: Pointer;
--%%
--%% function CreateProcessW;
--%% begin
--%%   GetProcedureAddress(_CreateProcessW, kernel32, 'CreateProcessW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcess: Pointer;
--%%
--%% function CreateProcess;
--%% begin
--%%   GetProcedureAddress(_CreateProcess, kernel32, 'CreateProcess' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcess]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleHandleExA: Pointer;
--%%
--%% function GetModuleHandleExA;
--%% begin
--%%   GetProcedureAddress(_GetModuleHandleExA, kernel32, 'GetModuleHandleExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleHandleExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleHandleExW: Pointer;
--%%
--%% function GetModuleHandleExW;
--%% begin
--%%   GetProcedureAddress(_GetModuleHandleExW, kernel32, 'GetModuleHandleExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleHandleExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetModuleHandleEx: Pointer;
--%%
--%% function GetModuleHandleEx;
--%% begin
--%%   GetProcedureAddress(_GetModuleHandleEx, kernel32, 'GetModuleHandleEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetModuleHandleEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _NeedCurrentDirectoryForExePathA: Pointer;
--%%
--%% function NeedCurrentDirectoryForExePathA;
--%% begin
--%%   GetProcedureAddress(_NeedCurrentDirectoryForExePathA, kernel32, 'NeedCurrentDirectoryForExePathA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_NeedCurrentDirectoryForExePathA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _NeedCurrentDirectoryForExePathW: Pointer;
--%%
--%% function NeedCurrentDirectoryForExePathW;
--%% begin
--%%   GetProcedureAddress(_NeedCurrentDirectoryForExePathW, kernel32, 'NeedCurrentDirectoryForExePathW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_NeedCurrentDirectoryForExePathW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _NeedCurrentDirectoryForExePath: Pointer;
--%%
--%% function NeedCurrentDirectoryForExePath;
--%% begin
--%%   GetProcedureAddress(_NeedCurrentDirectoryForExePath, kernel32, 'NeedCurrentDirectoryForExePath' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_NeedCurrentDirectoryForExePath]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetProcessShutdownParameters: Pointer;
--%%
--%% function SetProcessShutdownParameters;
--%% begin
--%%   GetProcedureAddress(_SetProcessShutdownParameters, kernel32, 'SetProcessShutdownParameters');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetProcessShutdownParameters]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessShutdownParameters: Pointer;
--%%
--%% function GetProcessShutdownParameters;
--%% begin
--%%   GetProcedureAddress(_GetProcessShutdownParameters, kernel32, 'GetProcessShutdownParameters');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessShutdownParameters]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProcessVersion: Pointer;
--%%
--%% function GetProcessVersion;
--%% begin
--%%   GetProcedureAddress(_GetProcessVersion, kernel32, 'GetProcessVersion');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProcessVersion]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FatalAppExitA: Pointer;
--%%
--%% procedure FatalAppExitA;
--%% begin
--%%   GetProcedureAddress(_FatalAppExitA, kernel32, 'FatalAppExitA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FatalAppExitA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FatalAppExitW: Pointer;
--%%
--%% procedure FatalAppExitW;
--%% begin
--%%   GetProcedureAddress(_FatalAppExitW, kernel32, 'FatalAppExitW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FatalAppExitW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FatalAppExit: Pointer;
--%%
--%% procedure FatalAppExit;
--%% begin
--%%   GetProcedureAddress(_FatalAppExit, kernel32, 'FatalAppExit' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FatalAppExit]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetStartupInfoA: Pointer;
--%%
--%% procedure GetStartupInfoA;
--%% begin
--%%   GetProcedureAddress(_GetStartupInfoA, kernel32, 'GetStartupInfoA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetStartupInfoA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetStartupInfoW: Pointer;
--%%
--%% procedure GetStartupInfoW;
--%% begin
--%%   GetProcedureAddress(_GetStartupInfoW, kernel32, 'GetStartupInfoW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetStartupInfoW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetStartupInfo: Pointer;
--%%
--%% procedure GetStartupInfo;
--%% begin
--%%   GetProcedureAddress(_GetStartupInfo, kernel32, 'GetStartupInfo' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetStartupInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommandLineA: Pointer;
--%%
--%% function GetCommandLineA;
--%% begin
--%%   GetProcedureAddress(_GetCommandLineA, kernel32, 'GetCommandLineA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommandLineA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommandLineW: Pointer;
--%%
--%% function GetCommandLineW;
--%% begin
--%%   GetProcedureAddress(_GetCommandLineW, kernel32, 'GetCommandLineW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommandLineW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCommandLine: Pointer;
--%%
--%% function GetCommandLine;
--%% begin
--%%   GetProcedureAddress(_GetCommandLine, kernel32, 'GetCommandLine' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCommandLine]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetEnvironmentVariableA: Pointer;
--%%
--%% function GetEnvironmentVariableA;
--%% begin
--%%   GetProcedureAddress(_GetEnvironmentVariableA, kernel32, 'GetEnvironmentVariableA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEnvironmentVariableA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetEnvironmentVariableW: Pointer;
--%%
--%% function GetEnvironmentVariableW;
--%% begin
--%%   GetProcedureAddress(_GetEnvironmentVariableW, kernel32, 'GetEnvironmentVariableW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEnvironmentVariableW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetEnvironmentVariable: Pointer;
--%%
--%% function GetEnvironmentVariable;
--%% begin
--%%   GetProcedureAddress(_GetEnvironmentVariable, kernel32, 'GetEnvironmentVariable' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEnvironmentVariable]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEnvironmentVariableA: Pointer;
--%%
--%% function SetEnvironmentVariableA;
--%% begin
--%%   GetProcedureAddress(_SetEnvironmentVariableA, kernel32, 'SetEnvironmentVariableA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEnvironmentVariableA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEnvironmentVariableW: Pointer;
--%%
--%% function SetEnvironmentVariableW;
--%% begin
--%%   GetProcedureAddress(_SetEnvironmentVariableW, kernel32, 'SetEnvironmentVariableW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEnvironmentVariableW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetEnvironmentVariable: Pointer;
--%%
--%% function SetEnvironmentVariable;
--%% begin
--%%   GetProcedureAddress(_SetEnvironmentVariable, kernel32, 'SetEnvironmentVariable' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetEnvironmentVariable]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ExpandEnvironmentStringsA: Pointer;
--%%
--%% function ExpandEnvironmentStringsA;
--%% begin
--%%   GetProcedureAddress(_ExpandEnvironmentStringsA, kernel32, 'ExpandEnvironmentStringsA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ExpandEnvironmentStringsA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ExpandEnvironmentStringsW: Pointer;
--%%
--%% function ExpandEnvironmentStringsW;
--%% begin
--%%   GetProcedureAddress(_ExpandEnvironmentStringsW, kernel32, 'ExpandEnvironmentStringsW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ExpandEnvironmentStringsW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ExpandEnvironmentStrings: Pointer;
--%%
--%% function ExpandEnvironmentStrings;
--%% begin
--%%   GetProcedureAddress(_ExpandEnvironmentStrings, kernel32, 'ExpandEnvironmentStrings' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ExpandEnvironmentStrings]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFirmwareEnvironmentVariableA: Pointer;
--%%
--%% function GetFirmwareEnvironmentVariableA;
--%% begin
--%%   GetProcedureAddress(_GetFirmwareEnvironmentVariableA, kernel32, 'GetFirmwareEnvironmentVariableA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFirmwareEnvironmentVariableA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFirmwareEnvironmentVariableW: Pointer;
--%%
--%% function GetFirmwareEnvironmentVariableW;
--%% begin
--%%   GetProcedureAddress(_GetFirmwareEnvironmentVariableW, kernel32, 'GetFirmwareEnvironmentVariableW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFirmwareEnvironmentVariableW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFirmwareEnvironmentVariable: Pointer;
--%%
--%% function GetFirmwareEnvironmentVariable;
--%% begin
--%%   GetProcedureAddress(_GetFirmwareEnvironmentVariable, kernel32, 'GetFirmwareEnvironmentVariable' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFirmwareEnvironmentVariable]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFirmwareEnvironmentVariableA: Pointer;
--%%
--%% function SetFirmwareEnvironmentVariableA;
--%% begin
--%%   GetProcedureAddress(_SetFirmwareEnvironmentVariableA, kernel32, 'SetFirmwareEnvironmentVariableA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFirmwareEnvironmentVariableA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFirmwareEnvironmentVariableW: Pointer;
--%%
--%% function SetFirmwareEnvironmentVariableW;
--%% begin
--%%   GetProcedureAddress(_SetFirmwareEnvironmentVariableW, kernel32, 'SetFirmwareEnvironmentVariableW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFirmwareEnvironmentVariableW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFirmwareEnvironmentVariable: Pointer;
--%%
--%% function SetFirmwareEnvironmentVariable;
--%% begin
--%%   GetProcedureAddress(_SetFirmwareEnvironmentVariable, kernel32, 'SetFirmwareEnvironmentVariable' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFirmwareEnvironmentVariable]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OutputDebugStringA: Pointer;
--%%
--%% procedure OutputDebugStringA;
--%% begin
--%%   GetProcedureAddress(_OutputDebugStringA, kernel32, 'OutputDebugStringA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OutputDebugStringA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OutputDebugStringW: Pointer;
--%%
--%% procedure OutputDebugStringW;
--%% begin
--%%   GetProcedureAddress(_OutputDebugStringW, kernel32, 'OutputDebugStringW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OutputDebugStringW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OutputDebugString: Pointer;
--%%
--%% procedure OutputDebugString;
--%% begin
--%%   GetProcedureAddress(_OutputDebugString, kernel32, 'OutputDebugString' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OutputDebugString]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindResourceA: Pointer;
--%%
--%% function FindResourceA;
--%% begin
--%%   GetProcedureAddress(_FindResourceA, kernel32, 'FindResourceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindResourceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindResourceW: Pointer;
--%%
--%% function FindResourceW;
--%% begin
--%%   GetProcedureAddress(_FindResourceW, kernel32, 'FindResourceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindResourceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindResource: Pointer;
--%%
--%% function FindResource;
--%% begin
--%%   GetProcedureAddress(_FindResource, kernel32, 'FindResource' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindResourceExA: Pointer;
--%%
--%% function FindResourceExA;
--%% begin
--%%   GetProcedureAddress(_FindResourceExA, kernel32, 'FindResourceExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindResourceExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindResourceExW: Pointer;
--%%
--%% function FindResourceExW;
--%% begin
--%%   GetProcedureAddress(_FindResourceExW, kernel32, 'FindResourceExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindResourceExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindResourceEx: Pointer;
--%%
--%% function FindResourceEx;
--%% begin
--%%   GetProcedureAddress(_FindResourceEx, kernel32, 'FindResourceEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindResourceEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceTypesA: Pointer;
--%%
--%% function EnumResourceTypesA;
--%% begin
--%%   GetProcedureAddress(_EnumResourceTypesA, kernel32, 'EnumResourceTypesA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceTypesA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceTypesW: Pointer;
--%%
--%% function EnumResourceTypesW;
--%% begin
--%%   GetProcedureAddress(_EnumResourceTypesW, kernel32, 'EnumResourceTypesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceTypesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceTypes: Pointer;
--%%
--%% function EnumResourceTypes;
--%% begin
--%%   GetProcedureAddress(_EnumResourceTypes, kernel32, 'EnumResourceTypes' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceTypes]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceNamesA: Pointer;
--%%
--%% function EnumResourceNamesA;
--%% begin
--%%   GetProcedureAddress(_EnumResourceNamesA, kernel32, 'EnumResourceNamesA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceNamesA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceNamesW: Pointer;
--%%
--%% function EnumResourceNamesW;
--%% begin
--%%   GetProcedureAddress(_EnumResourceNamesW, kernel32, 'EnumResourceNamesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceNamesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceNames: Pointer;
--%%
--%% function EnumResourceNames;
--%% begin
--%%   GetProcedureAddress(_EnumResourceNames, kernel32, 'EnumResourceNames' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceNames]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceLanguagesA: Pointer;
--%%
--%% function EnumResourceLanguagesA;
--%% begin
--%%   GetProcedureAddress(_EnumResourceLanguagesA, kernel32, 'EnumResourceLanguagesA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceLanguagesA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceLanguagesW: Pointer;
--%%
--%% function EnumResourceLanguagesW;
--%% begin
--%%   GetProcedureAddress(_EnumResourceLanguagesW, kernel32, 'EnumResourceLanguagesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceLanguagesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EnumResourceLanguages: Pointer;
--%%
--%% function EnumResourceLanguages;
--%% begin
--%%   GetProcedureAddress(_EnumResourceLanguages, kernel32, 'EnumResourceLanguages' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EnumResourceLanguages]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BeginUpdateResourceA: Pointer;
--%%
--%% function BeginUpdateResourceA;
--%% begin
--%%   GetProcedureAddress(_BeginUpdateResourceA, kernel32, 'BeginUpdateResourceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BeginUpdateResourceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BeginUpdateResourceW: Pointer;
--%%
--%% function BeginUpdateResourceW;
--%% begin
--%%   GetProcedureAddress(_BeginUpdateResourceW, kernel32, 'BeginUpdateResourceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BeginUpdateResourceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BeginUpdateResource: Pointer;
--%%
--%% function BeginUpdateResource;
--%% begin
--%%   GetProcedureAddress(_BeginUpdateResource, kernel32, 'BeginUpdateResource' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BeginUpdateResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UpdateResourceA: Pointer;
--%%
--%% function UpdateResourceA;
--%% begin
--%%   GetProcedureAddress(_UpdateResourceA, kernel32, 'UpdateResourceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UpdateResourceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UpdateResourceW: Pointer;
--%%
--%% function UpdateResourceW;
--%% begin
--%%   GetProcedureAddress(_UpdateResourceW, kernel32, 'UpdateResourceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UpdateResourceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UpdateResource: Pointer;
--%%
--%% function UpdateResource;
--%% begin
--%%   GetProcedureAddress(_UpdateResource, kernel32, 'UpdateResource' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UpdateResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EndUpdateResourceA: Pointer;
--%%
--%% function EndUpdateResourceA;
--%% begin
--%%   GetProcedureAddress(_EndUpdateResourceA, kernel32, 'EndUpdateResourceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EndUpdateResourceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EndUpdateResourceW: Pointer;
--%%
--%% function EndUpdateResourceW;
--%% begin
--%%   GetProcedureAddress(_EndUpdateResourceW, kernel32, 'EndUpdateResourceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EndUpdateResourceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EndUpdateResource: Pointer;
--%%
--%% function EndUpdateResource;
--%% begin
--%%   GetProcedureAddress(_EndUpdateResource, kernel32, 'EndUpdateResource' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EndUpdateResource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalAddAtomA: Pointer;
--%%
--%% function GlobalAddAtomA;
--%% begin
--%%   GetProcedureAddress(_GlobalAddAtomA, kernel32, 'GlobalAddAtomA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalAddAtomA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalAddAtomW: Pointer;
--%%
--%% function GlobalAddAtomW;
--%% begin
--%%   GetProcedureAddress(_GlobalAddAtomW, kernel32, 'GlobalAddAtomW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalAddAtomW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalAddAtom: Pointer;
--%%
--%% function GlobalAddAtom;
--%% begin
--%%   GetProcedureAddress(_GlobalAddAtom, kernel32, 'GlobalAddAtom' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalAddAtom]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalFindAtomA: Pointer;
--%%
--%% function GlobalFindAtomA;
--%% begin
--%%   GetProcedureAddress(_GlobalFindAtomA, kernel32, 'GlobalFindAtomA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalFindAtomA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalFindAtomW: Pointer;
--%%
--%% function GlobalFindAtomW;
--%% begin
--%%   GetProcedureAddress(_GlobalFindAtomW, kernel32, 'GlobalFindAtomW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalFindAtomW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalFindAtom: Pointer;
--%%
--%% function GlobalFindAtom;
--%% begin
--%%   GetProcedureAddress(_GlobalFindAtom, kernel32, 'GlobalFindAtom' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalFindAtom]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalGetAtomNameA: Pointer;
--%%
--%% function GlobalGetAtomNameA;
--%% begin
--%%   GetProcedureAddress(_GlobalGetAtomNameA, kernel32, 'GlobalGetAtomNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalGetAtomNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalGetAtomNameW: Pointer;
--%%
--%% function GlobalGetAtomNameW;
--%% begin
--%%   GetProcedureAddress(_GlobalGetAtomNameW, kernel32, 'GlobalGetAtomNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalGetAtomNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GlobalGetAtomName: Pointer;
--%%
--%% function GlobalGetAtomName;
--%% begin
--%%   GetProcedureAddress(_GlobalGetAtomName, kernel32, 'GlobalGetAtomName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GlobalGetAtomName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAtomA: Pointer;
--%%
--%% function AddAtomA;
--%% begin
--%%   GetProcedureAddress(_AddAtomA, kernel32, 'AddAtomA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAtomA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAtomW: Pointer;
--%%
--%% function AddAtomW;
--%% begin
--%%   GetProcedureAddress(_AddAtomW, kernel32, 'AddAtomW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAtomW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAtom: Pointer;
--%%
--%% function AddAtom;
--%% begin
--%%   GetProcedureAddress(_AddAtom, kernel32, 'AddAtom' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAtom]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindAtomA: Pointer;
--%%
--%% function FindAtomA;
--%% begin
--%%   GetProcedureAddress(_FindAtomA, kernel32, 'FindAtomA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindAtomA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindAtomW: Pointer;
--%%
--%% function FindAtomW;
--%% begin
--%%   GetProcedureAddress(_FindAtomW, kernel32, 'FindAtomW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindAtomW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindAtom: Pointer;
--%%
--%% function FindAtom;
--%% begin
--%%   GetProcedureAddress(_FindAtom, kernel32, 'FindAtom' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindAtom]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetAtomNameA: Pointer;
--%%
--%% function GetAtomNameA;
--%% begin
--%%   GetProcedureAddress(_GetAtomNameA, kernel32, 'GetAtomNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetAtomNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetAtomNameW: Pointer;
--%%
--%% function GetAtomNameW;
--%% begin
--%%   GetProcedureAddress(_GetAtomNameW, kernel32, 'GetAtomNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetAtomNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetAtomName: Pointer;
--%%
--%% function GetAtomName;
--%% begin
--%%   GetProcedureAddress(_GetAtomName, kernel32, 'GetAtomName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetAtomName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileIntA: Pointer;
--%%
--%% function GetProfileIntA;
--%% begin
--%%   GetProcedureAddress(_GetProfileIntA, kernel32, 'GetProfileIntA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileIntA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileIntW: Pointer;
--%%
--%% function GetProfileIntW;
--%% begin
--%%   GetProcedureAddress(_GetProfileIntW, kernel32, 'GetProfileIntW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileIntW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileInt: Pointer;
--%%
--%% function GetProfileInt;
--%% begin
--%%   GetProcedureAddress(_GetProfileInt, kernel32, 'GetProfileInt' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileInt]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileStringA: Pointer;
--%%
--%% function GetProfileStringA;
--%% begin
--%%   GetProcedureAddress(_GetProfileStringA, kernel32, 'GetProfileStringA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileStringA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileStringW: Pointer;
--%%
--%% function GetProfileStringW;
--%% begin
--%%   GetProcedureAddress(_GetProfileStringW, kernel32, 'GetProfileStringW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileStringW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileString: Pointer;
--%%
--%% function GetProfileString;
--%% begin
--%%   GetProcedureAddress(_GetProfileString, kernel32, 'GetProfileString' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileString]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProfileStringA: Pointer;
--%%
--%% function WriteProfileStringA;
--%% begin
--%%   GetProcedureAddress(_WriteProfileStringA, kernel32, 'WriteProfileStringA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProfileStringA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProfileStringW: Pointer;
--%%
--%% function WriteProfileStringW;
--%% begin
--%%   GetProcedureAddress(_WriteProfileStringW, kernel32, 'WriteProfileStringW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProfileStringW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProfileString: Pointer;
--%%
--%% function WriteProfileString;
--%% begin
--%%   GetProcedureAddress(_WriteProfileString, kernel32, 'WriteProfileString' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProfileString]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileSectionA: Pointer;
--%%
--%% function GetProfileSectionA;
--%% begin
--%%   GetProcedureAddress(_GetProfileSectionA, kernel32, 'GetProfileSectionA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileSectionA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileSectionW: Pointer;
--%%
--%% function GetProfileSectionW;
--%% begin
--%%   GetProcedureAddress(_GetProfileSectionW, kernel32, 'GetProfileSectionW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileSectionW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetProfileSection: Pointer;
--%%
--%% function GetProfileSection;
--%% begin
--%%   GetProcedureAddress(_GetProfileSection, kernel32, 'GetProfileSection' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetProfileSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProfileSectionA: Pointer;
--%%
--%% function WriteProfileSectionA;
--%% begin
--%%   GetProcedureAddress(_WriteProfileSectionA, kernel32, 'WriteProfileSectionA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProfileSectionA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProfileSectionW: Pointer;
--%%
--%% function WriteProfileSectionW;
--%% begin
--%%   GetProcedureAddress(_WriteProfileSectionW, kernel32, 'WriteProfileSectionW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProfileSectionW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WriteProfileSection: Pointer;
--%%
--%% function WriteProfileSection;
--%% begin
--%%   GetProcedureAddress(_WriteProfileSection, kernel32, 'WriteProfileSection' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WriteProfileSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileIntA: Pointer;
--%%
--%% function GetPrivateProfileIntA;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileIntA, kernel32, 'GetPrivateProfileIntA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileIntA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileIntW: Pointer;
--%%
--%% function GetPrivateProfileIntW;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileIntW, kernel32, 'GetPrivateProfileIntW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileIntW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileInt: Pointer;
--%%
--%% function GetPrivateProfileInt;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileInt, kernel32, 'GetPrivateProfileInt' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileInt]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileStringA: Pointer;
--%%
--%% function GetPrivateProfileStringA;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileStringA, kernel32, 'GetPrivateProfileStringA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileStringA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileStringW: Pointer;
--%%
--%% function GetPrivateProfileStringW;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileStringW, kernel32, 'GetPrivateProfileStringW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileStringW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileString: Pointer;
--%%
--%% function GetPrivateProfileString;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileString, kernel32, 'GetPrivateProfileString' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileString]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileStringA: Pointer;
--%%
--%% function WritePrivateProfileStringA;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileStringA, kernel32, 'WritePrivateProfileStringA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileStringA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileStringW: Pointer;
--%%
--%% function WritePrivateProfileStringW;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileStringW, kernel32, 'WritePrivateProfileStringW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileStringW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileString: Pointer;
--%%
--%% function WritePrivateProfileString;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileString, kernel32, 'WritePrivateProfileString' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileString]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileSectionA: Pointer;
--%%
--%% function GetPrivateProfileSectionA;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileSectionA, kernel32, 'GetPrivateProfileSectionA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileSectionA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileSectionW: Pointer;
--%%
--%% function GetPrivateProfileSectionW;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileSectionW, kernel32, 'GetPrivateProfileSectionW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileSectionW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileSection: Pointer;
--%%
--%% function GetPrivateProfileSection;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileSection, kernel32, 'GetPrivateProfileSection' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileSectionA: Pointer;
--%%
--%% function WritePrivateProfileSectionA;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileSectionA, kernel32, 'WritePrivateProfileSectionA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileSectionA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileSectionW: Pointer;
--%%
--%% function WritePrivateProfileSectionW;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileSectionW, kernel32, 'WritePrivateProfileSectionW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileSectionW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileSection: Pointer;
--%%
--%% function WritePrivateProfileSection;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileSection, kernel32, 'WritePrivateProfileSection' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileSection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileSectionNamesA: Pointer;
--%%
--%% function GetPrivateProfileSectionNamesA;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileSectionNamesA, kernel32, 'GetPrivateProfileSectionNamesA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileSectionNamesA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileSectionNamesW: Pointer;
--%%
--%% function GetPrivateProfileSectionNamesW;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileSectionNamesW, kernel32, 'GetPrivateProfileSectionNamesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileSectionNamesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileSectionNames: Pointer;
--%%
--%% function GetPrivateProfileSectionNames;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileSectionNames, kernel32, 'GetPrivateProfileSectionNames' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileSectionNames]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileStructA: Pointer;
--%%
--%% function GetPrivateProfileStructA;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileStructA, kernel32, 'GetPrivateProfileStructA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileStructA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileStructW: Pointer;
--%%
--%% function GetPrivateProfileStructW;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileStructW, kernel32, 'GetPrivateProfileStructW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileStructW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateProfileStruct: Pointer;
--%%
--%% function GetPrivateProfileStruct;
--%% begin
--%%   GetProcedureAddress(_GetPrivateProfileStruct, kernel32, 'GetPrivateProfileStruct' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateProfileStruct]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileStructA: Pointer;
--%%
--%% function WritePrivateProfileStructA;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileStructA, kernel32, 'WritePrivateProfileStructA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileStructA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileStructW: Pointer;
--%%
--%% function WritePrivateProfileStructW;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileStructW, kernel32, 'WritePrivateProfileStructW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileStructW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WritePrivateProfileStruct: Pointer;
--%%
--%% function WritePrivateProfileStruct;
--%% begin
--%%   GetProcedureAddress(_WritePrivateProfileStruct, kernel32, 'WritePrivateProfileStruct' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WritePrivateProfileStruct]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDriveTypeA: Pointer;
--%%
--%% function GetDriveTypeA;
--%% begin
--%%   GetProcedureAddress(_GetDriveTypeA, kernel32, 'GetDriveTypeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDriveTypeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDriveTypeW: Pointer;
--%%
--%% function GetDriveTypeW;
--%% begin
--%%   GetProcedureAddress(_GetDriveTypeW, kernel32, 'GetDriveTypeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDriveTypeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDriveType: Pointer;
--%%
--%% function GetDriveType;
--%% begin
--%%   GetProcedureAddress(_GetDriveType, kernel32, 'GetDriveType' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDriveType]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemDirectoryA: Pointer;
--%%
--%% function GetSystemDirectoryA;
--%% begin
--%%   GetProcedureAddress(_GetSystemDirectoryA, kernel32, 'GetSystemDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemDirectoryW: Pointer;
--%%
--%% function GetSystemDirectoryW;
--%% begin
--%%   GetProcedureAddress(_GetSystemDirectoryW, kernel32, 'GetSystemDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemDirectory: Pointer;
--%%
--%% function GetSystemDirectory;
--%% begin
--%%   GetProcedureAddress(_GetSystemDirectory, kernel32, 'GetSystemDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTempPathA: Pointer;
--%%
--%% function GetTempPathA;
--%% begin
--%%   GetProcedureAddress(_GetTempPathA, kernel32, 'GetTempPathA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTempPathA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTempPathW: Pointer;
--%%
--%% function GetTempPathW;
--%% begin
--%%   GetProcedureAddress(_GetTempPathW, kernel32, 'GetTempPathW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTempPathW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTempPath: Pointer;
--%%
--%% function GetTempPath;
--%% begin
--%%   GetProcedureAddress(_GetTempPath, kernel32, 'GetTempPath' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTempPath]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTempFileNameA: Pointer;
--%%
--%% function GetTempFileNameA;
--%% begin
--%%   GetProcedureAddress(_GetTempFileNameA, kernel32, 'GetTempFileNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTempFileNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTempFileNameW: Pointer;
--%%
--%% function GetTempFileNameW;
--%% begin
--%%   GetProcedureAddress(_GetTempFileNameW, kernel32, 'GetTempFileNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTempFileNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTempFileName: Pointer;
--%%
--%% function GetTempFileName;
--%% begin
--%%   GetProcedureAddress(_GetTempFileName, kernel32, 'GetTempFileName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTempFileName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetWindowsDirectoryA: Pointer;
--%%
--%% function GetWindowsDirectoryA;
--%% begin
--%%   GetProcedureAddress(_GetWindowsDirectoryA, kernel32, 'GetWindowsDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetWindowsDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetWindowsDirectoryW: Pointer;
--%%
--%% function GetWindowsDirectoryW;
--%% begin
--%%   GetProcedureAddress(_GetWindowsDirectoryW, kernel32, 'GetWindowsDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetWindowsDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetWindowsDirectory: Pointer;
--%%
--%% function GetWindowsDirectory;
--%% begin
--%%   GetProcedureAddress(_GetWindowsDirectory, kernel32, 'GetWindowsDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetWindowsDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemWindowsDirectoryA: Pointer;
--%%
--%% function GetSystemWindowsDirectoryA;
--%% begin
--%%   GetProcedureAddress(_GetSystemWindowsDirectoryA, kernel32, 'GetSystemWindowsDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemWindowsDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemWindowsDirectoryW: Pointer;
--%%
--%% function GetSystemWindowsDirectoryW;
--%% begin
--%%   GetProcedureAddress(_GetSystemWindowsDirectoryW, kernel32, 'GetSystemWindowsDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemWindowsDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemWindowsDirectory: Pointer;
--%%
--%% function GetSystemWindowsDirectory;
--%% begin
--%%   GetProcedureAddress(_GetSystemWindowsDirectory, kernel32, 'GetSystemWindowsDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemWindowsDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemWow64DirectoryA: Pointer;
--%%
--%% function GetSystemWow64DirectoryA;
--%% begin
--%%   GetProcedureAddress(_GetSystemWow64DirectoryA, kernel32, 'GetSystemWow64DirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemWow64DirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemWow64DirectoryW: Pointer;
--%%
--%% function GetSystemWow64DirectoryW;
--%% begin
--%%   GetProcedureAddress(_GetSystemWow64DirectoryW, kernel32, 'GetSystemWow64DirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemWow64DirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemWow64Directory: Pointer;
--%%
--%% function GetSystemWow64Directory;
--%% begin
--%%   GetProcedureAddress(_GetSystemWow64Directory, kernel32, 'GetSystemWow64Directory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemWow64Directory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _Wow64EnableWow64FsRedirection: Pointer;
--%%
--%% function Wow64EnableWow64FsRedirection;
--%% begin
--%%   GetProcedureAddress(_Wow64EnableWow64FsRedirection, kernel32, 'Wow64EnableWow64FsRedirection');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_Wow64EnableWow64FsRedirection]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCurrentDirectoryA: Pointer;
--%%
--%% function SetCurrentDirectoryA;
--%% begin
--%%   GetProcedureAddress(_SetCurrentDirectoryA, kernel32, 'SetCurrentDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCurrentDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCurrentDirectoryW: Pointer;
--%%
--%% function SetCurrentDirectoryW;
--%% begin
--%%   GetProcedureAddress(_SetCurrentDirectoryW, kernel32, 'SetCurrentDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCurrentDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetCurrentDirectory: Pointer;
--%%
--%% function SetCurrentDirectory;
--%% begin
--%%   GetProcedureAddress(_SetCurrentDirectory, kernel32, 'SetCurrentDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetCurrentDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentDirectoryA: Pointer;
--%%
--%% function GetCurrentDirectoryA;
--%% begin
--%%   GetProcedureAddress(_GetCurrentDirectoryA, kernel32, 'GetCurrentDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentDirectoryW: Pointer;
--%%
--%% function GetCurrentDirectoryW;
--%% begin
--%%   GetProcedureAddress(_GetCurrentDirectoryW, kernel32, 'GetCurrentDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentDirectory: Pointer;
--%%
--%% function GetCurrentDirectory;
--%% begin
--%%   GetProcedureAddress(_GetCurrentDirectory, kernel32, 'GetCurrentDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetDllDirectoryA: Pointer;
--%%
--%% function SetDllDirectoryA;
--%% begin
--%%   GetProcedureAddress(_SetDllDirectoryA, kernel32, 'SetDllDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetDllDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetDllDirectoryW: Pointer;
--%%
--%% function SetDllDirectoryW;
--%% begin
--%%   GetProcedureAddress(_SetDllDirectoryW, kernel32, 'SetDllDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetDllDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetDllDirectory: Pointer;
--%%
--%% function SetDllDirectory;
--%% begin
--%%   GetProcedureAddress(_SetDllDirectory, kernel32, 'SetDllDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetDllDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDllDirectoryA: Pointer;
--%%
--%% function GetDllDirectoryA;
--%% begin
--%%   GetProcedureAddress(_GetDllDirectoryA, kernel32, 'GetDllDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDllDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDllDirectoryW: Pointer;
--%%
--%% function GetDllDirectoryW;
--%% begin
--%%   GetProcedureAddress(_GetDllDirectoryW, kernel32, 'GetDllDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDllDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDllDirectory: Pointer;
--%%
--%% function GetDllDirectory;
--%% begin
--%%   GetProcedureAddress(_GetDllDirectory, kernel32, 'GetDllDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDllDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDiskFreeSpaceA: Pointer;
--%%
--%% function GetDiskFreeSpaceA;
--%% begin
--%%   GetProcedureAddress(_GetDiskFreeSpaceA, kernel32, 'GetDiskFreeSpaceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDiskFreeSpaceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDiskFreeSpaceW: Pointer;
--%%
--%% function GetDiskFreeSpaceW;
--%% begin
--%%   GetProcedureAddress(_GetDiskFreeSpaceW, kernel32, 'GetDiskFreeSpaceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDiskFreeSpaceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDiskFreeSpace: Pointer;
--%%
--%% function GetDiskFreeSpace;
--%% begin
--%%   GetProcedureAddress(_GetDiskFreeSpace, kernel32, 'GetDiskFreeSpace' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDiskFreeSpace]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDiskFreeSpaceExA: Pointer;
--%%
--%% function GetDiskFreeSpaceExA;
--%% begin
--%%   GetProcedureAddress(_GetDiskFreeSpaceExA, kernel32, 'GetDiskFreeSpaceExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDiskFreeSpaceExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDiskFreeSpaceExW: Pointer;
--%%
--%% function GetDiskFreeSpaceExW;
--%% begin
--%%   GetProcedureAddress(_GetDiskFreeSpaceExW, kernel32, 'GetDiskFreeSpaceExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDiskFreeSpaceExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDiskFreeSpaceEx: Pointer;
--%%
--%% function GetDiskFreeSpaceEx;
--%% begin
--%%   GetProcedureAddress(_GetDiskFreeSpaceEx, kernel32, 'GetDiskFreeSpaceEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDiskFreeSpaceEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateDirectoryA: Pointer;
--%%
--%% function CreateDirectoryA;
--%% begin
--%%   GetProcedureAddress(_CreateDirectoryA, kernel32, 'CreateDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateDirectoryW: Pointer;
--%%
--%% function CreateDirectoryW;
--%% begin
--%%   GetProcedureAddress(_CreateDirectoryW, kernel32, 'CreateDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateDirectory: Pointer;
--%%
--%% function CreateDirectory;
--%% begin
--%%   GetProcedureAddress(_CreateDirectory, kernel32, 'CreateDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateDirectoryExA: Pointer;
--%%
--%% function CreateDirectoryExA;
--%% begin
--%%   GetProcedureAddress(_CreateDirectoryExA, kernel32, 'CreateDirectoryExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateDirectoryExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateDirectoryExW: Pointer;
--%%
--%% function CreateDirectoryExW;
--%% begin
--%%   GetProcedureAddress(_CreateDirectoryExW, kernel32, 'CreateDirectoryExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateDirectoryExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateDirectoryEx: Pointer;
--%%
--%% function CreateDirectoryEx;
--%% begin
--%%   GetProcedureAddress(_CreateDirectoryEx, kernel32, 'CreateDirectoryEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateDirectoryEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RemoveDirectoryA: Pointer;
--%%
--%% function RemoveDirectoryA;
--%% begin
--%%   GetProcedureAddress(_RemoveDirectoryA, kernel32, 'RemoveDirectoryA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RemoveDirectoryA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RemoveDirectoryW: Pointer;
--%%
--%% function RemoveDirectoryW;
--%% begin
--%%   GetProcedureAddress(_RemoveDirectoryW, kernel32, 'RemoveDirectoryW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RemoveDirectoryW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RemoveDirectory: Pointer;
--%%
--%% function RemoveDirectory;
--%% begin
--%%   GetProcedureAddress(_RemoveDirectory, kernel32, 'RemoveDirectory' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RemoveDirectory]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFullPathNameA: Pointer;
--%%
--%% function GetFullPathNameA;
--%% begin
--%%   GetProcedureAddress(_GetFullPathNameA, kernel32, 'GetFullPathNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFullPathNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFullPathNameW: Pointer;
--%%
--%% function GetFullPathNameW;
--%% begin
--%%   GetProcedureAddress(_GetFullPathNameW, kernel32, 'GetFullPathNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFullPathNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFullPathName: Pointer;
--%%
--%% function GetFullPathName;
--%% begin
--%%   GetProcedureAddress(_GetFullPathName, kernel32, 'GetFullPathName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFullPathName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DefineDosDeviceA: Pointer;
--%%
--%% function DefineDosDeviceA;
--%% begin
--%%   GetProcedureAddress(_DefineDosDeviceA, kernel32, 'DefineDosDeviceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DefineDosDeviceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DefineDosDeviceW: Pointer;
--%%
--%% function DefineDosDeviceW;
--%% begin
--%%   GetProcedureAddress(_DefineDosDeviceW, kernel32, 'DefineDosDeviceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DefineDosDeviceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DefineDosDevice: Pointer;
--%%
--%% function DefineDosDevice;
--%% begin
--%%   GetProcedureAddress(_DefineDosDevice, kernel32, 'DefineDosDevice' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DefineDosDevice]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryDosDeviceA: Pointer;
--%%
--%% function QueryDosDeviceA;
--%% begin
--%%   GetProcedureAddress(_QueryDosDeviceA, kernel32, 'QueryDosDeviceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryDosDeviceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryDosDeviceW: Pointer;
--%%
--%% function QueryDosDeviceW;
--%% begin
--%%   GetProcedureAddress(_QueryDosDeviceW, kernel32, 'QueryDosDeviceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryDosDeviceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryDosDevice: Pointer;
--%%
--%% function QueryDosDevice;
--%% begin
--%%   GetProcedureAddress(_QueryDosDevice, kernel32, 'QueryDosDevice' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryDosDevice]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFileA: Pointer;
--%%
--%% function CreateFileA;
--%% begin
--%%   GetProcedureAddress(_CreateFileA, kernel32, 'CreateFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFileW: Pointer;
--%%
--%% function CreateFileW;
--%% begin
--%%   GetProcedureAddress(_CreateFileW, kernel32, 'CreateFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateFile: Pointer;
--%%
--%% function CreateFile;
--%% begin
--%%   GetProcedureAddress(_CreateFile, kernel32, 'CreateFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReOpenFile: Pointer;
--%%
--%% function ReOpenFile;
--%% begin
--%%   GetProcedureAddress(_ReOpenFile, kernel32, 'ReOpenFile');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReOpenFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileAttributesA: Pointer;
--%%
--%% function SetFileAttributesA;
--%% begin
--%%   GetProcedureAddress(_SetFileAttributesA, kernel32, 'SetFileAttributesA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileAttributesA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileAttributesW: Pointer;
--%%
--%% function SetFileAttributesW;
--%% begin
--%%   GetProcedureAddress(_SetFileAttributesW, kernel32, 'SetFileAttributesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileAttributesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileAttributes: Pointer;
--%%
--%% function SetFileAttributes;
--%% begin
--%%   GetProcedureAddress(_SetFileAttributes, kernel32, 'SetFileAttributes' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileAttributes]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileAttributesA: Pointer;
--%%
--%% function GetFileAttributesA;
--%% begin
--%%   GetProcedureAddress(_GetFileAttributesA, kernel32, 'GetFileAttributesA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileAttributesA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileAttributesW: Pointer;
--%%
--%% function GetFileAttributesW;
--%% begin
--%%   GetProcedureAddress(_GetFileAttributesW, kernel32, 'GetFileAttributesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileAttributesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileAttributes: Pointer;
--%%
--%% function GetFileAttributes;
--%% begin
--%%   GetProcedureAddress(_GetFileAttributes, kernel32, 'GetFileAttributes' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileAttributes]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileAttributesExA: Pointer;
--%%
--%% function GetFileAttributesExA;
--%% begin
--%%   GetProcedureAddress(_GetFileAttributesExA, kernel32, 'GetFileAttributesExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileAttributesExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileAttributesExW: Pointer;
--%%
--%% function GetFileAttributesExW;
--%% begin
--%%   GetProcedureAddress(_GetFileAttributesExW, kernel32, 'GetFileAttributesExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileAttributesExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileAttributesEx: Pointer;
--%%
--%% function GetFileAttributesEx;
--%% begin
--%%   GetProcedureAddress(_GetFileAttributesEx, kernel32, 'GetFileAttributesEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileAttributesEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCompressedFileSizeA: Pointer;
--%%
--%% function GetCompressedFileSizeA;
--%% begin
--%%   GetProcedureAddress(_GetCompressedFileSizeA, kernel32, 'GetCompressedFileSizeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCompressedFileSizeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCompressedFileSizeW: Pointer;
--%%
--%% function GetCompressedFileSizeW;
--%% begin
--%%   GetProcedureAddress(_GetCompressedFileSizeW, kernel32, 'GetCompressedFileSizeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCompressedFileSizeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCompressedFileSize: Pointer;
--%%
--%% function GetCompressedFileSize;
--%% begin
--%%   GetProcedureAddress(_GetCompressedFileSize, kernel32, 'GetCompressedFileSize' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCompressedFileSize]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteFileA: Pointer;
--%%
--%% function DeleteFileA;
--%% begin
--%%   GetProcedureAddress(_DeleteFileA, kernel32, 'DeleteFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteFileW: Pointer;
--%%
--%% function DeleteFileW;
--%% begin
--%%   GetProcedureAddress(_DeleteFileW, kernel32, 'DeleteFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteFile: Pointer;
--%%
--%% function DeleteFile;
--%% begin
--%%   GetProcedureAddress(_DeleteFile, kernel32, 'DeleteFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFileExA: Pointer;
--%%
--%% function FindFirstFileExA;
--%% begin
--%%   GetProcedureAddress(_FindFirstFileExA, kernel32, 'FindFirstFileExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFileExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFileExW: Pointer;
--%%
--%% function FindFirstFileExW;
--%% begin
--%%   GetProcedureAddress(_FindFirstFileExW, kernel32, 'FindFirstFileExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFileExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFileEx: Pointer;
--%%
--%% function FindFirstFileEx;
--%% begin
--%%   GetProcedureAddress(_FindFirstFileEx, kernel32, 'FindFirstFileEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFileA: Pointer;
--%%
--%% function FindFirstFileA;
--%% begin
--%%   GetProcedureAddress(_FindFirstFileA, kernel32, 'FindFirstFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFileW: Pointer;
--%%
--%% function FindFirstFileW;
--%% begin
--%%   GetProcedureAddress(_FindFirstFileW, kernel32, 'FindFirstFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFile: Pointer;
--%%
--%% function FindFirstFile;
--%% begin
--%%   GetProcedureAddress(_FindFirstFile, kernel32, 'FindFirstFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextFileA: Pointer;
--%%
--%% function FindNextFileA;
--%% begin
--%%   GetProcedureAddress(_FindNextFileA, kernel32, 'FindNextFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextFileW: Pointer;
--%%
--%% function FindNextFileW;
--%% begin
--%%   GetProcedureAddress(_FindNextFileW, kernel32, 'FindNextFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextFile: Pointer;
--%%
--%% function FindNextFile;
--%% begin
--%%   GetProcedureAddress(_FindNextFile, kernel32, 'FindNextFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SearchPathA: Pointer;
--%%
--%% function SearchPathA;
--%% begin
--%%   GetProcedureAddress(_SearchPathA, kernel32, 'SearchPathA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SearchPathA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SearchPathW: Pointer;
--%%
--%% function SearchPathW;
--%% begin
--%%   GetProcedureAddress(_SearchPathW, kernel32, 'SearchPathW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SearchPathW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SearchPath: Pointer;
--%%
--%% function SearchPath;
--%% begin
--%%   GetProcedureAddress(_SearchPath, kernel32, 'SearchPath' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SearchPath]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopyFileA: Pointer;
--%%
--%% function CopyFileA;
--%% begin
--%%   GetProcedureAddress(_CopyFileA, kernel32, 'CopyFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopyFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopyFileW: Pointer;
--%%
--%% function CopyFileW;
--%% begin
--%%   GetProcedureAddress(_CopyFileW, kernel32, 'CopyFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopyFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopyFile: Pointer;
--%%
--%% function CopyFile;
--%% begin
--%%   GetProcedureAddress(_CopyFile, kernel32, 'CopyFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopyFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopyFileExA: Pointer;
--%%
--%% function CopyFileExA;
--%% begin
--%%   GetProcedureAddress(_CopyFileExA, kernel32, 'CopyFileExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopyFileExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopyFileExW: Pointer;
--%%
--%% function CopyFileExW;
--%% begin
--%%   GetProcedureAddress(_CopyFileExW, kernel32, 'CopyFileExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopyFileExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopyFileEx: Pointer;
--%%
--%% function CopyFileEx;
--%% begin
--%%   GetProcedureAddress(_CopyFileEx, kernel32, 'CopyFileEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopyFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileA: Pointer;
--%%
--%% function MoveFileA;
--%% begin
--%%   GetProcedureAddress(_MoveFileA, kernel32, 'MoveFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileW: Pointer;
--%%
--%% function MoveFileW;
--%% begin
--%%   GetProcedureAddress(_MoveFileW, kernel32, 'MoveFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFile: Pointer;
--%%
--%% function MoveFile;
--%% begin
--%%   GetProcedureAddress(_MoveFile, kernel32, 'MoveFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileExA: Pointer;
--%%
--%% function MoveFileExA;
--%% begin
--%%   GetProcedureAddress(_MoveFileExA, kernel32, 'MoveFileExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileExW: Pointer;
--%%
--%% function MoveFileExW;
--%% begin
--%%   GetProcedureAddress(_MoveFileExW, kernel32, 'MoveFileExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileEx: Pointer;
--%%
--%% function MoveFileEx;
--%% begin
--%%   GetProcedureAddress(_MoveFileEx, kernel32, 'MoveFileEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileWithProgressA: Pointer;
--%%
--%% function MoveFileWithProgressA;
--%% begin
--%%   GetProcedureAddress(_MoveFileWithProgressA, kernel32, 'MoveFileWithProgressA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileWithProgressA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileWithProgressW: Pointer;
--%%
--%% function MoveFileWithProgressW;
--%% begin
--%%   GetProcedureAddress(_MoveFileWithProgressW, kernel32, 'MoveFileWithProgressW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileWithProgressW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MoveFileWithProgress: Pointer;
--%%
--%% function MoveFileWithProgress;
--%% begin
--%%   GetProcedureAddress(_MoveFileWithProgress, kernel32, 'MoveFileWithProgress' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MoveFileWithProgress]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReplaceFileA: Pointer;
--%%
--%% function ReplaceFileA;
--%% begin
--%%   GetProcedureAddress(_ReplaceFileA, kernel32, 'ReplaceFileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReplaceFileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReplaceFileW: Pointer;
--%%
--%% function ReplaceFileW;
--%% begin
--%%   GetProcedureAddress(_ReplaceFileW, kernel32, 'ReplaceFileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReplaceFileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReplaceFile: Pointer;
--%%
--%% function ReplaceFile;
--%% begin
--%%   GetProcedureAddress(_ReplaceFile, kernel32, 'ReplaceFile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReplaceFile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateHardLinkA: Pointer;
--%%
--%% function CreateHardLinkA;
--%% begin
--%%   GetProcedureAddress(_CreateHardLinkA, kernel32, 'CreateHardLinkA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateHardLinkA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateHardLinkW: Pointer;
--%%
--%% function CreateHardLinkW;
--%% begin
--%%   GetProcedureAddress(_CreateHardLinkW, kernel32, 'CreateHardLinkW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateHardLinkW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateHardLink: Pointer;
--%%
--%% function CreateHardLink;
--%% begin
--%%   GetProcedureAddress(_CreateHardLink, kernel32, 'CreateHardLink' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateHardLink]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstStreamW: Pointer;
--%%
--%% function FindFirstStreamW;
--%% begin
--%%   GetProcedureAddress(_FindFirstStreamW, kernel32, 'FindFirstStreamW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstStreamW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextStreamW: Pointer;
--%%
--%% function FindNextStreamW;
--%% begin
--%%   GetProcedureAddress(_FindNextStreamW, kernel32, 'FindNextStreamW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextStreamW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateNamedPipeA: Pointer;
--%%
--%% function CreateNamedPipeA;
--%% begin
--%%   GetProcedureAddress(_CreateNamedPipeA, kernel32, 'CreateNamedPipeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateNamedPipeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateNamedPipeW: Pointer;
--%%
--%% function CreateNamedPipeW;
--%% begin
--%%   GetProcedureAddress(_CreateNamedPipeW, kernel32, 'CreateNamedPipeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateNamedPipeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateNamedPipe: Pointer;
--%%
--%% function CreateNamedPipe;
--%% begin
--%%   GetProcedureAddress(_CreateNamedPipe, kernel32, 'CreateNamedPipe' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNamedPipeHandleStateA: Pointer;
--%%
--%% function GetNamedPipeHandleStateA;
--%% begin
--%%   GetProcedureAddress(_GetNamedPipeHandleStateA, kernel32, 'GetNamedPipeHandleStateA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNamedPipeHandleStateA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNamedPipeHandleStateW: Pointer;
--%%
--%% function GetNamedPipeHandleStateW;
--%% begin
--%%   GetProcedureAddress(_GetNamedPipeHandleStateW, kernel32, 'GetNamedPipeHandleStateW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNamedPipeHandleStateW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNamedPipeHandleState: Pointer;
--%%
--%% function GetNamedPipeHandleState;
--%% begin
--%%   GetProcedureAddress(_GetNamedPipeHandleState, kernel32, 'GetNamedPipeHandleState' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNamedPipeHandleState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CallNamedPipeA: Pointer;
--%%
--%% function CallNamedPipeA;
--%% begin
--%%   GetProcedureAddress(_CallNamedPipeA, kernel32, 'CallNamedPipeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CallNamedPipeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CallNamedPipeW: Pointer;
--%%
--%% function CallNamedPipeW;
--%% begin
--%%   GetProcedureAddress(_CallNamedPipeW, kernel32, 'CallNamedPipeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CallNamedPipeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CallNamedPipe: Pointer;
--%%
--%% function CallNamedPipe;
--%% begin
--%%   GetProcedureAddress(_CallNamedPipe, kernel32, 'CallNamedPipe' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CallNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitNamedPipeA: Pointer;
--%%
--%% function WaitNamedPipeA;
--%% begin
--%%   GetProcedureAddress(_WaitNamedPipeA, kernel32, 'WaitNamedPipeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitNamedPipeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitNamedPipeW: Pointer;
--%%
--%% function WaitNamedPipeW;
--%% begin
--%%   GetProcedureAddress(_WaitNamedPipeW, kernel32, 'WaitNamedPipeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitNamedPipeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WaitNamedPipe: Pointer;
--%%
--%% function WaitNamedPipe;
--%% begin
--%%   GetProcedureAddress(_WaitNamedPipe, kernel32, 'WaitNamedPipe' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WaitNamedPipe]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetVolumeLabelA: Pointer;
--%%
--%% function SetVolumeLabelA;
--%% begin
--%%   GetProcedureAddress(_SetVolumeLabelA, kernel32, 'SetVolumeLabelA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetVolumeLabelA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetVolumeLabelW: Pointer;
--%%
--%% function SetVolumeLabelW;
--%% begin
--%%   GetProcedureAddress(_SetVolumeLabelW, kernel32, 'SetVolumeLabelW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetVolumeLabelW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetVolumeLabel: Pointer;
--%%
--%% function SetVolumeLabel;
--%% begin
--%%   GetProcedureAddress(_SetVolumeLabel, kernel32, 'SetVolumeLabel' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetVolumeLabel]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileApisToOEM: Pointer;
--%%
--%% procedure SetFileApisToOEM;
--%% begin
--%%   GetProcedureAddress(_SetFileApisToOEM, kernel32, 'SetFileApisToOEM');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileApisToOEM]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileApisToANSI: Pointer;
--%%
--%% procedure SetFileApisToANSI;
--%% begin
--%%   GetProcedureAddress(_SetFileApisToANSI, kernel32, 'SetFileApisToANSI');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileApisToANSI]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AreFileApisANSI: Pointer;
--%%
--%% function AreFileApisANSI;
--%% begin
--%%   GetProcedureAddress(_AreFileApisANSI, kernel32, 'AreFileApisANSI');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AreFileApisANSI]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumeInformationA: Pointer;
--%%
--%% function GetVolumeInformationA;
--%% begin
--%%   GetProcedureAddress(_GetVolumeInformationA, kernel32, 'GetVolumeInformationA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumeInformationA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumeInformationW: Pointer;
--%%
--%% function GetVolumeInformationW;
--%% begin
--%%   GetProcedureAddress(_GetVolumeInformationW, kernel32, 'GetVolumeInformationW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumeInformationW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumeInformation: Pointer;
--%%
--%% function GetVolumeInformation;
--%% begin
--%%   GetProcedureAddress(_GetVolumeInformation, kernel32, 'GetVolumeInformation' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumeInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CancelIo: Pointer;
--%%
--%% function CancelIo;
--%% begin
--%%   GetProcedureAddress(_CancelIo, kernel32, 'CancelIo');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CancelIo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ClearEventLogA: Pointer;
--%%
--%% function ClearEventLogA;
--%% begin
--%%   GetProcedureAddress(_ClearEventLogA, advapi32, 'ClearEventLogA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ClearEventLogA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ClearEventLogW: Pointer;
--%%
--%% function ClearEventLogW;
--%% begin
--%%   GetProcedureAddress(_ClearEventLogW, advapi32, 'ClearEventLogW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ClearEventLogW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ClearEventLog: Pointer;
--%%
--%% function ClearEventLog;
--%% begin
--%%   GetProcedureAddress(_ClearEventLog, advapi32, 'ClearEventLog' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ClearEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BackupEventLogA: Pointer;
--%%
--%% function BackupEventLogA;
--%% begin
--%%   GetProcedureAddress(_BackupEventLogA, advapi32, 'BackupEventLogA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BackupEventLogA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BackupEventLogW: Pointer;
--%%
--%% function BackupEventLogW;
--%% begin
--%%   GetProcedureAddress(_BackupEventLogW, advapi32, 'BackupEventLogW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BackupEventLogW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BackupEventLog: Pointer;
--%%
--%% function BackupEventLog;
--%% begin
--%%   GetProcedureAddress(_BackupEventLog, advapi32, 'BackupEventLog' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BackupEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CloseEventLog: Pointer;
--%%
--%% function CloseEventLog;
--%% begin
--%%   GetProcedureAddress(_CloseEventLog, advapi32, 'CloseEventLog');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CloseEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeregisterEventSource: Pointer;
--%%
--%% function DeregisterEventSource;
--%% begin
--%%   GetProcedureAddress(_DeregisterEventSource, advapi32, 'DeregisterEventSource');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeregisterEventSource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _NotifyChangeEventLog: Pointer;
--%%
--%% function NotifyChangeEventLog;
--%% begin
--%%   GetProcedureAddress(_NotifyChangeEventLog, advapi32, 'NotifyChangeEventLog');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_NotifyChangeEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNumberOfEventLogRecords: Pointer;
--%%
--%% function GetNumberOfEventLogRecords;
--%% begin
--%%   GetProcedureAddress(_GetNumberOfEventLogRecords, advapi32, 'GetNumberOfEventLogRecords');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNumberOfEventLogRecords]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetOldestEventLogRecord: Pointer;
--%%
--%% function GetOldestEventLogRecord;
--%% begin
--%%   GetProcedureAddress(_GetOldestEventLogRecord, advapi32, 'GetOldestEventLogRecord');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetOldestEventLogRecord]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEventLogA: Pointer;
--%%
--%% function OpenEventLogA;
--%% begin
--%%   GetProcedureAddress(_OpenEventLogA, advapi32, 'OpenEventLogA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEventLogA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEventLogW: Pointer;
--%%
--%% function OpenEventLogW;
--%% begin
--%%   GetProcedureAddress(_OpenEventLogW, advapi32, 'OpenEventLogW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEventLogW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenEventLog: Pointer;
--%%
--%% function OpenEventLog;
--%% begin
--%%   GetProcedureAddress(_OpenEventLog, advapi32, 'OpenEventLog' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RegisterEventSourceA: Pointer;
--%%
--%% function RegisterEventSourceA;
--%% begin
--%%   GetProcedureAddress(_RegisterEventSourceA, advapi32, 'RegisterEventSourceA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RegisterEventSourceA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RegisterEventSourceW: Pointer;
--%%
--%% function RegisterEventSourceW;
--%% begin
--%%   GetProcedureAddress(_RegisterEventSourceW, advapi32, 'RegisterEventSourceW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RegisterEventSourceW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RegisterEventSource: Pointer;
--%%
--%% function RegisterEventSource;
--%% begin
--%%   GetProcedureAddress(_RegisterEventSource, advapi32, 'RegisterEventSource' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RegisterEventSource]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenBackupEventLogA: Pointer;
--%%
--%% function OpenBackupEventLogA;
--%% begin
--%%   GetProcedureAddress(_OpenBackupEventLogA, advapi32, 'OpenBackupEventLogA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenBackupEventLogA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenBackupEventLogW: Pointer;
--%%
--%% function OpenBackupEventLogW;
--%% begin
--%%   GetProcedureAddress(_OpenBackupEventLogW, advapi32, 'OpenBackupEventLogW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenBackupEventLogW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenBackupEventLog: Pointer;
--%%
--%% function OpenBackupEventLog;
--%% begin
--%%   GetProcedureAddress(_OpenBackupEventLog, advapi32, 'OpenBackupEventLog' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenBackupEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadEventLogA: Pointer;
--%%
--%% function ReadEventLogA;
--%% begin
--%%   GetProcedureAddress(_ReadEventLogA, advapi32, 'ReadEventLogA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadEventLogA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadEventLogW: Pointer;
--%%
--%% function ReadEventLogW;
--%% begin
--%%   GetProcedureAddress(_ReadEventLogW, advapi32, 'ReadEventLogW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadEventLogW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadEventLog: Pointer;
--%%
--%% function ReadEventLog;
--%% begin
--%%   GetProcedureAddress(_ReadEventLog, advapi32, 'ReadEventLog' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadEventLog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReportEventA: Pointer;
--%%
--%% function ReportEventA;
--%% begin
--%%   GetProcedureAddress(_ReportEventA, advapi32, 'ReportEventA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReportEventA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReportEventW: Pointer;
--%%
--%% function ReportEventW;
--%% begin
--%%   GetProcedureAddress(_ReportEventW, advapi32, 'ReportEventW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReportEventW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReportEvent: Pointer;
--%%
--%% function ReportEvent;
--%% begin
--%%   GetProcedureAddress(_ReportEvent, advapi32, 'ReportEvent' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReportEvent]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetEventLogInformation: Pointer;
--%%
--%% function GetEventLogInformation;
--%% begin
--%%   GetProcedureAddress(_GetEventLogInformation, advapi32, 'GetEventLogInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetEventLogInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DuplicateToken: Pointer;
--%%
--%% function DuplicateToken;
--%% begin
--%%   GetProcedureAddress(_DuplicateToken, advapi32, 'DuplicateToken');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DuplicateToken]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetKernelObjectSecurity: Pointer;
--%%
--%% function GetKernelObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_GetKernelObjectSecurity, advapi32, 'GetKernelObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetKernelObjectSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ImpersonateNamedPipeClient: Pointer;
--%%
--%% function ImpersonateNamedPipeClient;
--%% begin
--%%   GetProcedureAddress(_ImpersonateNamedPipeClient, advapi32, 'ImpersonateNamedPipeClient');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ImpersonateNamedPipeClient]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ImpersonateSelf: Pointer;
--%%
--%% function ImpersonateSelf;
--%% begin
--%%   GetProcedureAddress(_ImpersonateSelf, advapi32, 'ImpersonateSelf');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ImpersonateSelf]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RevertToSelf: Pointer;
--%%
--%% function RevertToSelf;
--%% begin
--%%   GetProcedureAddress(_RevertToSelf, advapi32, 'RevertToSelf');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RevertToSelf]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetThreadToken: Pointer;
--%%
--%% function SetThreadToken;
--%% begin
--%%   GetProcedureAddress(_SetThreadToken, advapi32, 'SetThreadToken');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetThreadToken]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheck: Pointer;
--%%
--%% function AccessCheck;
--%% begin
--%%   GetProcedureAddress(_AccessCheck, advapi32, 'AccessCheck');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheck]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByType: Pointer;
--%%
--%% function AccessCheckByType;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByType, advapi32, 'AccessCheckByType');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByType]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeResultList: Pointer;
--%%
--%% function AccessCheckByTypeResultList;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeResultList, advapi32, 'AccessCheckByTypeResultList');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeResultList]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenProcessToken: Pointer;
--%%
--%% function OpenProcessToken;
--%% begin
--%%   GetProcedureAddress(_OpenProcessToken, advapi32, 'OpenProcessToken');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenProcessToken]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenThreadToken: Pointer;
--%%
--%% function OpenThreadToken;
--%% begin
--%%   GetProcedureAddress(_OpenThreadToken, advapi32, 'OpenThreadToken');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenThreadToken]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetTokenInformation: Pointer;
--%%
--%% function GetTokenInformation;
--%% begin
--%%   GetProcedureAddress(_GetTokenInformation, advapi32, 'GetTokenInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetTokenInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetTokenInformation: Pointer;
--%%
--%% function SetTokenInformation;
--%% begin
--%%   GetProcedureAddress(_SetTokenInformation, advapi32, 'SetTokenInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetTokenInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AdjustTokenPrivileges: Pointer;
--%%
--%% function AdjustTokenPrivileges;
--%% begin
--%%   GetProcedureAddress(_AdjustTokenPrivileges, advapi32, 'AdjustTokenPrivileges');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AdjustTokenPrivileges]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AdjustTokenGroups: Pointer;
--%%
--%% function AdjustTokenGroups;
--%% begin
--%%   GetProcedureAddress(_AdjustTokenGroups, advapi32, 'AdjustTokenGroups');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AdjustTokenGroups]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PrivilegeCheck: Pointer;
--%%
--%% function PrivilegeCheck;
--%% begin
--%%   GetProcedureAddress(_PrivilegeCheck, advapi32, 'PrivilegeCheck');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PrivilegeCheck]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckAndAuditAlarmA: Pointer;
--%%
--%% function AccessCheckAndAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_AccessCheckAndAuditAlarmA, advapi32, 'AccessCheckAndAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckAndAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckAndAuditAlarmW: Pointer;
--%%
--%% function AccessCheckAndAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_AccessCheckAndAuditAlarmW, advapi32, 'AccessCheckAndAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckAndAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckAndAuditAlarm: Pointer;
--%%
--%% function AccessCheckAndAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_AccessCheckAndAuditAlarm, advapi32, 'AccessCheckAndAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckAndAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeAndAuditAlarmA: Pointer;
--%%
--%% function AccessCheckByTypeAndAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeAndAuditAlarmA, advapi32, 'AccessCheckByTypeAndAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeAndAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeAndAuditAlarmW: Pointer;
--%%
--%% function AccessCheckByTypeAndAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeAndAuditAlarmW, advapi32, 'AccessCheckByTypeAndAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeAndAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeAndAuditAlarm: Pointer;
--%%
--%% function AccessCheckByTypeAndAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeAndAuditAlarm, advapi32, 'AccessCheckByTypeAndAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeAndAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeResultListAndA: Pointer;
--%%
--%% function AccessCheckByTypeResultListAndAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeResultListAndA, advapi32, 'AccessCheckByTypeResultListAndAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeResultListAndA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeResultListAndW: Pointer;
--%%
--%% function AccessCheckByTypeResultListAndAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeResultListAndW, advapi32, 'AccessCheckByTypeResultListAndAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeResultListAndW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTypeResultListAnd: Pointer;
--%%
--%% function AccessCheckByTypeResultListAndAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTypeResultListAnd, advapi32, 'AccessCheckByTypeResultListAndAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTypeResultListAnd]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTRLAndAAByHA: Pointer;
--%%
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandleA;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTRLAndAAByHA, advapi32, 'AccessCheckByTypeResultListAndAuditAlarmByHandleA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTRLAndAAByHA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTRLAndAAByHW: Pointer;
--%%
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandleW;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTRLAndAAByHW, advapi32, 'AccessCheckByTypeResultListAndAuditAlarmByHandleW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTRLAndAAByHW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AccessCheckByTRLAndAAByH: Pointer;
--%%
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandle;
--%% begin
--%%   GetProcedureAddress(_AccessCheckByTRLAndAAByH, advapi32, 'AccessCheckByTypeResultListAndAuditAlarmByHandle' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AccessCheckByTRLAndAAByH]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectOpenAuditAlarmA: Pointer;
--%%
--%% function ObjectOpenAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_ObjectOpenAuditAlarmA, advapi32, 'ObjectOpenAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectOpenAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectOpenAuditAlarmW: Pointer;
--%%
--%% function ObjectOpenAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_ObjectOpenAuditAlarmW, advapi32, 'ObjectOpenAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectOpenAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectOpenAuditAlarm: Pointer;
--%%
--%% function ObjectOpenAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_ObjectOpenAuditAlarm, advapi32, 'ObjectOpenAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectOpenAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectPrivilegeAuditAlarmA: Pointer;
--%%
--%% function ObjectPrivilegeAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_ObjectPrivilegeAuditAlarmA, advapi32, 'ObjectPrivilegeAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectPrivilegeAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectPrivilegeAuditAlarmW: Pointer;
--%%
--%% function ObjectPrivilegeAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_ObjectPrivilegeAuditAlarmW, advapi32, 'ObjectPrivilegeAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectPrivilegeAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectPrivilegeAuditAlarm: Pointer;
--%%
--%% function ObjectPrivilegeAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_ObjectPrivilegeAuditAlarm, advapi32, 'ObjectPrivilegeAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectPrivilegeAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectCloseAuditAlarmA: Pointer;
--%%
--%% function ObjectCloseAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_ObjectCloseAuditAlarmA, advapi32, 'ObjectCloseAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectCloseAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectCloseAuditAlarmW: Pointer;
--%%
--%% function ObjectCloseAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_ObjectCloseAuditAlarmW, advapi32, 'ObjectCloseAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectCloseAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectCloseAuditAlarm: Pointer;
--%%
--%% function ObjectCloseAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_ObjectCloseAuditAlarm, advapi32, 'ObjectCloseAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectCloseAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectDeleteAuditAlarmA: Pointer;
--%%
--%% function ObjectDeleteAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_ObjectDeleteAuditAlarmA, advapi32, 'ObjectDeleteAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectDeleteAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectDeleteAuditAlarmW: Pointer;
--%%
--%% function ObjectDeleteAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_ObjectDeleteAuditAlarmW, advapi32, 'ObjectDeleteAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectDeleteAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ObjectDeleteAuditAlarm: Pointer;
--%%
--%% function ObjectDeleteAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_ObjectDeleteAuditAlarm, advapi32, 'ObjectDeleteAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ObjectDeleteAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PrivilegedServiceAuditAlarmA: Pointer;
--%%
--%% function PrivilegedServiceAuditAlarmA;
--%% begin
--%%   GetProcedureAddress(_PrivilegedServiceAuditAlarmA, advapi32, 'PrivilegedServiceAuditAlarmA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PrivilegedServiceAuditAlarmA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PrivilegedServiceAuditAlarmW: Pointer;
--%%
--%% function PrivilegedServiceAuditAlarmW;
--%% begin
--%%   GetProcedureAddress(_PrivilegedServiceAuditAlarmW, advapi32, 'PrivilegedServiceAuditAlarmW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PrivilegedServiceAuditAlarmW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _PrivilegedServiceAuditAlarm: Pointer;
--%%
--%% function PrivilegedServiceAuditAlarm;
--%% begin
--%%   GetProcedureAddress(_PrivilegedServiceAuditAlarm, advapi32, 'PrivilegedServiceAuditAlarm' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_PrivilegedServiceAuditAlarm]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsWellKnownSid: Pointer;
--%%
--%% function IsWellKnownSid;
--%% begin
--%%   GetProcedureAddress(_IsWellKnownSid, advapi32, 'IsWellKnownSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsWellKnownSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateWellKnownSid: Pointer;
--%%
--%% function CreateWellKnownSid;
--%% begin
--%%   GetProcedureAddress(_CreateWellKnownSid, advapi32, 'CreateWellKnownSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateWellKnownSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EqualDomainSid: Pointer;
--%%
--%% function EqualDomainSid;
--%% begin
--%%   GetProcedureAddress(_EqualDomainSid, advapi32, 'EqualDomainSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EqualDomainSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetWindowsAccountDomainSid: Pointer;
--%%
--%% function GetWindowsAccountDomainSid;
--%% begin
--%%   GetProcedureAddress(_GetWindowsAccountDomainSid, advapi32, 'GetWindowsAccountDomainSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetWindowsAccountDomainSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsValidSid: Pointer;
--%%
--%% function IsValidSid;
--%% begin
--%%   GetProcedureAddress(_IsValidSid, advapi32, 'IsValidSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsValidSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EqualSid: Pointer;
--%%
--%% function EqualSid;
--%% begin
--%%   GetProcedureAddress(_EqualSid, advapi32, 'EqualSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EqualSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _EqualPrefixSid: Pointer;
--%%
--%% function EqualPrefixSid;
--%% begin
--%%   GetProcedureAddress(_EqualPrefixSid, advapi32, 'EqualPrefixSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_EqualPrefixSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSidLengthRequired: Pointer;
--%%
--%% function GetSidLengthRequired;
--%% begin
--%%   GetProcedureAddress(_GetSidLengthRequired, advapi32, 'GetSidLengthRequired');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSidLengthRequired]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AllocateAndInitializeSid: Pointer;
--%%
--%% function AllocateAndInitializeSid;
--%% begin
--%%   GetProcedureAddress(_AllocateAndInitializeSid, advapi32, 'AllocateAndInitializeSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AllocateAndInitializeSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeSid: Pointer;
--%%
--%% function FreeSid;
--%% begin
--%%   GetProcedureAddress(_FreeSid, advapi32, 'FreeSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitializeSid: Pointer;
--%%
--%% function InitializeSid;
--%% begin
--%%   GetProcedureAddress(_InitializeSid, advapi32, 'InitializeSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitializeSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSidIdentifierAuthority: Pointer;
--%%
--%% function GetSidIdentifierAuthority;
--%% begin
--%%   GetProcedureAddress(_GetSidIdentifierAuthority, advapi32, 'GetSidIdentifierAuthority');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSidIdentifierAuthority]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSidSubAuthority: Pointer;
--%%
--%% function GetSidSubAuthority;
--%% begin
--%%   GetProcedureAddress(_GetSidSubAuthority, advapi32, 'GetSidSubAuthority');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSidSubAuthority]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSidSubAuthorityCount: Pointer;
--%%
--%% function GetSidSubAuthorityCount;
--%% begin
--%%   GetProcedureAddress(_GetSidSubAuthorityCount, advapi32, 'GetSidSubAuthorityCount');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSidSubAuthorityCount]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLengthSid: Pointer;
--%%
--%% function GetLengthSid;
--%% begin
--%%   GetProcedureAddress(_GetLengthSid, advapi32, 'GetLengthSid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLengthSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CopySid: Pointer;
--%%
--%% function CopySid;
--%% begin
--%%   GetProcedureAddress(_CopySid, advapi32, 'CopySid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CopySid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AreAllAccessesGranted: Pointer;
--%%
--%% function AreAllAccessesGranted;
--%% begin
--%%   GetProcedureAddress(_AreAllAccessesGranted, advapi32, 'AreAllAccessesGranted');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AreAllAccessesGranted]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AreAnyAccessesGranted: Pointer;
--%%
--%% function AreAnyAccessesGranted;
--%% begin
--%%   GetProcedureAddress(_AreAnyAccessesGranted, advapi32, 'AreAnyAccessesGranted');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AreAnyAccessesGranted]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MapGenericMask: Pointer;
--%%
--%% procedure MapGenericMask;
--%% begin
--%%   GetProcedureAddress(_MapGenericMask, advapi32, 'MapGenericMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MapGenericMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsValidAcl: Pointer;
--%%
--%% function IsValidAcl;
--%% begin
--%%   GetProcedureAddress(_IsValidAcl, advapi32, 'IsValidAcl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsValidAcl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitializeAcl: Pointer;
--%%
--%% function InitializeAcl;
--%% begin
--%%   GetProcedureAddress(_InitializeAcl, advapi32, 'InitializeAcl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitializeAcl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetAclInformation: Pointer;
--%%
--%% function GetAclInformation;
--%% begin
--%%   GetProcedureAddress(_GetAclInformation, advapi32, 'GetAclInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetAclInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetAclInformation: Pointer;
--%%
--%% function SetAclInformation;
--%% begin
--%%   GetProcedureAddress(_SetAclInformation, advapi32, 'SetAclInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetAclInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAce: Pointer;
--%%
--%% function AddAce;
--%% begin
--%%   GetProcedureAddress(_AddAce, advapi32, 'AddAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteAce: Pointer;
--%%
--%% function DeleteAce;
--%% begin
--%%   GetProcedureAddress(_DeleteAce, advapi32, 'DeleteAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetAce: Pointer;
--%%
--%% function GetAce;
--%% begin
--%%   GetProcedureAddress(_GetAce, advapi32, 'GetAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAccessAllowedAce: Pointer;
--%%
--%% function AddAccessAllowedAce;
--%% begin
--%%   GetProcedureAddress(_AddAccessAllowedAce, advapi32, 'AddAccessAllowedAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAccessAllowedAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAccessAllowedAceEx: Pointer;
--%%
--%% function AddAccessAllowedAceEx;
--%% begin
--%%   GetProcedureAddress(_AddAccessAllowedAceEx, advapi32, 'AddAccessAllowedAceEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAccessAllowedAceEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAccessDeniedAce: Pointer;
--%%
--%% function AddAccessDeniedAce;
--%% begin
--%%   GetProcedureAddress(_AddAccessDeniedAce, advapi32, 'AddAccessDeniedAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAccessDeniedAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAccessDeniedAceEx: Pointer;
--%%
--%% function AddAccessDeniedAceEx;
--%% begin
--%%   GetProcedureAddress(_AddAccessDeniedAceEx, advapi32, 'AddAccessDeniedAceEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAccessDeniedAceEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAuditAccessAce: Pointer;
--%%
--%% function AddAuditAccessAce;
--%% begin
--%%   GetProcedureAddress(_AddAuditAccessAce, advapi32, 'AddAuditAccessAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAuditAccessAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAuditAccessAceEx: Pointer;
--%%
--%% function AddAuditAccessAceEx;
--%% begin
--%%   GetProcedureAddress(_AddAuditAccessAceEx, advapi32, 'AddAuditAccessAceEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAuditAccessAceEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAccessAllowedObjectAce: Pointer;
--%%
--%% function AddAccessAllowedObjectAce;
--%% begin
--%%   GetProcedureAddress(_AddAccessAllowedObjectAce, advapi32, 'AddAccessAllowedObjectAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAccessAllowedObjectAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAccessDeniedObjectAce: Pointer;
--%%
--%% function AddAccessDeniedObjectAce;
--%% begin
--%%   GetProcedureAddress(_AddAccessDeniedObjectAce, advapi32, 'AddAccessDeniedObjectAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAccessDeniedObjectAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddAuditAccessObjectAce: Pointer;
--%%
--%% function AddAuditAccessObjectAce;
--%% begin
--%%   GetProcedureAddress(_AddAuditAccessObjectAce, advapi32, 'AddAuditAccessObjectAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddAuditAccessObjectAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstFreeAce: Pointer;
--%%
--%% function FindFirstFreeAce;
--%% begin
--%%   GetProcedureAddress(_FindFirstFreeAce, advapi32, 'FindFirstFreeAce');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstFreeAce]
--%%   end;
--%% end;
--%%
--%% var
--%%   _InitializeSecurityDescriptor: Pointer;
--%%
--%% function InitializeSecurityDescriptor;
--%% begin
--%%   GetProcedureAddress(_InitializeSecurityDescriptor, advapi32, 'InitializeSecurityDescriptor');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_InitializeSecurityDescriptor]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsValidSecurityDescriptor: Pointer;
--%%
--%% function IsValidSecurityDescriptor;
--%% begin
--%%   GetProcedureAddress(_IsValidSecurityDescriptor, advapi32, 'IsValidSecurityDescriptor');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsValidSecurityDescriptor]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorLength: Pointer;
--%%
--%% function GetSecurityDescriptorLength;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorLength, advapi32, 'GetSecurityDescriptorLength');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorLength]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorControl: Pointer;
--%%
--%% function GetSecurityDescriptorControl;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorControl, advapi32, 'GetSecurityDescriptorControl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorControl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSecurityDescriptorControl: Pointer;
--%%
--%% function SetSecurityDescriptorControl;
--%% begin
--%%   GetProcedureAddress(_SetSecurityDescriptorControl, advapi32, 'SetSecurityDescriptorControl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSecurityDescriptorControl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSecurityDescriptorDacl: Pointer;
--%%
--%% function SetSecurityDescriptorDacl;
--%% begin
--%%   GetProcedureAddress(_SetSecurityDescriptorDacl, advapi32, 'SetSecurityDescriptorDacl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSecurityDescriptorDacl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorDacl: Pointer;
--%%
--%% function GetSecurityDescriptorDacl;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorDacl, advapi32, 'GetSecurityDescriptorDacl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorDacl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSecurityDescriptorSacl: Pointer;
--%%
--%% function SetSecurityDescriptorSacl;
--%% begin
--%%   GetProcedureAddress(_SetSecurityDescriptorSacl, advapi32, 'SetSecurityDescriptorSacl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSecurityDescriptorSacl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorSacl: Pointer;
--%%
--%% function GetSecurityDescriptorSacl;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorSacl, advapi32, 'GetSecurityDescriptorSacl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorSacl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSecurityDescriptorOwner: Pointer;
--%%
--%% function SetSecurityDescriptorOwner;
--%% begin
--%%   GetProcedureAddress(_SetSecurityDescriptorOwner, advapi32, 'SetSecurityDescriptorOwner');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSecurityDescriptorOwner]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorOwner: Pointer;
--%%
--%% function GetSecurityDescriptorOwner;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorOwner, advapi32, 'GetSecurityDescriptorOwner');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorOwner]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSecurityDescriptorGroup: Pointer;
--%%
--%% function SetSecurityDescriptorGroup;
--%% begin
--%%   GetProcedureAddress(_SetSecurityDescriptorGroup, advapi32, 'SetSecurityDescriptorGroup');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSecurityDescriptorGroup]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorGroup: Pointer;
--%%
--%% function GetSecurityDescriptorGroup;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorGroup, advapi32, 'GetSecurityDescriptorGroup');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorGroup]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSecurityDescriptorRMControl: Pointer;
--%%
--%% function SetSecurityDescriptorRMControl;
--%% begin
--%%   GetProcedureAddress(_SetSecurityDescriptorRMControl, advapi32, 'SetSecurityDescriptorRMControl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSecurityDescriptorRMControl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSecurityDescriptorRMControl: Pointer;
--%%
--%% function GetSecurityDescriptorRMControl;
--%% begin
--%%   GetProcedureAddress(_GetSecurityDescriptorRMControl, advapi32, 'GetSecurityDescriptorRMControl');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSecurityDescriptorRMControl]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreatePrivateObjectSecurity: Pointer;
--%%
--%% function CreatePrivateObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_CreatePrivateObjectSecurity, advapi32, 'CreatePrivateObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreatePrivateObjectSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ConvertToAutoInheritPrObjSec: Pointer;
--%%
--%% function ConvertToAutoInheritPrivateObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_ConvertToAutoInheritPrObjSec, advapi32, 'ConvertToAutoInheritPrivateObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ConvertToAutoInheritPrObjSec]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreatePrivateObjectSecurityEx: Pointer;
--%%
--%% function CreatePrivateObjectSecurityEx;
--%% begin
--%%   GetProcedureAddress(_CreatePrivateObjectSecurityEx, advapi32, 'CreatePrivateObjectSecurityEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreatePrivateObjectSecurityEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetPrivateObjectSecurity: Pointer;
--%%
--%% function SetPrivateObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_SetPrivateObjectSecurity, advapi32, 'SetPrivateObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetPrivateObjectSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetPrivateObjectSecurityEx: Pointer;
--%%
--%% function SetPrivateObjectSecurityEx;
--%% begin
--%%   GetProcedureAddress(_SetPrivateObjectSecurityEx, advapi32, 'SetPrivateObjectSecurityEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetPrivateObjectSecurityEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPrivateObjectSecurity: Pointer;
--%%
--%% function GetPrivateObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_GetPrivateObjectSecurity, advapi32, 'GetPrivateObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPrivateObjectSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DestroyPrivateObjectSecurity: Pointer;
--%%
--%% function DestroyPrivateObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_DestroyPrivateObjectSecurity, advapi32, 'DestroyPrivateObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DestroyPrivateObjectSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MakeSelfRelativeSD: Pointer;
--%%
--%% function MakeSelfRelativeSD;
--%% begin
--%%   GetProcedureAddress(_MakeSelfRelativeSD, advapi32, 'MakeSelfRelativeSD');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MakeSelfRelativeSD]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MakeAbsoluteSD: Pointer;
--%%
--%% function MakeAbsoluteSD;
--%% begin
--%%   GetProcedureAddress(_MakeAbsoluteSD, advapi32, 'MakeAbsoluteSD');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MakeAbsoluteSD]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MakeAbsoluteSD2: Pointer;
--%%
--%% function MakeAbsoluteSD2;
--%% begin
--%%   GetProcedureAddress(_MakeAbsoluteSD2, advapi32, 'MakeAbsoluteSD2');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MakeAbsoluteSD2]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileSecurityA: Pointer;
--%%
--%% function SetFileSecurityA;
--%% begin
--%%   GetProcedureAddress(_SetFileSecurityA, advapi32, 'SetFileSecurityA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileSecurityA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileSecurityW: Pointer;
--%%
--%% function SetFileSecurityW;
--%% begin
--%%   GetProcedureAddress(_SetFileSecurityW, advapi32, 'SetFileSecurityW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileSecurityW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetFileSecurity: Pointer;
--%%
--%% function SetFileSecurity;
--%% begin
--%%   GetProcedureAddress(_SetFileSecurity, advapi32, 'SetFileSecurity' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetFileSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileSecurityA: Pointer;
--%%
--%% function GetFileSecurityA;
--%% begin
--%%   GetProcedureAddress(_GetFileSecurityA, advapi32, 'GetFileSecurityA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileSecurityA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileSecurityW: Pointer;
--%%
--%% function GetFileSecurityW;
--%% begin
--%%   GetProcedureAddress(_GetFileSecurityW, advapi32, 'GetFileSecurityW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileSecurityW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetFileSecurity: Pointer;
--%%
--%% function GetFileSecurity;
--%% begin
--%%   GetProcedureAddress(_GetFileSecurity, advapi32, 'GetFileSecurity' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetFileSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetKernelObjectSecurity: Pointer;
--%%
--%% function SetKernelObjectSecurity;
--%% begin
--%%   GetProcedureAddress(_SetKernelObjectSecurity, advapi32, 'SetKernelObjectSecurity');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetKernelObjectSecurity]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstChangeNotificationA: Pointer;
--%%
--%% function FindFirstChangeNotificationA;
--%% begin
--%%   GetProcedureAddress(_FindFirstChangeNotificationA, kernel32, 'FindFirstChangeNotificationA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstChangeNotificationA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstChangeNotificationW: Pointer;
--%%
--%% function FindFirstChangeNotificationW;
--%% begin
--%%   GetProcedureAddress(_FindFirstChangeNotificationW, kernel32, 'FindFirstChangeNotificationW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstChangeNotificationW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstChangeNotification: Pointer;
--%%
--%% function FindFirstChangeNotification;
--%% begin
--%%   GetProcedureAddress(_FindFirstChangeNotification, kernel32, 'FindFirstChangeNotification' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstChangeNotification]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextChangeNotification: Pointer;
--%%
--%% function FindNextChangeNotification;
--%% begin
--%%   GetProcedureAddress(_FindNextChangeNotification, kernel32, 'FindNextChangeNotification');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextChangeNotification]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindCloseChangeNotification: Pointer;
--%%
--%% function FindCloseChangeNotification;
--%% begin
--%%   GetProcedureAddress(_FindCloseChangeNotification, kernel32, 'FindCloseChangeNotification');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindCloseChangeNotification]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReadDirectoryChangesW: Pointer;
--%%
--%% function ReadDirectoryChangesW;
--%% begin
--%%   GetProcedureAddress(_ReadDirectoryChangesW, kernel32, 'ReadDirectoryChangesW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReadDirectoryChangesW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualLock: Pointer;
--%%
--%% function VirtualLock;
--%% begin
--%%   GetProcedureAddress(_VirtualLock, kernel32, 'VirtualLock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualLock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VirtualUnlock: Pointer;
--%%
--%% function VirtualUnlock;
--%% begin
--%%   GetProcedureAddress(_VirtualUnlock, kernel32, 'VirtualUnlock');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VirtualUnlock]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MapViewOfFileEx: Pointer;
--%%
--%% function MapViewOfFileEx;
--%% begin
--%%   GetProcedureAddress(_MapViewOfFileEx, kernel32, 'MapViewOfFileEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MapViewOfFileEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetPriorityClass: Pointer;
--%%
--%% function SetPriorityClass;
--%% begin
--%%   GetProcedureAddress(_SetPriorityClass, kernel32, 'SetPriorityClass');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetPriorityClass]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetPriorityClass: Pointer;
--%%
--%% function GetPriorityClass;
--%% begin
--%%   GetProcedureAddress(_GetPriorityClass, kernel32, 'GetPriorityClass');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetPriorityClass]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadReadPtr: Pointer;
--%%
--%% function IsBadReadPtr;
--%% begin
--%%   GetProcedureAddress(_IsBadReadPtr, kernel32, 'IsBadReadPtr');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadReadPtr]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadWritePtr: Pointer;
--%%
--%% function IsBadWritePtr;
--%% begin
--%%   GetProcedureAddress(_IsBadWritePtr, kernel32, 'IsBadWritePtr');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadWritePtr]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadHugeReadPtr: Pointer;
--%%
--%% function IsBadHugeReadPtr;
--%% begin
--%%   GetProcedureAddress(_IsBadHugeReadPtr, kernel32, 'IsBadHugeReadPtr');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadHugeReadPtr]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadHugeWritePtr: Pointer;
--%%
--%% function IsBadHugeWritePtr;
--%% begin
--%%   GetProcedureAddress(_IsBadHugeWritePtr, kernel32, 'IsBadHugeWritePtr');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadHugeWritePtr]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadCodePtr: Pointer;
--%%
--%% function IsBadCodePtr;
--%% begin
--%%   GetProcedureAddress(_IsBadCodePtr, kernel32, 'IsBadCodePtr');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadCodePtr]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadStringPtrA: Pointer;
--%%
--%% function IsBadStringPtrA;
--%% begin
--%%   GetProcedureAddress(_IsBadStringPtrA, kernel32, 'IsBadStringPtrA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadStringPtrA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadStringPtrW: Pointer;
--%%
--%% function IsBadStringPtrW;
--%% begin
--%%   GetProcedureAddress(_IsBadStringPtrW, kernel32, 'IsBadStringPtrW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadStringPtrW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsBadStringPtr: Pointer;
--%%
--%% function IsBadStringPtr;
--%% begin
--%%   GetProcedureAddress(_IsBadStringPtr, kernel32, 'IsBadStringPtr' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsBadStringPtr]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupAccountSidA: Pointer;
--%%
--%% function LookupAccountSidA;
--%% begin
--%%   GetProcedureAddress(_LookupAccountSidA, advapi32, 'LookupAccountSidA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupAccountSidA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupAccountSidW: Pointer;
--%%
--%% function LookupAccountSidW;
--%% begin
--%%   GetProcedureAddress(_LookupAccountSidW, advapi32, 'LookupAccountSidW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupAccountSidW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupAccountSid: Pointer;
--%%
--%% function LookupAccountSid;
--%% begin
--%%   GetProcedureAddress(_LookupAccountSid, advapi32, 'LookupAccountSid' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupAccountSid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupAccountNameA: Pointer;
--%%
--%% function LookupAccountNameA;
--%% begin
--%%   GetProcedureAddress(_LookupAccountNameA, advapi32, 'LookupAccountNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupAccountNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupAccountNameW: Pointer;
--%%
--%% function LookupAccountNameW;
--%% begin
--%%   GetProcedureAddress(_LookupAccountNameW, advapi32, 'LookupAccountNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupAccountNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupAccountName: Pointer;
--%%
--%% function LookupAccountName;
--%% begin
--%%   GetProcedureAddress(_LookupAccountName, advapi32, 'LookupAccountName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupAccountName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeValueA: Pointer;
--%%
--%% function LookupPrivilegeValueA;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeValueA, advapi32, 'LookupPrivilegeValueA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeValueA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeValueW: Pointer;
--%%
--%% function LookupPrivilegeValueW;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeValueW, advapi32, 'LookupPrivilegeValueW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeValueW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeValue: Pointer;
--%%
--%% function LookupPrivilegeValue;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeValue, advapi32, 'LookupPrivilegeValue' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeValue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeNameA: Pointer;
--%%
--%% function LookupPrivilegeNameA;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeNameA, advapi32, 'LookupPrivilegeNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeNameW: Pointer;
--%%
--%% function LookupPrivilegeNameW;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeNameW, advapi32, 'LookupPrivilegeNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeName: Pointer;
--%%
--%% function LookupPrivilegeName;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeName, advapi32, 'LookupPrivilegeName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeDisplayNameA: Pointer;
--%%
--%% function LookupPrivilegeDisplayNameA;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeDisplayNameA, advapi32, 'LookupPrivilegeDisplayNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeDisplayNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeDisplayNameW: Pointer;
--%%
--%% function LookupPrivilegeDisplayNameW;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeDisplayNameW, advapi32, 'LookupPrivilegeDisplayNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeDisplayNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LookupPrivilegeDisplayName: Pointer;
--%%
--%% function LookupPrivilegeDisplayName;
--%% begin
--%%   GetProcedureAddress(_LookupPrivilegeDisplayName, advapi32, 'LookupPrivilegeDisplayName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LookupPrivilegeDisplayName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AllocateLocallyUniqueId: Pointer;
--%%
--%% function AllocateLocallyUniqueId;
--%% begin
--%%   GetProcedureAddress(_AllocateLocallyUniqueId, advapi32, 'AllocateLocallyUniqueId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AllocateLocallyUniqueId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BuildCommDCBA: Pointer;
--%%
--%% function BuildCommDCBA;
--%% begin
--%%   GetProcedureAddress(_BuildCommDCBA, kernel32, 'BuildCommDCBA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BuildCommDCBA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BuildCommDCBW: Pointer;
--%%
--%% function BuildCommDCBW;
--%% begin
--%%   GetProcedureAddress(_BuildCommDCBW, kernel32, 'BuildCommDCBW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BuildCommDCBW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BuildCommDCB: Pointer;
--%%
--%% function BuildCommDCB;
--%% begin
--%%   GetProcedureAddress(_BuildCommDCB, kernel32, 'BuildCommDCB' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BuildCommDCB]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BuildCommDCBAndTimeoutsA: Pointer;
--%%
--%% function BuildCommDCBAndTimeoutsA;
--%% begin
--%%   GetProcedureAddress(_BuildCommDCBAndTimeoutsA, kernel32, 'BuildCommDCBAndTimeoutsA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BuildCommDCBAndTimeoutsA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BuildCommDCBAndTimeoutsW: Pointer;
--%%
--%% function BuildCommDCBAndTimeoutsW;
--%% begin
--%%   GetProcedureAddress(_BuildCommDCBAndTimeoutsW, kernel32, 'BuildCommDCBAndTimeoutsW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BuildCommDCBAndTimeoutsW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BuildCommDCBAndTimeouts: Pointer;
--%%
--%% function BuildCommDCBAndTimeouts;
--%% begin
--%%   GetProcedureAddress(_BuildCommDCBAndTimeouts, kernel32, 'BuildCommDCBAndTimeouts' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BuildCommDCBAndTimeouts]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CommConfigDialogA: Pointer;
--%%
--%% function CommConfigDialogA;
--%% begin
--%%   GetProcedureAddress(_CommConfigDialogA, kernel32, 'CommConfigDialogA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CommConfigDialogA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CommConfigDialogW: Pointer;
--%%
--%% function CommConfigDialogW;
--%% begin
--%%   GetProcedureAddress(_CommConfigDialogW, kernel32, 'CommConfigDialogW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CommConfigDialogW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CommConfigDialog: Pointer;
--%%
--%% function CommConfigDialog;
--%% begin
--%%   GetProcedureAddress(_CommConfigDialog, kernel32, 'CommConfigDialog' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CommConfigDialog]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDefaultCommConfigA: Pointer;
--%%
--%% function GetDefaultCommConfigA;
--%% begin
--%%   GetProcedureAddress(_GetDefaultCommConfigA, kernel32, 'GetDefaultCommConfigA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDefaultCommConfigA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDefaultCommConfigW: Pointer;
--%%
--%% function GetDefaultCommConfigW;
--%% begin
--%%   GetProcedureAddress(_GetDefaultCommConfigW, kernel32, 'GetDefaultCommConfigW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDefaultCommConfigW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetDefaultCommConfig: Pointer;
--%%
--%% function GetDefaultCommConfig;
--%% begin
--%%   GetProcedureAddress(_GetDefaultCommConfig, kernel32, 'GetDefaultCommConfig' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetDefaultCommConfig]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetDefaultCommConfigA: Pointer;
--%%
--%% function SetDefaultCommConfigA;
--%% begin
--%%   GetProcedureAddress(_SetDefaultCommConfigA, kernel32, 'SetDefaultCommConfigA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetDefaultCommConfigA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetDefaultCommConfigW: Pointer;
--%%
--%% function SetDefaultCommConfigW;
--%% begin
--%%   GetProcedureAddress(_SetDefaultCommConfigW, kernel32, 'SetDefaultCommConfigW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetDefaultCommConfigW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetDefaultCommConfig: Pointer;
--%%
--%% function SetDefaultCommConfig;
--%% begin
--%%   GetProcedureAddress(_SetDefaultCommConfig, kernel32, 'SetDefaultCommConfig' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetDefaultCommConfig]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetComputerNameA: Pointer;
--%%
--%% function GetComputerNameA;
--%% begin
--%%   GetProcedureAddress(_GetComputerNameA, kernel32, 'GetComputerNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetComputerNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetComputerNameW: Pointer;
--%%
--%% function GetComputerNameW;
--%% begin
--%%   GetProcedureAddress(_GetComputerNameW, kernel32, 'GetComputerNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetComputerNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetComputerName: Pointer;
--%%
--%% function GetComputerName;
--%% begin
--%%   GetProcedureAddress(_GetComputerName, kernel32, 'GetComputerName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetComputerName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetComputerNameA: Pointer;
--%%
--%% function SetComputerNameA;
--%% begin
--%%   GetProcedureAddress(_SetComputerNameA, kernel32, 'SetComputerNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetComputerNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetComputerNameW: Pointer;
--%%
--%% function SetComputerNameW;
--%% begin
--%%   GetProcedureAddress(_SetComputerNameW, kernel32, 'SetComputerNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetComputerNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetComputerName: Pointer;
--%%
--%% function SetComputerName;
--%% begin
--%%   GetProcedureAddress(_SetComputerName, kernel32, 'SetComputerName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetComputerName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetComputerNameExA: Pointer;
--%%
--%% function GetComputerNameExA;
--%% begin
--%%   GetProcedureAddress(_GetComputerNameExA, kernel32, 'GetComputerNameExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetComputerNameExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetComputerNameExW: Pointer;
--%%
--%% function GetComputerNameExW;
--%% begin
--%%   GetProcedureAddress(_GetComputerNameExW, kernel32, 'GetComputerNameExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetComputerNameExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetComputerNameEx: Pointer;
--%%
--%% function GetComputerNameEx;
--%% begin
--%%   GetProcedureAddress(_GetComputerNameEx, kernel32, 'GetComputerNameEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetComputerNameEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetComputerNameExA: Pointer;
--%%
--%% function SetComputerNameExA;
--%% begin
--%%   GetProcedureAddress(_SetComputerNameExA, kernel32, 'SetComputerNameExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetComputerNameExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetComputerNameExW: Pointer;
--%%
--%% function SetComputerNameExW;
--%% begin
--%%   GetProcedureAddress(_SetComputerNameExW, kernel32, 'SetComputerNameExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetComputerNameExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetComputerNameEx: Pointer;
--%%
--%% function SetComputerNameEx;
--%% begin
--%%   GetProcedureAddress(_SetComputerNameEx, kernel32, 'SetComputerNameEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetComputerNameEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DnsHostnameToComputerNameA: Pointer;
--%%
--%% function DnsHostnameToComputerNameA;
--%% begin
--%%   GetProcedureAddress(_DnsHostnameToComputerNameA, kernel32, 'DnsHostnameToComputerNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DnsHostnameToComputerNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DnsHostnameToComputerNameW: Pointer;
--%%
--%% function DnsHostnameToComputerNameW;
--%% begin
--%%   GetProcedureAddress(_DnsHostnameToComputerNameW, kernel32, 'DnsHostnameToComputerNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DnsHostnameToComputerNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DnsHostnameToComputerName: Pointer;
--%%
--%% function DnsHostnameToComputerName;
--%% begin
--%%   GetProcedureAddress(_DnsHostnameToComputerName, kernel32, 'DnsHostnameToComputerName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DnsHostnameToComputerName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetUserNameA: Pointer;
--%%
--%% function GetUserNameA;
--%% begin
--%%   GetProcedureAddress(_GetUserNameA, advapi32, 'GetUserNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetUserNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetUserNameW: Pointer;
--%%
--%% function GetUserNameW;
--%% begin
--%%   GetProcedureAddress(_GetUserNameW, advapi32, 'GetUserNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetUserNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetUserName: Pointer;
--%%
--%% function GetUserName;
--%% begin
--%%   GetProcedureAddress(_GetUserName, advapi32, 'GetUserName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetUserName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LogonUserA: Pointer;
--%%
--%% function LogonUserA;
--%% begin
--%%   GetProcedureAddress(_LogonUserA, advapi32, 'LogonUserA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LogonUserA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LogonUserW: Pointer;
--%%
--%% function LogonUserW;
--%% begin
--%%   GetProcedureAddress(_LogonUserW, advapi32, 'LogonUserW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LogonUserW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LogonUser: Pointer;
--%%
--%% function LogonUser;
--%% begin
--%%   GetProcedureAddress(_LogonUser, advapi32, 'LogonUser' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LogonUser]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LogonUserExA: Pointer;
--%%
--%% function LogonUserExA;
--%% begin
--%%   GetProcedureAddress(_LogonUserExA, advapi32, 'LogonUserExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LogonUserExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LogonUserExW: Pointer;
--%%
--%% function LogonUserExW;
--%% begin
--%%   GetProcedureAddress(_LogonUserExW, advapi32, 'LogonUserExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LogonUserExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _LogonUserEx: Pointer;
--%%
--%% function LogonUserEx;
--%% begin
--%%   GetProcedureAddress(_LogonUserEx, advapi32, 'LogonUserEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_LogonUserEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ImpersonateLoggedOnUser: Pointer;
--%%
--%% function ImpersonateLoggedOnUser;
--%% begin
--%%   GetProcedureAddress(_ImpersonateLoggedOnUser, advapi32, 'ImpersonateLoggedOnUser');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ImpersonateLoggedOnUser]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessAsUserA: Pointer;
--%%
--%% function CreateProcessAsUserA;
--%% begin
--%%   GetProcedureAddress(_CreateProcessAsUserA, advapi32, 'CreateProcessAsUserA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessAsUserA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessAsUserW: Pointer;
--%%
--%% function CreateProcessAsUserW;
--%% begin
--%%   GetProcedureAddress(_CreateProcessAsUserW, advapi32, 'CreateProcessAsUserW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessAsUserW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessAsUser: Pointer;
--%%
--%% function CreateProcessAsUser;
--%% begin
--%%   GetProcedureAddress(_CreateProcessAsUser, advapi32, 'CreateProcessAsUser' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessAsUser]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessWithLogonW: Pointer;
--%%
--%% function CreateProcessWithLogonW;
--%% begin
--%%   GetProcedureAddress(_CreateProcessWithLogonW, advapi32, 'CreateProcessWithLogonW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessWithLogonW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateProcessWithTokenW: Pointer;
--%%
--%% function CreateProcessWithTokenW;
--%% begin
--%%   GetProcedureAddress(_CreateProcessWithTokenW, advapi32, 'CreateProcessWithTokenW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateProcessWithTokenW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ImpersonateAnonymousToken: Pointer;
--%%
--%% function ImpersonateAnonymousToken;
--%% begin
--%%   GetProcedureAddress(_ImpersonateAnonymousToken, advapi32, 'ImpersonateAnonymousToken');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ImpersonateAnonymousToken]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DuplicateTokenEx: Pointer;
--%%
--%% function DuplicateTokenEx;
--%% begin
--%%   GetProcedureAddress(_DuplicateTokenEx, advapi32, 'DuplicateTokenEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DuplicateTokenEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateRestrictedToken: Pointer;
--%%
--%% function CreateRestrictedToken;
--%% begin
--%%   GetProcedureAddress(_CreateRestrictedToken, advapi32, 'CreateRestrictedToken');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateRestrictedToken]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsTokenRestricted: Pointer;
--%%
--%% function IsTokenRestricted;
--%% begin
--%%   GetProcedureAddress(_IsTokenRestricted, advapi32, 'IsTokenRestricted');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsTokenRestricted]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CheckTokenMembership: Pointer;
--%%
--%% function CheckTokenMembership;
--%% begin
--%%   GetProcedureAddress(_CheckTokenMembership, advapi32, 'CheckTokenMembership');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CheckTokenMembership]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsTokenUntrusted: Pointer;
--%%
--%% function IsTokenUntrusted;
--%% begin
--%%   GetProcedureAddress(_IsTokenUntrusted, advapi32, 'IsTokenUntrusted');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsTokenUntrusted]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RegisterWaitForSingleObject: Pointer;
--%%
--%% function RegisterWaitForSingleObject;
--%% begin
--%%   GetProcedureAddress(_RegisterWaitForSingleObject, kernel32, 'RegisterWaitForSingleObject');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RegisterWaitForSingleObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RegisterWaitForSingleObjectEx: Pointer;
--%%
--%% function RegisterWaitForSingleObjectEx;
--%% begin
--%%   GetProcedureAddress(_RegisterWaitForSingleObjectEx, kernel32, 'RegisterWaitForSingleObjectEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RegisterWaitForSingleObjectEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UnregisterWait: Pointer;
--%%
--%% function UnregisterWait;
--%% begin
--%%   GetProcedureAddress(_UnregisterWait, kernel32, 'UnregisterWait');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UnregisterWait]
--%%   end;
--%% end;
--%%
--%% var
--%%   _UnregisterWaitEx: Pointer;
--%%
--%% function UnregisterWaitEx;
--%% begin
--%%   GetProcedureAddress(_UnregisterWaitEx, kernel32, 'UnregisterWaitEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_UnregisterWaitEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueueUserWorkItem: Pointer;
--%%
--%% function QueueUserWorkItem;
--%% begin
--%%   GetProcedureAddress(_QueueUserWorkItem, kernel32, 'QueueUserWorkItem');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueueUserWorkItem]
--%%   end;
--%% end;
--%%
--%% var
--%%   _BindIoCompletionCallback: Pointer;
--%%
--%% function BindIoCompletionCallback;
--%% begin
--%%   GetProcedureAddress(_BindIoCompletionCallback, kernel32, 'BindIoCompletionCallback');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_BindIoCompletionCallback]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateTimerQueue: Pointer;
--%%
--%% function CreateTimerQueue;
--%% begin
--%%   GetProcedureAddress(_CreateTimerQueue, kernel32, 'CreateTimerQueue');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateTimerQueue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateTimerQueueTimer: Pointer;
--%%
--%% function CreateTimerQueueTimer;
--%% begin
--%%   GetProcedureAddress(_CreateTimerQueueTimer, kernel32, 'CreateTimerQueueTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateTimerQueueTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ChangeTimerQueueTimer: Pointer;
--%%
--%% function ChangeTimerQueueTimer;
--%% begin
--%%   GetProcedureAddress(_ChangeTimerQueueTimer, kernel32, 'ChangeTimerQueueTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ChangeTimerQueueTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteTimerQueueTimer: Pointer;
--%%
--%% function DeleteTimerQueueTimer;
--%% begin
--%%   GetProcedureAddress(_DeleteTimerQueueTimer, kernel32, 'DeleteTimerQueueTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteTimerQueueTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteTimerQueueEx: Pointer;
--%%
--%% function DeleteTimerQueueEx;
--%% begin
--%%   GetProcedureAddress(_DeleteTimerQueueEx, kernel32, 'DeleteTimerQueueEx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteTimerQueueEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetTimerQueueTimer: Pointer;
--%%
--%% function SetTimerQueueTimer;
--%% begin
--%%   GetProcedureAddress(_SetTimerQueueTimer, kernel32, 'SetTimerQueueTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetTimerQueueTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CancelTimerQueueTimer: Pointer;
--%%
--%% function CancelTimerQueueTimer;
--%% begin
--%%   GetProcedureAddress(_CancelTimerQueueTimer, kernel32, 'CancelTimerQueueTimer');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CancelTimerQueueTimer]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteTimerQueue: Pointer;
--%%
--%% function DeleteTimerQueue;
--%% begin
--%%   GetProcedureAddress(_DeleteTimerQueue, kernel32, 'DeleteTimerQueue');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteTimerQueue]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentHwProfileA: Pointer;
--%%
--%% function GetCurrentHwProfileA;
--%% begin
--%%   GetProcedureAddress(_GetCurrentHwProfileA, advapi32, 'GetCurrentHwProfileA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentHwProfileA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentHwProfileW: Pointer;
--%%
--%% function GetCurrentHwProfileW;
--%% begin
--%%   GetProcedureAddress(_GetCurrentHwProfileW, advapi32, 'GetCurrentHwProfileW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentHwProfileW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentHwProfile: Pointer;
--%%
--%% function GetCurrentHwProfile;
--%% begin
--%%   GetProcedureAddress(_GetCurrentHwProfile, advapi32, 'GetCurrentHwProfile' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentHwProfile]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryPerformanceCounter: Pointer;
--%%
--%% function QueryPerformanceCounter;
--%% begin
--%%   GetProcedureAddress(_QueryPerformanceCounter, kernel32, 'QueryPerformanceCounter');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryPerformanceCounter]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryPerformanceFrequency: Pointer;
--%%
--%% function QueryPerformanceFrequency;
--%% begin
--%%   GetProcedureAddress(_QueryPerformanceFrequency, kernel32, 'QueryPerformanceFrequency');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryPerformanceFrequency]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVersionExA: Pointer;
--%%
--%% function GetVersionExA;
--%% begin
--%%   GetProcedureAddress(_GetVersionExA, kernel32, 'GetVersionExA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVersionExA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVersionExW: Pointer;
--%%
--%% function GetVersionExW;
--%% begin
--%%   GetProcedureAddress(_GetVersionExW, kernel32, 'GetVersionExW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVersionExW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVersionEx: Pointer;
--%%
--%% function GetVersionEx;
--%% begin
--%%   GetProcedureAddress(_GetVersionEx, kernel32, 'GetVersionEx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVersionEx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VerifyVersionInfoA: Pointer;
--%%
--%% function VerifyVersionInfoA;
--%% begin
--%%   GetProcedureAddress(_VerifyVersionInfoA, kernel32, 'VerifyVersionInfoA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VerifyVersionInfoA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VerifyVersionInfoW: Pointer;
--%%
--%% function VerifyVersionInfoW;
--%% begin
--%%   GetProcedureAddress(_VerifyVersionInfoW, kernel32, 'VerifyVersionInfoW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VerifyVersionInfoW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _VerifyVersionInfo: Pointer;
--%%
--%% function VerifyVersionInfo;
--%% begin
--%%   GetProcedureAddress(_VerifyVersionInfo, kernel32, 'VerifyVersionInfo' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_VerifyVersionInfo]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetSystemPowerStatus: Pointer;
--%%
--%% function GetSystemPowerStatus;
--%% begin
--%%   GetProcedureAddress(_GetSystemPowerStatus, kernel32, 'GetSystemPowerStatus');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetSystemPowerStatus]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetSystemPowerState: Pointer;
--%%
--%% function SetSystemPowerState;
--%% begin
--%%   GetProcedureAddress(_SetSystemPowerState, kernel32, 'SetSystemPowerState');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetSystemPowerState]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AllocateUserPhysicalPages: Pointer;
--%%
--%% function AllocateUserPhysicalPages;
--%% begin
--%%   GetProcedureAddress(_AllocateUserPhysicalPages, kernel32, 'AllocateUserPhysicalPages');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AllocateUserPhysicalPages]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FreeUserPhysicalPages: Pointer;
--%%
--%% function FreeUserPhysicalPages;
--%% begin
--%%   GetProcedureAddress(_FreeUserPhysicalPages, kernel32, 'FreeUserPhysicalPages');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FreeUserPhysicalPages]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MapUserPhysicalPages: Pointer;
--%%
--%% function MapUserPhysicalPages;
--%% begin
--%%   GetProcedureAddress(_MapUserPhysicalPages, kernel32, 'MapUserPhysicalPages');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MapUserPhysicalPages]
--%%   end;
--%% end;
--%%
--%% var
--%%   _MapUserPhysicalPagesScatter: Pointer;
--%%
--%% function MapUserPhysicalPagesScatter;
--%% begin
--%%   GetProcedureAddress(_MapUserPhysicalPagesScatter, kernel32, 'MapUserPhysicalPagesScatter');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_MapUserPhysicalPagesScatter]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateJobObjectA: Pointer;
--%%
--%% function CreateJobObjectA;
--%% begin
--%%   GetProcedureAddress(_CreateJobObjectA, kernel32, 'CreateJobObjectA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateJobObjectA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateJobObjectW: Pointer;
--%%
--%% function CreateJobObjectW;
--%% begin
--%%   GetProcedureAddress(_CreateJobObjectW, kernel32, 'CreateJobObjectW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateJobObjectW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateJobObject: Pointer;
--%%
--%% function CreateJobObject;
--%% begin
--%%   GetProcedureAddress(_CreateJobObject, kernel32, 'CreateJobObject' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateJobObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenJobObjectA: Pointer;
--%%
--%% function OpenJobObjectA;
--%% begin
--%%   GetProcedureAddress(_OpenJobObjectA, kernel32, 'OpenJobObjectA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenJobObjectA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenJobObjectW: Pointer;
--%%
--%% function OpenJobObjectW;
--%% begin
--%%   GetProcedureAddress(_OpenJobObjectW, kernel32, 'OpenJobObjectW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenJobObjectW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _OpenJobObject: Pointer;
--%%
--%% function OpenJobObject;
--%% begin
--%%   GetProcedureAddress(_OpenJobObject, kernel32, 'OpenJobObject' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_OpenJobObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AssignProcessToJobObject: Pointer;
--%%
--%% function AssignProcessToJobObject;
--%% begin
--%%   GetProcedureAddress(_AssignProcessToJobObject, kernel32, 'AssignProcessToJobObject');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AssignProcessToJobObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _TerminateJobObject: Pointer;
--%%
--%% function TerminateJobObject;
--%% begin
--%%   GetProcedureAddress(_TerminateJobObject, kernel32, 'TerminateJobObject');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_TerminateJobObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryInformationJobObject: Pointer;
--%%
--%% function QueryInformationJobObject;
--%% begin
--%%   GetProcedureAddress(_QueryInformationJobObject, kernel32, 'QueryInformationJobObject');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryInformationJobObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetInformationJobObject: Pointer;
--%%
--%% function SetInformationJobObject;
--%% begin
--%%   GetProcedureAddress(_SetInformationJobObject, kernel32, 'SetInformationJobObject');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetInformationJobObject]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsProcessInJob: Pointer;
--%%
--%% function IsProcessInJob;
--%% begin
--%%   GetProcedureAddress(_IsProcessInJob, kernel32, 'IsProcessInJob');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsProcessInJob]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateJobSet: Pointer;
--%%
--%% function CreateJobSet;
--%% begin
--%%   GetProcedureAddress(_CreateJobSet, kernel32, 'CreateJobSet');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateJobSet]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddVectoredExceptionHandler: Pointer;
--%%
--%% function AddVectoredExceptionHandler;
--%% begin
--%%   GetProcedureAddress(_AddVectoredExceptionHandler, kernel32, 'AddVectoredExceptionHandler');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddVectoredExceptionHandler]
--%%   end;
--%% end;
--%%
--%% var
--%%   _RemoveVectoredExceptionHandler: Pointer;
--%%
--%% function RemoveVectoredExceptionHandler;
--%% begin
--%%   GetProcedureAddress(_RemoveVectoredExceptionHandler, kernel32, 'RemoveVectoredExceptionHandler');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_RemoveVectoredExceptionHandler]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstVolumeA: Pointer;
--%%
--%% function FindFirstVolumeA;
--%% begin
--%%   GetProcedureAddress(_FindFirstVolumeA, kernel32, 'FindFirstVolumeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstVolumeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstVolumeW: Pointer;
--%%
--%% function FindFirstVolumeW;
--%% begin
--%%   GetProcedureAddress(_FindFirstVolumeW, kernel32, 'FindFirstVolumeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstVolumeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstVolume: Pointer;
--%%
--%% function FindFirstVolume;
--%% begin
--%%   GetProcedureAddress(_FindFirstVolume, kernel32, 'FindFirstVolume' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstVolume]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextVolumeA: Pointer;
--%%
--%% function FindNextVolumeA;
--%% begin
--%%   GetProcedureAddress(_FindNextVolumeA, kernel32, 'FindNextVolumeA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextVolumeA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextVolumeW: Pointer;
--%%
--%% function FindNextVolumeW;
--%% begin
--%%   GetProcedureAddress(_FindNextVolumeW, kernel32, 'FindNextVolumeW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextVolumeW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextVolume: Pointer;
--%%
--%% function FindNextVolume;
--%% begin
--%%   GetProcedureAddress(_FindNextVolume, kernel32, 'FindNextVolume' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextVolume]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindVolumeClose: Pointer;
--%%
--%% function FindVolumeClose;
--%% begin
--%%   GetProcedureAddress(_FindVolumeClose, kernel32, 'FindVolumeClose');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindVolumeClose]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstVolumeMountPointA: Pointer;
--%%
--%% function FindFirstVolumeMountPointA;
--%% begin
--%%   GetProcedureAddress(_FindFirstVolumeMountPointA, kernel32, 'FindFirstVolumeMountPointA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstVolumeMountPointA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstVolumeMountPointW: Pointer;
--%%
--%% function FindFirstVolumeMountPointW;
--%% begin
--%%   GetProcedureAddress(_FindFirstVolumeMountPointW, kernel32, 'FindFirstVolumeMountPointW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstVolumeMountPointW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindFirstVolumeMountPoint: Pointer;
--%%
--%% function FindFirstVolumeMountPoint;
--%% begin
--%%   GetProcedureAddress(_FindFirstVolumeMountPoint, kernel32, 'FindFirstVolumeMountPoint' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindFirstVolumeMountPoint]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextVolumeMountPointA: Pointer;
--%%
--%% function FindNextVolumeMountPointA;
--%% begin
--%%   GetProcedureAddress(_FindNextVolumeMountPointA, kernel32, 'FindNextVolumeMountPointA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextVolumeMountPointA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextVolumeMountPointW: Pointer;
--%%
--%% function FindNextVolumeMountPointW;
--%% begin
--%%   GetProcedureAddress(_FindNextVolumeMountPointW, kernel32, 'FindNextVolumeMountPointW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextVolumeMountPointW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindNextVolumeMountPoint: Pointer;
--%%
--%% function FindNextVolumeMountPoint;
--%% begin
--%%   GetProcedureAddress(_FindNextVolumeMountPoint, kernel32, 'FindNextVolumeMountPoint' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindNextVolumeMountPoint]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindVolumeMountPointClose: Pointer;
--%%
--%% function FindVolumeMountPointClose;
--%% begin
--%%   GetProcedureAddress(_FindVolumeMountPointClose, kernel32, 'FindVolumeMountPointClose');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindVolumeMountPointClose]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetVolumeMountPointA: Pointer;
--%%
--%% function SetVolumeMountPointA;
--%% begin
--%%   GetProcedureAddress(_SetVolumeMountPointA, kernel32, 'SetVolumeMountPointA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetVolumeMountPointA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetVolumeMountPointW: Pointer;
--%%
--%% function SetVolumeMountPointW;
--%% begin
--%%   GetProcedureAddress(_SetVolumeMountPointW, kernel32, 'SetVolumeMountPointW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetVolumeMountPointW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _SetVolumeMountPoint: Pointer;
--%%
--%% function SetVolumeMountPoint;
--%% begin
--%%   GetProcedureAddress(_SetVolumeMountPoint, kernel32, 'SetVolumeMountPoint' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_SetVolumeMountPoint]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteVolumeMountPointA: Pointer;
--%%
--%% function DeleteVolumeMountPointA;
--%% begin
--%%   GetProcedureAddress(_DeleteVolumeMountPointA, kernel32, 'DeleteVolumeMountPointA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteVolumeMountPointA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteVolumeMountPointW: Pointer;
--%%
--%% function DeleteVolumeMountPointW;
--%% begin
--%%   GetProcedureAddress(_DeleteVolumeMountPointW, kernel32, 'DeleteVolumeMountPointW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteVolumeMountPointW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeleteVolumeMountPoint: Pointer;
--%%
--%% function DeleteVolumeMountPoint;
--%% begin
--%%   GetProcedureAddress(_DeleteVolumeMountPoint, kernel32, 'DeleteVolumeMountPoint' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeleteVolumeMountPoint]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumeNameForVolMountPointA: Pointer;
--%%
--%% function GetVolumeNameForVolumeMountPointA;
--%% begin
--%%   GetProcedureAddress(_GetVolumeNameForVolMountPointA, kernel32, 'GetVolumeNameForVolumeMountPointA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumeNameForVolMountPointA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumeNameForVolMountPointW: Pointer;
--%%
--%% function GetVolumeNameForVolumeMountPointW;
--%% begin
--%%   GetProcedureAddress(_GetVolumeNameForVolMountPointW, kernel32, 'GetVolumeNameForVolumeMountPointW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumeNameForVolMountPointW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumeNameForVolMountPoint: Pointer;
--%%
--%% function GetVolumeNameForVolumeMountPoint;
--%% begin
--%%   GetProcedureAddress(_GetVolumeNameForVolMountPoint, kernel32, 'GetVolumeNameForVolumeMountPoint' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumeNameForVolMountPoint]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumePathNameA: Pointer;
--%%
--%% function GetVolumePathNameA;
--%% begin
--%%   GetProcedureAddress(_GetVolumePathNameA, kernel32, 'GetVolumePathNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumePathNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumePathNameW: Pointer;
--%%
--%% function GetVolumePathNameW;
--%% begin
--%%   GetProcedureAddress(_GetVolumePathNameW, kernel32, 'GetVolumePathNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumePathNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumePathName: Pointer;
--%%
--%% function GetVolumePathName;
--%% begin
--%%   GetProcedureAddress(_GetVolumePathName, kernel32, 'GetVolumePathName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumePathName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumePathNamesForVolNameA: Pointer;
--%%
--%% function GetVolumePathNamesForVolumeNameA;
--%% begin
--%%   GetProcedureAddress(_GetVolumePathNamesForVolNameA, kernel32, 'GetVolumePathNamesForVolumeNameA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumePathNamesForVolNameA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumePathNamesForVolNameW: Pointer;
--%%
--%% function GetVolumePathNamesForVolumeNameW;
--%% begin
--%%   GetProcedureAddress(_GetVolumePathNamesForVolNameW, kernel32, 'GetVolumePathNamesForVolumeNameW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumePathNamesForVolNameW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetVolumePathNamesForVolName: Pointer;
--%%
--%% function GetVolumePathNamesForVolumeName;
--%% begin
--%%   GetProcedureAddress(_GetVolumePathNamesForVolName, kernel32, 'GetVolumePathNamesForVolumeName' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetVolumePathNamesForVolName]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateActCtxA: Pointer;
--%%
--%% function CreateActCtxA;
--%% begin
--%%   GetProcedureAddress(_CreateActCtxA, kernel32, 'CreateActCtxA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateActCtxA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateActCtxW: Pointer;
--%%
--%% function CreateActCtxW;
--%% begin
--%%   GetProcedureAddress(_CreateActCtxW, kernel32, 'CreateActCtxW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateActCtxW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _CreateActCtx: Pointer;
--%%
--%% function CreateActCtx;
--%% begin
--%%   GetProcedureAddress(_CreateActCtx, kernel32, 'CreateActCtx' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_CreateActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _AddRefActCtx: Pointer;
--%%
--%% procedure AddRefActCtx;
--%% begin
--%%   GetProcedureAddress(_AddRefActCtx, kernel32, 'AddRefActCtx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_AddRefActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ReleaseActCtx: Pointer;
--%%
--%% procedure ReleaseActCtx;
--%% begin
--%%   GetProcedureAddress(_ReleaseActCtx, kernel32, 'ReleaseActCtx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ReleaseActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ZombifyActCtx: Pointer;
--%%
--%% function ZombifyActCtx;
--%% begin
--%%   GetProcedureAddress(_ZombifyActCtx, kernel32, 'ZombifyActCtx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ZombifyActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ActivateActCtx: Pointer;
--%%
--%% function ActivateActCtx;
--%% begin
--%%   GetProcedureAddress(_ActivateActCtx, kernel32, 'ActivateActCtx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ActivateActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _DeactivateActCtx: Pointer;
--%%
--%% function DeactivateActCtx;
--%% begin
--%%   GetProcedureAddress(_DeactivateActCtx, kernel32, 'DeactivateActCtx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_DeactivateActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetCurrentActCtx: Pointer;
--%%
--%% function GetCurrentActCtx;
--%% begin
--%%   GetProcedureAddress(_GetCurrentActCtx, kernel32, 'GetCurrentActCtx');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetCurrentActCtx]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindActCtxSectionStringA: Pointer;
--%%
--%% function FindActCtxSectionStringA;
--%% begin
--%%   GetProcedureAddress(_FindActCtxSectionStringA, kernel32, 'FindActCtxSectionStringA');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindActCtxSectionStringA]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindActCtxSectionStringW: Pointer;
--%%
--%% function FindActCtxSectionStringW;
--%% begin
--%%   GetProcedureAddress(_FindActCtxSectionStringW, kernel32, 'FindActCtxSectionStringW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindActCtxSectionStringW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindActCtxSectionString: Pointer;
--%%
--%% function FindActCtxSectionString;
--%% begin
--%%   GetProcedureAddress(_FindActCtxSectionString, kernel32, 'FindActCtxSectionString' + AWSuffix);
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindActCtxSectionString]
--%%   end;
--%% end;
--%%
--%% var
--%%   _FindActCtxSectionGuid: Pointer;
--%%
--%% function FindActCtxSectionGuid;
--%% begin
--%%   GetProcedureAddress(_FindActCtxSectionGuid, kernel32, 'FindActCtxSectionGuid');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_FindActCtxSectionGuid]
--%%   end;
--%% end;
--%%
--%% var
--%%   _QueryActCtxW: Pointer;
--%%
--%% function QueryActCtxW;
--%% begin
--%%   GetProcedureAddress(_QueryActCtxW, kernel32, 'QueryActCtxW');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_QueryActCtxW]
--%%   end;
--%% end;
--%%
--%% var
--%%   _ProcessIdToSessionId: Pointer;
--%%
--%% function ProcessIdToSessionId;
--%% begin
--%%   GetProcedureAddress(_ProcessIdToSessionId, kernel32, 'ProcessIdToSessionId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_ProcessIdToSessionId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _WTSGetActiveConsoleSessionId: Pointer;
--%%
--%% function WTSGetActiveConsoleSessionId;
--%% begin
--%%   GetProcedureAddress(_WTSGetActiveConsoleSessionId, kernel32, 'WTSGetActiveConsoleSessionId');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_WTSGetActiveConsoleSessionId]
--%%   end;
--%% end;
--%%
--%% var
--%%   _IsWow64Process: Pointer;
--%%
--%% function IsWow64Process;
--%% begin
--%%   GetProcedureAddress(_IsWow64Process, kernel32, 'IsWow64Process');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_IsWow64Process]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetLogicalProcessorInformation: Pointer;
--%%
--%% function GetLogicalProcessorInformation;
--%% begin
--%%   GetProcedureAddress(_GetLogicalProcessorInformation, kernel32, 'GetLogicalProcessorInformation');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetLogicalProcessorInformation]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNumaHighestNodeNumber: Pointer;
--%%
--%% function GetNumaHighestNodeNumber;
--%% begin
--%%   GetProcedureAddress(_GetNumaHighestNodeNumber, kernel32, 'GetNumaHighestNodeNumber');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNumaHighestNodeNumber]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNumaProcessorNode: Pointer;
--%%
--%% function GetNumaProcessorNode;
--%% begin
--%%   GetProcedureAddress(_GetNumaProcessorNode, kernel32, 'GetNumaProcessorNode');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNumaProcessorNode]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNumaNodeProcessorMask: Pointer;
--%%
--%% function GetNumaNodeProcessorMask;
--%% begin
--%%   GetProcedureAddress(_GetNumaNodeProcessorMask, kernel32, 'GetNumaNodeProcessorMask');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNumaNodeProcessorMask]
--%%   end;
--%% end;
--%%
--%% var
--%%   _GetNumaAvailableMemoryNode: Pointer;
--%%
--%% function GetNumaAvailableMemoryNode;
--%% begin
--%%   GetProcedureAddress(_GetNumaAvailableMemoryNode, kernel32, 'GetNumaAvailableMemoryNode');
--%%   asm
--%%         MOV     ESP, EBP
--%%         POP     EBP
--%%         JMP     [_GetNumaAvailableMemoryNode]
--%%   end;
--%% end;
--%%
--%% {$ELSE}
--%%
--%% function InterlockedCompareExchange64; external kernel32 name 'InterlockedCompareExchange64';
--%% function InterlockedIncrement; external kernel32 name 'InterlockedIncrement';
--%% function InterlockedDecrement; external kernel32 name 'InterlockedDecrement';
--%% function InterlockedExchange; external kernel32 name 'InterlockedExchange';
--%% function InterlockedExchangeAdd; external kernel32 name 'InterlockedExchangeAdd';
--%% function InterlockedCompareExchange; external kernel32 name 'InterlockedCompareExchange';
--%% procedure InitializeSListHead; external kernel32 name 'InitializeSListHead';
--%% function InterlockedPopEntrySList; external kernel32 name 'InterlockedPopEntrySList';
--%% function InterlockedPushEntrySList; external kernel32 name 'InterlockedPushEntrySList';
--%% function InterlockedFlushSList; external kernel32 name 'InterlockedFlushSList';
--%% function QueryDepthSList; external kernel32 name 'QueryDepthSList';
--%% function FreeResource; external kernel32 name 'FreeResource';
--%% function LockResource; external kernel32 name 'LockResource';
--%% function FreeLibrary; external kernel32 name 'FreeLibrary';
--%% procedure FreeLibraryAndExitThread; external kernel32 name 'FreeLibraryAndExitThread';
--%% function DisableThreadLibraryCalls; external kernel32 name 'DisableThreadLibraryCalls';
--%% function GetProcAddress; external kernel32 name 'GetProcAddress';
--%% function GetVersion; external kernel32 name 'GetVersion';
--%% function GlobalAlloc; external kernel32 name 'GlobalAlloc';
--%% function GlobalReAlloc; external kernel32 name 'GlobalReAlloc';
--%% function GlobalSize; external kernel32 name 'GlobalSize';
--%% function GlobalFlags; external kernel32 name 'GlobalFlags';
--%% function GlobalLock; external kernel32 name 'GlobalLock';
--%% function GlobalHandle; external kernel32 name 'GlobalHandle';
--%% function GlobalUnlock; external kernel32 name 'GlobalUnlock';
--%% function GlobalFree; external kernel32 name 'GlobalFree';
--%% function GlobalCompact; external kernel32 name 'GlobalCompact';
--%% procedure GlobalFix; external kernel32 name 'GlobalFix';
--%% procedure GlobalUnfix; external kernel32 name 'GlobalUnfix';
--%% function GlobalWire; external kernel32 name 'GlobalWire';
--%% function GlobalUnWire; external kernel32 name 'GlobalUnWire';
--%% procedure GlobalMemoryStatus; external kernel32 name 'GlobalMemoryStatus';
--%% function GlobalMemoryStatusEx; external kernel32 name 'GlobalMemoryStatusEx';
--%% function LocalAlloc; external kernel32 name 'LocalAlloc';
--%% function LocalReAlloc; external kernel32 name 'LocalReAlloc';
--%% function LocalLock; external kernel32 name 'LocalLock';
--%% function LocalHandle; external kernel32 name 'LocalHandle';
--%% function LocalUnlock; external kernel32 name 'LocalUnlock';
--%% function LocalSize; external kernel32 name 'LocalSize';
--%% function LocalFlags; external kernel32 name 'LocalFlags';
--%% function LocalFree; external kernel32 name 'LocalFree';
--%% function LocalShrink; external kernel32 name 'LocalShrink';
--%% function LocalCompact; external kernel32 name 'LocalCompact';
--%% function FlushInstructionCache; external kernel32 name 'FlushInstructionCache';
--%% function VirtualAlloc; external kernel32 name 'VirtualAlloc';
--%% function VirtualFree; external kernel32 name 'VirtualFree';
--%% function VirtualProtect; external kernel32 name 'VirtualProtect';
--%% function VirtualQuery; external kernel32 name 'VirtualQuery';
--%% function VirtualAllocEx; external kernel32 name 'VirtualAllocEx';
--%% function GetWriteWatch; external kernel32 name 'GetWriteWatch';
--%% function ResetWriteWatch; external kernel32 name 'ResetWriteWatch';
--%% function GetLargePageMinimum; external kernel32 name 'GetLargePageMinimum';
--%% function VirtualFreeEx; external kernel32 name 'VirtualFreeEx';
--%% function VirtualProtectEx; external kernel32 name 'VirtualProtectEx';
--%% function VirtualQueryEx; external kernel32 name 'VirtualQueryEx';
--%% function HeapCreate; external kernel32 name 'HeapCreate';
--%% function HeapDestroy; external kernel32 name 'HeapDestroy';
--%% function HeapAlloc; external kernel32 name 'HeapAlloc';
--%% function HeapReAlloc; external kernel32 name 'HeapReAlloc';
--%% function HeapFree; external kernel32 name 'HeapFree';
--%% function HeapSize; external kernel32 name 'HeapSize';
--%% function HeapValidate; external kernel32 name 'HeapValidate';
--%% function HeapCompact; external kernel32 name 'HeapCompact';
--%% function GetProcessHeap; external kernel32 name 'GetProcessHeap';
--%% function GetProcessHeaps; external kernel32 name 'GetProcessHeaps';
--%% function HeapLock; external kernel32 name 'HeapLock';
--%% function HeapUnlock; external kernel32 name 'HeapUnlock';
--%% function HeapWalk; external kernel32 name 'HeapWalk';
--%% function HeapSetInformation; external kernel32 name 'HeapSetInformation';
--%% function HeapQueryInformation; external kernel32 name 'HeapQueryInformation';
--%% function GetBinaryTypeA; external kernel32 name 'GetBinaryTypeA';
--%% function GetBinaryTypeW; external kernel32 name 'GetBinaryTypeW';
--%% function GetBinaryType; external kernel32 name 'GetBinaryType' + AWSuffix;
--%% function GetShortPathNameA; external kernel32 name 'GetShortPathNameA';
--%% function GetShortPathNameW; external kernel32 name 'GetShortPathNameW';
--%% function GetShortPathName; external kernel32 name 'GetShortPathName' + AWSuffix;
--%% function GetLongPathNameA; external kernel32 name 'GetLongPathNameA';
--%% function GetLongPathNameW; external kernel32 name 'GetLongPathNameW';
--%% function GetLongPathName; external kernel32 name 'GetLongPathName' + AWSuffix;
--%% function GetProcessAffinityMask; external kernel32 name 'GetProcessAffinityMask';
--%% function SetProcessAffinityMask; external kernel32 name 'SetProcessAffinityMask';
--%% function GetProcessHandleCount; external kernel32 name 'GetProcessHandleCount';
--%% function GetProcessTimes; external kernel32 name 'GetProcessTimes';
--%% function GetProcessIoCounters; external kernel32 name 'GetProcessIoCounters';
--%% function GetProcessWorkingSetSize; external kernel32 name 'GetProcessWorkingSetSize';
--%% function GetProcessWorkingSetSizeEx; external kernel32 name 'GetProcessWorkingSetSizeEx';
--%% function SetProcessWorkingSetSize; external kernel32 name 'SetProcessWorkingSetSize';
--%% function SetProcessWorkingSetSizeEx; external kernel32 name 'SetProcessWorkingSetSizeEx';
--%% function OpenProcess; external kernel32 name 'OpenProcess';
--%% function GetCurrentProcess; external kernel32 name 'GetCurrentProcess';
--%% function GetCurrentProcessId; external kernel32 name 'GetCurrentProcessId';
--%% procedure ExitProcess; external kernel32 name 'ExitProcess';
--%% function TerminateProcess; external kernel32 name 'TerminateProcess';
--%% function GetExitCodeProcess; external kernel32 name 'GetExitCodeProcess';
--%% procedure FatalExit; external kernel32 name 'FatalExit';
--%% function GetEnvironmentStringsW; external kernel32 name 'GetEnvironmentStringsW';
--%% function GetEnvironmentStrings; external kernel32 name 'GetEnvironmentStrings' + AWSuffix;
--%% {$IFNDEF UNICODE}
--%% function GetEnvironmentStringsA; external kernel32 name 'GetEnvironmentStringsA';
--%% {$ENDIF !UNICODE}
--%%
--%% {$IFDEF WIN2003_UP}
--%% function SetEnvironmentStringsA; external kernel32 name 'SetEnvironmentStringsA';
--%% function SetEnvironmentStringsW; external kernel32 name 'SetEnvironmentStringsW';
--%% function SetEnvironmentStrings; external kernel32 name 'SetEnvironmentStrings' + AWSuffix;
--%% {$ENDIF WIN2003_UP}
--%%
--%% function FreeEnvironmentStringsA; external kernel32 name 'FreeEnvironmentStringsA';
--%% function FreeEnvironmentStringsW; external kernel32 name 'FreeEnvironmentStringsW';
--%% function FreeEnvironmentStrings; external kernel32 name 'FreeEnvironmentStrings' + AWSuffix;
--%% procedure RaiseException; external kernel32 name 'RaiseException';
--%% function UnhandledExceptionFilter; external kernel32 name 'UnhandledExceptionFilter';
--%% function SetUnhandledExceptionFilter; external kernel32 name 'SetUnhandledExceptionFilter';
--%% function CreateFiber; external kernel32 name 'CreateFiber';
--%% function CreateFiberEx; external kernel32 name 'CreateFiberEx';
--%% procedure DeleteFiber; external kernel32 name 'DeleteFiber';
--%% function ConvertThreadToFiber; external kernel32 name 'ConvertThreadToFiber';
--%% function ConvertThreadToFiberEx; external kernel32 name 'ConvertThreadToFiberEx';
--%% function ConvertFiberToThread; external kernel32 name 'ConvertFiberToThread';
--%% procedure SwitchToFiber; external kernel32 name 'SwitchToFiber';
--%% function SwitchToThread; external kernel32 name 'SwitchToThread';
--%% function CreateThread; external kernel32 name 'CreateThread';
--%% function CreateRemoteThread; external kernel32 name 'CreateRemoteThread';
--%% function GetCurrentThread; external kernel32 name 'GetCurrentThread';
--%% function GetCurrentThreadId; external kernel32 name 'GetCurrentThreadId';
--%% function GetProcessIdOfThread; external kernel32 name 'GetProcessIdOfThread';
--%% function GetThreadId; external kernel32 name 'GetThreadId';
--%% function GetProcessId; external kernel32 name 'GetProcessId';
--%% function GetCurrentProcessorNumber; external kernel32 name 'GetCurrentProcessorNumber';
--%% function SetThreadAffinityMask; external kernel32 name 'SetThreadAffinityMask';
--%% function SetThreadIdealProcessor; external kernel32 name 'SetThreadIdealProcessor';
--%% function SetProcessPriorityBoost; external kernel32 name 'SetProcessPriorityBoost';
--%% function GetProcessPriorityBoost; external kernel32 name 'GetProcessPriorityBoost';
--%% function RequestWakeupLatency; external kernel32 name 'RequestWakeupLatency';
--%% function IsSystemResumeAutomatic; external kernel32 name 'IsSystemResumeAutomatic';
--%% function OpenThread; external kernel32 name 'OpenThread';
--%% function SetThreadPriority; external kernel32 name 'SetThreadPriority';
--%% function SetThreadPriorityBoost; external kernel32 name 'SetThreadPriorityBoost';
--%% function GetThreadPriorityBoost; external kernel32 name 'GetThreadPriorityBoost';
--%% function GetThreadPriority; external kernel32 name 'GetThreadPriority';
--%% function GetThreadTimes; external kernel32 name 'GetThreadTimes';
--%% function GetThreadIOPendingFlag; external kernel32 name 'GetThreadIOPendingFlag';
--%% procedure ExitThread; external kernel32 name 'ExitThread';
--%% function TerminateThread; external kernel32 name 'TerminateThread';
--%% function GetExitCodeThread; external kernel32 name 'GetExitCodeThread';
--%% function GetThreadSelectorEntry; external kernel32 name 'GetThreadSelectorEntry';
--%% function SetThreadExecutionState; external kernel32 name 'SetThreadExecutionState';
--%% function GetLastError; external kernel32 name 'GetLastError';
--%% procedure SetLastError; external kernel32 name 'SetLastError';
--%% procedure RestoreLastError; external kernel32 name 'RestoreLastError';
--%% function GetOverlappedResult; external kernel32 name 'GetOverlappedResult';
--%% function CreateIoCompletionPort; external kernel32 name 'CreateIoCompletionPort';
--%% function GetQueuedCompletionStatus; external kernel32 name 'GetQueuedCompletionStatus';
--%% function PostQueuedCompletionStatus; external kernel32 name 'PostQueuedCompletionStatus';
--%% function SetErrorMode; external kernel32 name 'SetErrorMode';
--%% function ReadProcessMemory; external kernel32 name 'ReadProcessMemory';
--%% function WriteProcessMemory; external kernel32 name 'WriteProcessMemory';
--%% function GetThreadContext; external kernel32 name 'GetThreadContext';
--%% function SetThreadContext; external kernel32 name 'SetThreadContext';
--%% function SuspendThread; external kernel32 name 'SuspendThread';
--%% function ResumeThread; external kernel32 name 'ResumeThread';
--%% function QueueUserAPC; external kernel32 name 'QueueUserAPC';
--%% function IsDebuggerPresent; external kernel32 name 'IsDebuggerPresent';
--%% function CheckRemoteDebuggerPresent; external kernel32 name 'CheckRemoteDebuggerPresent';
--%% procedure DebugBreak; external kernel32 name 'DebugBreak';
--%% function WaitForDebugEvent; external kernel32 name 'WaitForDebugEvent';
--%% function ContinueDebugEvent; external kernel32 name 'ContinueDebugEvent';
--%% function DebugActiveProcess; external kernel32 name 'DebugActiveProcess';
--%% function DebugActiveProcessStop; external kernel32 name 'DebugActiveProcessStop';
--%% function DebugSetProcessKillOnExit; external kernel32 name 'DebugSetProcessKillOnExit';
--%% function DebugBreakProcess; external kernel32 name 'DebugBreakProcess';
--%% procedure InitializeCriticalSection; external kernel32 name 'InitializeCriticalSection';
--%% procedure EnterCriticalSection; external kernel32 name 'EnterCriticalSection';
--%% procedure LeaveCriticalSection; external kernel32 name 'LeaveCriticalSection';
--%% function InitializeCriticalSectionAndSpinCount; external kernel32 name 'InitializeCriticalSectionAndSpinCount';
--%% function SetCriticalSectionSpinCount; external kernel32 name 'SetCriticalSectionSpinCount';
--%% function TryEnterCriticalSection; external kernel32 name 'TryEnterCriticalSection';
--%% procedure DeleteCriticalSection; external kernel32 name 'DeleteCriticalSection';
--%% function SetEvent; external kernel32 name 'SetEvent';
--%% function ResetEvent; external kernel32 name 'ResetEvent';
--%% function PulseEvent; external kernel32 name 'PulseEvent';
--%% function ReleaseSemaphore; external kernel32 name 'ReleaseSemaphore';
--%% function ReleaseMutex; external kernel32 name 'ReleaseMutex';
--%% function WaitForSingleObject; external kernel32 name 'WaitForSingleObject';
--%% function WaitForMultipleObjects; external kernel32 name 'WaitForMultipleObjects';
--%% procedure Sleep; external kernel32 name 'Sleep';
--%% function LoadResource; external kernel32 name 'LoadResource';
--%% function SizeofResource; external kernel32 name 'SizeofResource';
--%% function GlobalDeleteAtom; external kernel32 name 'GlobalDeleteAtom';
--%% function InitAtomTable; external kernel32 name 'InitAtomTable';
--%% function DeleteAtom; external kernel32 name 'DeleteAtom';
--%% function SetHandleCount; external kernel32 name 'SetHandleCount';
--%% function GetLogicalDrives; external kernel32 name 'GetLogicalDrives';
--%% function LockFile; external kernel32 name 'LockFile';
--%% function UnlockFile; external kernel32 name 'UnlockFile';
--%% function LockFileEx; external kernel32 name 'LockFileEx';
--%% function UnlockFileEx; external kernel32 name 'UnlockFileEx';
--%% function GetFileInformationByHandle; external kernel32 name 'GetFileInformationByHandle';
--%% function GetFileType; external kernel32 name 'GetFileType';
--%% function GetFileSize; external kernel32 name 'GetFileSize';
--%% function GetFileSizeEx; external kernel32 name 'GetFileSizeEx';
--%% function GetStdHandle; external kernel32 name 'GetStdHandle';
--%% function SetStdHandle; external kernel32 name 'SetStdHandle';
--%% function WriteFile; external kernel32 name 'WriteFile';
--%% function ReadFile; external kernel32 name 'ReadFile';
--%% function FlushFileBuffers; external kernel32 name 'FlushFileBuffers';
--%% function DeviceIoControl; external kernel32 name 'DeviceIoControl';
--%% function RequestDeviceWakeup; external kernel32 name 'RequestDeviceWakeup';
--%% function CancelDeviceWakeupRequest; external kernel32 name 'CancelDeviceWakeupRequest';
--%% function GetDevicePowerState; external kernel32 name 'GetDevicePowerState';
--%% function SetMessageWaitingIndicator; external kernel32 name 'SetMessageWaitingIndicator';
--%% function SetEndOfFile; external kernel32 name 'SetEndOfFile';
--%% function SetFilePointer; external kernel32 name 'SetFilePointer';
--%% function SetFilePointerEx; external kernel32 name 'SetFilePointerEx';
--%% function FindClose; external kernel32 name 'FindClose';
--%% function GetFileTime; external kernel32 name 'GetFileTime';
--%% function SetFileTime; external kernel32 name 'SetFileTime';
--%% function SetFileValidData; external kernel32 name 'SetFileValidData';
--%% function SetFileShortNameA; external kernel32 name 'SetFileShortNameA';
--%% function SetFileShortNameW; external kernel32 name 'SetFileShortNameW';
--%% function SetFileShortName; external kernel32 name 'SetFileShortName' + AWSuffix;
--%% function CloseHandle; external kernel32 name 'CloseHandle';
--%% function DuplicateHandle; external kernel32 name 'DuplicateHandle';
--%% function GetHandleInformation; external kernel32 name 'GetHandleInformation';
--%% function SetHandleInformation; external kernel32 name 'SetHandleInformation';
--%% function LoadModule; external kernel32 name 'LoadModule';
--%% function WinExec; external kernel32 name 'WinExec';
--%% function ClearCommBreak; external kernel32 name 'ClearCommBreak';
--%% function ClearCommError; external kernel32 name 'ClearCommError';
--%% function SetupComm; external kernel32 name 'SetupComm';
--%% function EscapeCommFunction; external kernel32 name 'EscapeCommFunction';
--%% function GetCommConfig; external kernel32 name 'GetCommConfig';
--%% function GetCommMask; external kernel32 name 'GetCommMask';
--%% function GetCommProperties; external kernel32 name 'GetCommProperties';
--%% function GetCommModemStatus; external kernel32 name 'GetCommModemStatus';
--%% function GetCommState; external kernel32 name 'GetCommState';
--%% function GetCommTimeouts; external kernel32 name 'GetCommTimeouts';
--%% function PurgeComm; external kernel32 name 'PurgeComm';
--%% function SetCommBreak; external kernel32 name 'SetCommBreak';
--%% function SetCommConfig; external kernel32 name 'SetCommConfig';
--%% function SetCommMask; external kernel32 name 'SetCommMask';
--%% function SetCommState; external kernel32 name 'SetCommState';
--%% function SetCommTimeouts; external kernel32 name 'SetCommTimeouts';
--%% function TransmitCommChar; external kernel32 name 'TransmitCommChar';
--%% function WaitCommEvent; external kernel32 name 'WaitCommEvent';
--%% function SetTapePosition; external kernel32 name 'SetTapePosition';
--%% function GetTapePosition; external kernel32 name 'GetTapePosition';
--%% function PrepareTape; external kernel32 name 'PrepareTape';
--%% function EraseTape; external kernel32 name 'EraseTape';
--%% function CreateTapePartition; external kernel32 name 'CreateTapePartition';
--%% function WriteTapemark; external kernel32 name 'WriteTapemark';
--%% function GetTapeStatus; external kernel32 name 'GetTapeStatus';
--%% function GetTapeParameters; external kernel32 name 'GetTapeParameters';
--%% function SetTapeParameters; external kernel32 name 'SetTapeParameters';
--%% function Beep; external kernel32 name 'Beep';
--%% function MulDiv; external kernel32 name 'MulDiv';
--%% procedure GetSystemTime; external kernel32 name 'GetSystemTime';
--%% procedure GetSystemTimeAsFileTime; external kernel32 name 'GetSystemTimeAsFileTime';
--%% function SetSystemTime; external kernel32 name 'SetSystemTime';
--%% procedure GetLocalTime; external kernel32 name 'GetLocalTime';
--%% function SetLocalTime; external kernel32 name 'SetLocalTime';
--%% procedure GetSystemInfo; external kernel32 name 'GetSystemInfo';
--%% function GetSystemRegistryQuota; external kernel32 name 'GetSystemRegistryQuota';
--%% function GetSystemTimes; external kernel32 name 'GetSystemTimes';
--%% procedure GetNativeSystemInfo; external kernel32 name 'GetNativeSystemInfo';
--%% function IsProcessorFeaturePresent; external kernel32 name 'IsProcessorFeaturePresent';
--%% function SystemTimeToTzSpecificLocalTime; external kernel32 name 'SystemTimeToTzSpecificLocalTime';
--%% function TzSpecificLocalTimeToSystemTime; external kernel32 name 'TzSpecificLocalTimeToSystemTime';
--%% function GetTimeZoneInformation; external kernel32 name 'GetTimeZoneInformation';
--%% function SetTimeZoneInformation; external kernel32 name 'SetTimeZoneInformation';
--%% function SystemTimeToFileTime; external kernel32 name 'SystemTimeToFileTime';
--%% function FileTimeToLocalFileTime; external kernel32 name 'FileTimeToLocalFileTime';
--%% function LocalFileTimeToFileTime; external kernel32 name 'LocalFileTimeToFileTime';
--%% function FileTimeToSystemTime; external kernel32 name 'FileTimeToSystemTime';
--%% function CompareFileTime; external kernel32 name 'CompareFileTime';
--%% function FileTimeToDosDateTime; external kernel32 name 'FileTimeToDosDateTime';
--%% function DosDateTimeToFileTime; external kernel32 name 'DosDateTimeToFileTime';
--%% function GetTickCount; external kernel32 name 'GetTickCount';
--%% function SetSystemTimeAdjustment; external kernel32 name 'SetSystemTimeAdjustment';
--%% function GetSystemTimeAdjustment; external kernel32 name 'GetSystemTimeAdjustment';
--%% function FormatMessageA; external kernel32 name 'FormatMessageA';
--%% function FormatMessageW; external kernel32 name 'FormatMessageW';
--%% function FormatMessage; external kernel32 name 'FormatMessage' + AWSuffix;
--%% function CreatePipe; external kernel32 name 'CreatePipe';
--%% function ConnectNamedPipe; external kernel32 name 'ConnectNamedPipe';
--%% function DisconnectNamedPipe; external kernel32 name 'DisconnectNamedPipe';
--%% function SetNamedPipeHandleState; external kernel32 name 'SetNamedPipeHandleState';
--%% function GetNamedPipeInfo; external kernel32 name 'GetNamedPipeInfo';
--%% function PeekNamedPipe; external kernel32 name 'PeekNamedPipe';
--%% function TransactNamedPipe; external kernel32 name 'TransactNamedPipe';
--%% function CreateMailslotA; external kernel32 name 'CreateMailslotA';
--%% function CreateMailslotW; external kernel32 name 'CreateMailslotW';
--%% function CreateMailslot; external kernel32 name 'CreateMailslot' + AWSuffix;
--%% function GetMailslotInfo; external kernel32 name 'GetMailslotInfo';
--%% function SetMailslotInfo; external kernel32 name 'SetMailslotInfo';
--%% function MapViewOfFile; external kernel32 name 'MapViewOfFile';
--%% function FlushViewOfFile; external kernel32 name 'FlushViewOfFile';
--%% function UnmapViewOfFile; external kernel32 name 'UnmapViewOfFile';
--%% function EncryptFileA; external advapi32 name 'EncryptFileA';
--%% function EncryptFileW; external advapi32 name 'EncryptFileW';
--%% function EncryptFile; external advapi32 name 'EncryptFile' + AWSuffix;
--%% function DecryptFileA; external advapi32 name 'DecryptFileA';
--%% function DecryptFileW; external advapi32 name 'DecryptFileW';
--%% function DecryptFile; external advapi32 name 'DecryptFile' + AWSuffix;
--%% function FileEncryptionStatusA; external advapi32 name 'FileEncryptionStatusA';
--%% function FileEncryptionStatusW; external advapi32 name 'FileEncryptionStatusW';
--%% function FileEncryptionStatus; external advapi32 name 'FileEncryptionStatus' + AWSuffix;
--%% function OpenEncryptedFileRawA; external advapi32 name 'OpenEncryptedFileRawA';
--%% function OpenEncryptedFileRawW; external advapi32 name 'OpenEncryptedFileRawW';
--%% function OpenEncryptedFileRaw; external advapi32 name 'OpenEncryptedFileRaw' + AWSuffix;
--%% function ReadEncryptedFileRaw; external advapi32 name 'ReadEncryptedFileRaw';
--%% function WriteEncryptedFileRaw; external advapi32 name 'WriteEncryptedFileRaw';
--%% procedure CloseEncryptedFileRaw; external advapi32 name 'CloseEncryptedFileRaw';
--%% function lstrcmpA; external kernel32 name 'lstrcmpA';
--%% function lstrcmpW; external kernel32 name 'lstrcmpW';
--%% function lstrcmp; external kernel32 name 'lstrcmp' + AWSuffix;
--%% function lstrcmpiA; external kernel32 name 'lstrcmpiA';
--%% function lstrcmpiW; external kernel32 name 'lstrcmpiW';
--%% function lstrcmpi; external kernel32 name 'lstrcmpi' + AWSuffix;
--%% function lstrcpynA; external kernel32 name 'lstrcpynA';
--%% function lstrcpynW; external kernel32 name 'lstrcpynW';
--%% function lstrcpyn; external kernel32 name 'lstrcpyn' + AWSuffix;
--%% function lstrcpyA; external kernel32 name 'lstrcpyA';
--%% function lstrcpyW; external kernel32 name 'lstrcpyW';
--%% function lstrcpy; external kernel32 name 'lstrcpy' + AWSuffix;
--%% function lstrcatA; external kernel32 name 'lstrcatA';
--%% function lstrcatW; external kernel32 name 'lstrcatW';
--%% function lstrcat; external kernel32 name 'lstrcat' + AWSuffix;
--%% function lstrlenA; external kernel32 name 'lstrlenA';
--%% function lstrlenW; external kernel32 name 'lstrlenW';
--%% function lstrlen; external kernel32 name 'lstrlen' + AWSuffix;
--%% function OpenFile; external kernel32 name 'OpenFile';
--%% function _lopen; external kernel32 name '_lopen';
--%% function _lcreat; external kernel32 name '_lcreat';
--%% function _lread; external kernel32 name '_lread';
--%% function _lwrite; external kernel32 name '_lwrite';
--%% function _hread; external kernel32 name '_hread';
--%% function _hwrite; external kernel32 name '_hwrite';
--%% function _lclose; external kernel32 name '_lclose';
--%% function _llseek; external kernel32 name '_llseek';
--%% function IsTextUnicode; external advapi32 name 'IsTextUnicode';
--%% function FlsAlloc; external kernel32 name 'FlsAlloc';
--%% function FlsGetValue; external kernel32 name 'FlsGetValue';
--%% function FlsSetValue; external kernel32 name 'FlsSetValue';
--%% function FlsFree; external kernel32 name 'FlsFree';
--%% function TlsAlloc; external kernel32 name 'TlsAlloc';
--%% function TlsGetValue; external kernel32 name 'TlsGetValue';
--%% function TlsSetValue; external kernel32 name 'TlsSetValue';
--%% function TlsFree; external kernel32 name 'TlsFree';
--%% function SleepEx; external kernel32 name 'SleepEx';
--%% function WaitForSingleObjectEx; external kernel32 name 'WaitForSingleObjectEx';
--%% function WaitForMultipleObjectsEx; external kernel32 name 'WaitForMultipleObjectsEx';
--%% function SignalObjectAndWait; external kernel32 name 'SignalObjectAndWait';
--%% function ReadFileEx; external kernel32 name 'ReadFileEx';
--%% function WriteFileEx; external kernel32 name 'WriteFileEx';
--%% function BackupRead; external kernel32 name 'BackupRead';
--%% function BackupSeek; external kernel32 name 'BackupSeek';
--%% function BackupWrite; external kernel32 name 'BackupWrite';
--%% function ReadFileScatter; external kernel32 name 'ReadFileScatter';
--%% function WriteFileGather; external kernel32 name 'WriteFileGather';
--%% function OpenMutexA; external kernel32 name 'OpenMutexA';
--%% function OpenMutexW; external kernel32 name 'OpenMutexW';
--%% function OpenMutex; external kernel32 name 'OpenMutex' + AWSuffix;
--%% function CreateEventA; external kernel32 name 'CreateEventA';
--%% function CreateEventW; external kernel32 name 'CreateEventW';
--%% function CreateEvent; external kernel32 name 'CreateEvent' + AWSuffix;
--%% function OpenEventA; external kernel32 name 'OpenEventA';
--%% function OpenEventW; external kernel32 name 'OpenEventW';
--%% function OpenEvent; external kernel32 name 'OpenEvent' + AWSuffix;
--%% function CreateSemaphoreA; external kernel32 name 'CreateSemaphoreA';
--%% function CreateSemaphoreW; external kernel32 name 'CreateSemaphoreW';
--%% function CreateSemaphore; external kernel32 name 'CreateSemaphore' + AWSuffix;
--%% function OpenSemaphoreA; external kernel32 name 'OpenSemaphoreA';
--%% function OpenSemaphoreW; external kernel32 name 'OpenSemaphoreW';
--%% function OpenSemaphore; external kernel32 name 'OpenSemaphore' + AWSuffix;
--%% function CreateWaitableTimerA; external kernel32 name 'CreateWaitableTimerA';
--%% function CreateWaitableTimerW; external kernel32 name 'CreateWaitableTimerW';
--%% function CreateWaitableTimer; external kernel32 name 'CreateWaitableTimer' + AWSuffix;
--%% function OpenWaitableTimerA; external kernel32 name 'OpenWaitableTimerA';
--%% function OpenWaitableTimerW; external kernel32 name 'OpenWaitableTimerW';
--%% function OpenWaitableTimer; external kernel32 name 'OpenWaitableTimer' + AWSuffix;
--%% function SetWaitableTimer; external kernel32 name 'SetWaitableTimer';
--%% function CancelWaitableTimer; external kernel32 name 'CancelWaitableTimer';
--%% function CreateFileMappingA; external kernel32 name 'CreateFileMappingA';
--%% function CreateFileMappingW; external kernel32 name 'CreateFileMappingW';
--%% function CreateFileMapping; external kernel32 name 'CreateFileMapping' + AWSuffix;
--%% function OpenFileMappingA; external kernel32 name 'OpenFileMappingA';
--%% function OpenFileMappingW; external kernel32 name 'OpenFileMappingW';
--%% function OpenFileMapping; external kernel32 name 'OpenFileMapping' + AWSuffix;
--%% function GetLogicalDriveStringsA; external kernel32 name 'GetLogicalDriveStringsA';
--%% function GetLogicalDriveStringsW; external kernel32 name 'GetLogicalDriveStringsW';
--%% function GetLogicalDriveStrings; external kernel32 name 'GetLogicalDriveStrings' + AWSuffix;
--%% function CreateMemoryResourceNotification; external kernel32 name 'CreateMemoryResourceNotification';
--%% function QueryMemoryResourceNotification; external kernel32 name 'QueryMemoryResourceNotification';
--%% function LoadLibraryA; external kernel32 name 'LoadLibraryA';
--%% function LoadLibraryW; external kernel32 name 'LoadLibraryW';
--%% function LoadLibrary; external kernel32 name 'LoadLibrary' + AWSuffix;
--%% function LoadLibraryExA; external kernel32 name 'LoadLibraryExA';
--%% function LoadLibraryExW; external kernel32 name 'LoadLibraryExW';
--%% function LoadLibraryEx; external kernel32 name 'LoadLibraryEx' + AWSuffix;
--%% function GetModuleFileNameA; external kernel32 name 'GetModuleFileNameA';
--%% function GetModuleFileNameW; external kernel32 name 'GetModuleFileNameW';
--%% function GetModuleFileName; external kernel32 name 'GetModuleFileName' + AWSuffix;
--%% function GetModuleHandleA; external kernel32 name 'GetModuleHandleA';
--%% function GetModuleHandleW; external kernel32 name 'GetModuleHandleW';
--%% function GetModuleHandle; external kernel32 name 'GetModuleHandle' + AWSuffix;
--%% function CreateProcessA; external kernel32 name 'CreateProcessA';
--%% function CreateProcessW; external kernel32 name 'CreateProcessW';
--%% function CreateProcess; external kernel32 name 'CreateProcess' + AWSuffix;
--%% function GetModuleHandleExA; external kernel32 name 'GetModuleHandleExA';
--%% function GetModuleHandleExW; external kernel32 name 'GetModuleHandleExW';
--%% function GetModuleHandleEx; external kernel32 name 'GetModuleHandleEx' + AWSuffix;
--%% function NeedCurrentDirectoryForExePathA; external kernel32 name 'NeedCurrentDirectoryForExePathA';
--%% function NeedCurrentDirectoryForExePathW; external kernel32 name 'NeedCurrentDirectoryForExePathW';
--%% function NeedCurrentDirectoryForExePath; external kernel32 name 'NeedCurrentDirectoryForExePath' + AWSuffix;
--%% function SetProcessShutdownParameters; external kernel32 name 'SetProcessShutdownParameters';
--%% function GetProcessShutdownParameters; external kernel32 name 'GetProcessShutdownParameters';
--%% function GetProcessVersion; external kernel32 name 'GetProcessVersion';
--%% procedure FatalAppExitA; external kernel32 name 'FatalAppExitA';
--%% procedure FatalAppExitW; external kernel32 name 'FatalAppExitW';
--%% procedure FatalAppExit; external kernel32 name 'FatalAppExit' + AWSuffix;
--%% procedure GetStartupInfoA; external kernel32 name 'GetStartupInfoA';
--%% procedure GetStartupInfoW; external kernel32 name 'GetStartupInfoW';
--%% procedure GetStartupInfo; external kernel32 name 'GetStartupInfo' + AWSuffix;
--%% function GetCommandLineA; external kernel32 name 'GetCommandLineA';
--%% function GetCommandLineW; external kernel32 name 'GetCommandLineW';
--%% function GetCommandLine; external kernel32 name 'GetCommandLine' + AWSuffix;
--%% function GetEnvironmentVariableA; external kernel32 name 'GetEnvironmentVariableA';
--%% function GetEnvironmentVariableW; external kernel32 name 'GetEnvironmentVariableW';
--%% function GetEnvironmentVariable; external kernel32 name 'GetEnvironmentVariable' + AWSuffix;
--%% function SetEnvironmentVariableA; external kernel32 name 'SetEnvironmentVariableA';
--%% function SetEnvironmentVariableW; external kernel32 name 'SetEnvironmentVariableW';
--%% function SetEnvironmentVariable; external kernel32 name 'SetEnvironmentVariable' + AWSuffix;
--%% function ExpandEnvironmentStringsA; external kernel32 name 'ExpandEnvironmentStringsA';
--%% function ExpandEnvironmentStringsW; external kernel32 name 'ExpandEnvironmentStringsW';
--%% function ExpandEnvironmentStrings; external kernel32 name 'ExpandEnvironmentStrings' + AWSuffix;
--%% function GetFirmwareEnvironmentVariableA; external kernel32 name 'GetFirmwareEnvironmentVariableA';
--%% function GetFirmwareEnvironmentVariableW; external kernel32 name 'GetFirmwareEnvironmentVariableW';
--%% function GetFirmwareEnvironmentVariable; external kernel32 name 'GetFirmwareEnvironmentVariable' + AWSuffix;
--%% function SetFirmwareEnvironmentVariableA; external kernel32 name 'SetFirmwareEnvironmentVariableA';
--%% function SetFirmwareEnvironmentVariableW; external kernel32 name 'SetFirmwareEnvironmentVariableW';
--%% function SetFirmwareEnvironmentVariable; external kernel32 name 'SetFirmwareEnvironmentVariable' + AWSuffix;
--%% procedure OutputDebugStringA; external kernel32 name 'OutputDebugStringA';
--%% procedure OutputDebugStringW; external kernel32 name 'OutputDebugStringW';
--%% procedure OutputDebugString; external kernel32 name 'OutputDebugString' + AWSuffix;
--%% function FindResourceA; external kernel32 name 'FindResourceA';
--%% function FindResourceW; external kernel32 name 'FindResourceW';
--%% function FindResource; external kernel32 name 'FindResource' + AWSuffix;
--%% function FindResourceExA; external kernel32 name 'FindResourceExA';
--%% function FindResourceExW; external kernel32 name 'FindResourceExW';
--%% function FindResourceEx; external kernel32 name 'FindResourceEx' + AWSuffix;
--%% function EnumResourceTypesA; external kernel32 name 'EnumResourceTypesA';
--%% function EnumResourceTypesW; external kernel32 name 'EnumResourceTypesW';
--%% function EnumResourceTypes; external kernel32 name 'EnumResourceTypes' + AWSuffix;
--%% function EnumResourceNamesA; external kernel32 name 'EnumResourceNamesA';
--%% function EnumResourceNamesW; external kernel32 name 'EnumResourceNamesW';
--%% function EnumResourceNames; external kernel32 name 'EnumResourceNames' + AWSuffix;
--%% function EnumResourceLanguagesA; external kernel32 name 'EnumResourceLanguagesA';
--%% function EnumResourceLanguagesW; external kernel32 name 'EnumResourceLanguagesW';
--%% function EnumResourceLanguages; external kernel32 name 'EnumResourceLanguages' + AWSuffix;
--%% function BeginUpdateResourceA; external kernel32 name 'BeginUpdateResourceA';
--%% function BeginUpdateResourceW; external kernel32 name 'BeginUpdateResourceW';
--%% function BeginUpdateResource; external kernel32 name 'BeginUpdateResource' + AWSuffix;
--%% function UpdateResourceA; external kernel32 name 'UpdateResourceA';
--%% function UpdateResourceW; external kernel32 name 'UpdateResourceW';
--%% function UpdateResource; external kernel32 name 'UpdateResource' + AWSuffix;
--%% function EndUpdateResourceA; external kernel32 name 'EndUpdateResourceA';
--%% function EndUpdateResourceW; external kernel32 name 'EndUpdateResourceW';
--%% function EndUpdateResource; external kernel32 name 'EndUpdateResource' + AWSuffix;
--%% function GlobalAddAtomA; external kernel32 name 'GlobalAddAtomA';
--%% function GlobalAddAtomW; external kernel32 name 'GlobalAddAtomW';
--%% function GlobalAddAtom; external kernel32 name 'GlobalAddAtom' + AWSuffix;
--%% function GlobalFindAtomA; external kernel32 name 'GlobalFindAtomA';
--%% function GlobalFindAtomW; external kernel32 name 'GlobalFindAtomW';
--%% function GlobalFindAtom; external kernel32 name 'GlobalFindAtom' + AWSuffix;
--%% function GlobalGetAtomNameA; external kernel32 name 'GlobalGetAtomNameA';
--%% function GlobalGetAtomNameW; external kernel32 name 'GlobalGetAtomNameW';
--%% function GlobalGetAtomName; external kernel32 name 'GlobalGetAtomName' + AWSuffix;
--%% function AddAtomA; external kernel32 name 'AddAtomA';
--%% function AddAtomW; external kernel32 name 'AddAtomW';
--%% function AddAtom; external kernel32 name 'AddAtom' + AWSuffix;
--%% function FindAtomA; external kernel32 name 'FindAtomA';
--%% function FindAtomW; external kernel32 name 'FindAtomW';
--%% function FindAtom; external kernel32 name 'FindAtom' + AWSuffix;
--%% function GetAtomNameA; external kernel32 name 'GetAtomNameA';
--%% function GetAtomNameW; external kernel32 name 'GetAtomNameW';
--%% function GetAtomName; external kernel32 name 'GetAtomName' + AWSuffix;
--%% function GetProfileIntA; external kernel32 name 'GetProfileIntA';
--%% function GetProfileIntW; external kernel32 name 'GetProfileIntW';
--%% function GetProfileInt; external kernel32 name 'GetProfileInt' + AWSuffix;
--%% function GetProfileStringA; external kernel32 name 'GetProfileStringA';
--%% function GetProfileStringW; external kernel32 name 'GetProfileStringW';
--%% function GetProfileString; external kernel32 name 'GetProfileString' + AWSuffix;
--%% function WriteProfileStringA; external kernel32 name 'WriteProfileStringA';
--%% function WriteProfileStringW; external kernel32 name 'WriteProfileStringW';
--%% function WriteProfileString; external kernel32 name 'WriteProfileString' + AWSuffix;
--%% function GetProfileSectionA; external kernel32 name 'GetProfileSectionA';
--%% function GetProfileSectionW; external kernel32 name 'GetProfileSectionW';
--%% function GetProfileSection; external kernel32 name 'GetProfileSection' + AWSuffix;
--%% function WriteProfileSectionA; external kernel32 name 'WriteProfileSectionA';
--%% function WriteProfileSectionW; external kernel32 name 'WriteProfileSectionW';
--%% function WriteProfileSection; external kernel32 name 'WriteProfileSection' + AWSuffix;
--%% function GetPrivateProfileIntA; external kernel32 name 'GetPrivateProfileIntA';
--%% function GetPrivateProfileIntW; external kernel32 name 'GetPrivateProfileIntW';
--%% function GetPrivateProfileInt; external kernel32 name 'GetPrivateProfileInt' + AWSuffix;
--%% function GetPrivateProfileStringA; external kernel32 name 'GetPrivateProfileStringA';
--%% function GetPrivateProfileStringW; external kernel32 name 'GetPrivateProfileStringW';
--%% function GetPrivateProfileString; external kernel32 name 'GetPrivateProfileString' + AWSuffix;
--%% function WritePrivateProfileStringA; external kernel32 name 'WritePrivateProfileStringA';
--%% function WritePrivateProfileStringW; external kernel32 name 'WritePrivateProfileStringW';
--%% function WritePrivateProfileString; external kernel32 name 'WritePrivateProfileString' + AWSuffix;
--%% function GetPrivateProfileSectionA; external kernel32 name 'GetPrivateProfileSectionA';
--%% function GetPrivateProfileSectionW; external kernel32 name 'GetPrivateProfileSectionW';
--%% function GetPrivateProfileSection; external kernel32 name 'GetPrivateProfileSection' + AWSuffix;
--%% function WritePrivateProfileSectionA; external kernel32 name 'WritePrivateProfileSectionA';
--%% function WritePrivateProfileSectionW; external kernel32 name 'WritePrivateProfileSectionW';
--%% function WritePrivateProfileSection; external kernel32 name 'WritePrivateProfileSection' + AWSuffix;
--%% function GetPrivateProfileSectionNamesA; external kernel32 name 'GetPrivateProfileSectionNamesA';
--%% function GetPrivateProfileSectionNamesW; external kernel32 name 'GetPrivateProfileSectionNamesW';
--%% function GetPrivateProfileSectionNames; external kernel32 name 'GetPrivateProfileSectionNames' + AWSuffix;
--%% function GetPrivateProfileStructA; external kernel32 name 'GetPrivateProfileStructA';
--%% function GetPrivateProfileStructW; external kernel32 name 'GetPrivateProfileStructW';
--%% function GetPrivateProfileStruct; external kernel32 name 'GetPrivateProfileStruct' + AWSuffix;
--%% function WritePrivateProfileStructA; external kernel32 name 'WritePrivateProfileStructA';
--%% function WritePrivateProfileStructW; external kernel32 name 'WritePrivateProfileStructW';
--%% function WritePrivateProfileStruct; external kernel32 name 'WritePrivateProfileStruct' + AWSuffix;
--%% function GetDriveTypeA; external kernel32 name 'GetDriveTypeA';
--%% function GetDriveTypeW; external kernel32 name 'GetDriveTypeW';
--%% function GetDriveType; external kernel32 name 'GetDriveType' + AWSuffix;
--%% function GetSystemDirectoryA; external kernel32 name 'GetSystemDirectoryA';
--%% function GetSystemDirectoryW; external kernel32 name 'GetSystemDirectoryW';
--%% function GetSystemDirectory; external kernel32 name 'GetSystemDirectory' + AWSuffix;
--%% function GetTempPathA; external kernel32 name 'GetTempPathA';
--%% function GetTempPathW; external kernel32 name 'GetTempPathW';
--%% function GetTempPath; external kernel32 name 'GetTempPath' + AWSuffix;
--%% function GetTempFileNameA; external kernel32 name 'GetTempFileNameA';
--%% function GetTempFileNameW; external kernel32 name 'GetTempFileNameW';
--%% function GetTempFileName; external kernel32 name 'GetTempFileName' + AWSuffix;
--%% function GetWindowsDirectoryA; external kernel32 name 'GetWindowsDirectoryA';
--%% function GetWindowsDirectoryW; external kernel32 name 'GetWindowsDirectoryW';
--%% function GetWindowsDirectory; external kernel32 name 'GetWindowsDirectory' + AWSuffix;
--%% function GetSystemWindowsDirectoryA; external kernel32 name 'GetSystemWindowsDirectoryA';
--%% function GetSystemWindowsDirectoryW; external kernel32 name 'GetSystemWindowsDirectoryW';
--%% function GetSystemWindowsDirectory; external kernel32 name 'GetSystemWindowsDirectory' + AWSuffix;
--%% function GetSystemWow64DirectoryA; external kernel32 name 'GetSystemWow64DirectoryA';
--%% function GetSystemWow64DirectoryW; external kernel32 name 'GetSystemWow64DirectoryW';
--%% function GetSystemWow64Directory; external kernel32 name 'GetSystemWow64Directory' + AWSuffix;
--%% function Wow64EnableWow64FsRedirection; external kernel32 name 'Wow64EnableWow64FsRedirection';
--%% function SetCurrentDirectoryA; external kernel32 name 'SetCurrentDirectoryA';
--%% function SetCurrentDirectoryW; external kernel32 name 'SetCurrentDirectoryW';
--%% function SetCurrentDirectory; external kernel32 name 'SetCurrentDirectory' + AWSuffix;
--%% function GetCurrentDirectoryA; external kernel32 name 'GetCurrentDirectoryA';
--%% function GetCurrentDirectoryW; external kernel32 name 'GetCurrentDirectoryW';
--%% function GetCurrentDirectory; external kernel32 name 'GetCurrentDirectory' + AWSuffix;
--%% function SetDllDirectoryA; external kernel32 name 'SetDllDirectoryA';
--%% function SetDllDirectoryW; external kernel32 name 'SetDllDirectoryW';
--%% function SetDllDirectory; external kernel32 name 'SetDllDirectory' + AWSuffix;
--%% function GetDllDirectoryA; external kernel32 name 'GetDllDirectoryA';
--%% function GetDllDirectoryW; external kernel32 name 'GetDllDirectoryW';
--%% function GetDllDirectory; external kernel32 name 'GetDllDirectory' + AWSuffix;
--%% function GetDiskFreeSpaceA; external kernel32 name 'GetDiskFreeSpaceA';
--%% function GetDiskFreeSpaceW; external kernel32 name 'GetDiskFreeSpaceW';
--%% function GetDiskFreeSpace; external kernel32 name 'GetDiskFreeSpace' + AWSuffix;
--%% function GetDiskFreeSpaceExA; external kernel32 name 'GetDiskFreeSpaceExA';
--%% function GetDiskFreeSpaceExW; external kernel32 name 'GetDiskFreeSpaceExW';
--%% function GetDiskFreeSpaceEx; external kernel32 name 'GetDiskFreeSpaceEx' + AWSuffix;
--%% function CreateDirectoryA; external kernel32 name 'CreateDirectoryA';
--%% function CreateDirectoryW; external kernel32 name 'CreateDirectoryW';
--%% function CreateDirectory; external kernel32 name 'CreateDirectory' + AWSuffix;
--%% function CreateDirectoryExA; external kernel32 name 'CreateDirectoryExA';
--%% function CreateDirectoryExW; external kernel32 name 'CreateDirectoryExW';
--%% function CreateDirectoryEx; external kernel32 name 'CreateDirectoryEx' + AWSuffix;
--%% function RemoveDirectoryA; external kernel32 name 'RemoveDirectoryA';
--%% function RemoveDirectoryW; external kernel32 name 'RemoveDirectoryW';
--%% function RemoveDirectory; external kernel32 name 'RemoveDirectory' + AWSuffix;
--%% function GetFullPathNameA; external kernel32 name 'GetFullPathNameA';
--%% function GetFullPathNameW; external kernel32 name 'GetFullPathNameW';
--%% function GetFullPathName; external kernel32 name 'GetFullPathName' + AWSuffix;
--%% function DefineDosDeviceA; external kernel32 name 'DefineDosDeviceA';
--%% function DefineDosDeviceW; external kernel32 name 'DefineDosDeviceW';
--%% function DefineDosDevice; external kernel32 name 'DefineDosDevice' + AWSuffix;
--%% function QueryDosDeviceA; external kernel32 name 'QueryDosDeviceA';
--%% function QueryDosDeviceW; external kernel32 name 'QueryDosDeviceW';
--%% function QueryDosDevice; external kernel32 name 'QueryDosDevice' + AWSuffix;
--%% function CreateFileA; external kernel32 name 'CreateFileA';
--%% function CreateFileW; external kernel32 name 'CreateFileW';
--%% function CreateFile; external kernel32 name 'CreateFile' + AWSuffix;
--%% function ReOpenFile; external kernel32 name 'ReOpenFile';
--%% function SetFileAttributesA; external kernel32 name 'SetFileAttributesA';
--%% function SetFileAttributesW; external kernel32 name 'SetFileAttributesW';
--%% function SetFileAttributes; external kernel32 name 'SetFileAttributes' + AWSuffix;
--%% function GetFileAttributesA; external kernel32 name 'GetFileAttributesA';
--%% function GetFileAttributesW; external kernel32 name 'GetFileAttributesW';
--%% function GetFileAttributes; external kernel32 name 'GetFileAttributes' + AWSuffix;
--%% function GetFileAttributesExA; external kernel32 name 'GetFileAttributesExA';
--%% function GetFileAttributesExW; external kernel32 name 'GetFileAttributesExW';
--%% function GetFileAttributesEx; external kernel32 name 'GetFileAttributesEx' + AWSuffix;
--%% function GetCompressedFileSizeA; external kernel32 name 'GetCompressedFileSizeA';
--%% function GetCompressedFileSizeW; external kernel32 name 'GetCompressedFileSizeW';
--%% function GetCompressedFileSize; external kernel32 name 'GetCompressedFileSize' + AWSuffix;
--%% function DeleteFileA; external kernel32 name 'DeleteFileA';
--%% function DeleteFileW; external kernel32 name 'DeleteFileW';
--%% function DeleteFile; external kernel32 name 'DeleteFile' + AWSuffix;
--%% function FindFirstFileExA; external kernel32 name 'FindFirstFileExA';
--%% function FindFirstFileExW; external kernel32 name 'FindFirstFileExW';
--%% function FindFirstFileEx; external kernel32 name 'FindFirstFileEx' + AWSuffix;
--%% function FindFirstFileA; external kernel32 name 'FindFirstFileA';
--%% function FindFirstFileW; external kernel32 name 'FindFirstFileW';
--%% function FindFirstFile; external kernel32 name 'FindFirstFile' + AWSuffix;
--%% function FindNextFileA; external kernel32 name 'FindNextFileA';
--%% function FindNextFileW; external kernel32 name 'FindNextFileW';
--%% function FindNextFile; external kernel32 name 'FindNextFile' + AWSuffix;
--%% function SearchPathA; external kernel32 name 'SearchPathA';
--%% function SearchPathW; external kernel32 name 'SearchPathW';
--%% function SearchPath; external kernel32 name 'SearchPath' + AWSuffix;
--%% function CopyFileA; external kernel32 name 'CopyFileA';
--%% function CopyFileW; external kernel32 name 'CopyFileW';
--%% function CopyFile; external kernel32 name 'CopyFile' + AWSuffix;
--%% function CopyFileExA; external kernel32 name 'CopyFileExA';
--%% function CopyFileExW; external kernel32 name 'CopyFileExW';
--%% function CopyFileEx; external kernel32 name 'CopyFileEx' + AWSuffix;
--%% function MoveFileA; external kernel32 name 'MoveFileA';
--%% function MoveFileW; external kernel32 name 'MoveFileW';
--%% function MoveFile; external kernel32 name 'MoveFile' + AWSuffix;
--%% function MoveFileExA; external kernel32 name 'MoveFileExA';
--%% function MoveFileExW; external kernel32 name 'MoveFileExW';
--%% function MoveFileEx; external kernel32 name 'MoveFileEx' + AWSuffix;
--%% function MoveFileWithProgressA; external kernel32 name 'MoveFileWithProgressA';
--%% function MoveFileWithProgressW; external kernel32 name 'MoveFileWithProgressW';
--%% function MoveFileWithProgress; external kernel32 name 'MoveFileWithProgress' + AWSuffix;
--%% function ReplaceFileA; external kernel32 name 'ReplaceFileA';
--%% function ReplaceFileW; external kernel32 name 'ReplaceFileW';
--%% function ReplaceFile; external kernel32 name 'ReplaceFile' + AWSuffix;
--%% function CreateHardLinkA; external kernel32 name 'CreateHardLinkA';
--%% function CreateHardLinkW; external kernel32 name 'CreateHardLinkW';
--%% function CreateHardLink; external kernel32 name 'CreateHardLink' + AWSuffix;
--%% function FindFirstStreamW; external kernel32 name 'FindFirstStreamW';
--%% function FindNextStreamW; external kernel32 name 'FindNextStreamW';
--%% function CreateNamedPipeA; external kernel32 name 'CreateNamedPipeA';
--%% function CreateNamedPipeW; external kernel32 name 'CreateNamedPipeW';
--%% function CreateNamedPipe; external kernel32 name 'CreateNamedPipe' + AWSuffix;
--%% function GetNamedPipeHandleStateA; external kernel32 name 'GetNamedPipeHandleStateA';
--%% function GetNamedPipeHandleStateW; external kernel32 name 'GetNamedPipeHandleStateW';
--%% function GetNamedPipeHandleState; external kernel32 name 'GetNamedPipeHandleState' + AWSuffix;
--%% function CallNamedPipeA; external kernel32 name 'CallNamedPipeA';
--%% function CallNamedPipeW; external kernel32 name 'CallNamedPipeW';
--%% function CallNamedPipe; external kernel32 name 'CallNamedPipe' + AWSuffix;
--%% function WaitNamedPipeA; external kernel32 name 'WaitNamedPipeA';
--%% function WaitNamedPipeW; external kernel32 name 'WaitNamedPipeW';
--%% function WaitNamedPipe; external kernel32 name 'WaitNamedPipe' + AWSuffix;
--%% function SetVolumeLabelA; external kernel32 name 'SetVolumeLabelA';
--%% function SetVolumeLabelW; external kernel32 name 'SetVolumeLabelW';
--%% function SetVolumeLabel; external kernel32 name 'SetVolumeLabel' + AWSuffix;
--%% procedure SetFileApisToOEM; external kernel32 name 'SetFileApisToOEM';
--%% procedure SetFileApisToANSI; external kernel32 name 'SetFileApisToANSI';
--%% function AreFileApisANSI; external kernel32 name 'AreFileApisANSI';
--%% function GetVolumeInformationA; external kernel32 name 'GetVolumeInformationA';
--%% function GetVolumeInformationW; external kernel32 name 'GetVolumeInformationW';
--%% function GetVolumeInformation; external kernel32 name 'GetVolumeInformation' + AWSuffix;
--%% function CancelIo; external kernel32 name 'CancelIo';
--%% function ClearEventLogA; external advapi32 name 'ClearEventLogA';
--%% function ClearEventLogW; external advapi32 name 'ClearEventLogW';
--%% function ClearEventLog; external advapi32 name 'ClearEventLog' + AWSuffix;
--%% function BackupEventLogA; external advapi32 name 'BackupEventLogA';
--%% function BackupEventLogW; external advapi32 name 'BackupEventLogW';
--%% function BackupEventLog; external advapi32 name 'BackupEventLog' + AWSuffix;
--%% function CloseEventLog; external advapi32 name 'CloseEventLog';
--%% function DeregisterEventSource; external advapi32 name 'DeregisterEventSource';
--%% function NotifyChangeEventLog; external advapi32 name 'NotifyChangeEventLog';
--%% function GetNumberOfEventLogRecords; external advapi32 name 'GetNumberOfEventLogRecords';
--%% function GetOldestEventLogRecord; external advapi32 name 'GetOldestEventLogRecord';
--%% function OpenEventLogA; external advapi32 name 'OpenEventLogA';
--%% function OpenEventLogW; external advapi32 name 'OpenEventLogW';
--%% function OpenEventLog; external advapi32 name 'OpenEventLog' + AWSuffix;
--%% function RegisterEventSourceA; external advapi32 name 'RegisterEventSourceA';
--%% function RegisterEventSourceW; external advapi32 name 'RegisterEventSourceW';
--%% function RegisterEventSource; external advapi32 name 'RegisterEventSource' + AWSuffix;
--%% function OpenBackupEventLogA; external advapi32 name 'OpenBackupEventLogA';
--%% function OpenBackupEventLogW; external advapi32 name 'OpenBackupEventLogW';
--%% function OpenBackupEventLog; external advapi32 name 'OpenBackupEventLog' + AWSuffix;
--%% function ReadEventLogA; external advapi32 name 'ReadEventLogA';
--%% function ReadEventLogW; external advapi32 name 'ReadEventLogW';
--%% function ReadEventLog; external advapi32 name 'ReadEventLog' + AWSuffix;
--%% function ReportEventA; external advapi32 name 'ReportEventA';
--%% function ReportEventW; external advapi32 name 'ReportEventW';
--%% function ReportEvent; external advapi32 name 'ReportEvent' + AWSuffix;
--%% function GetEventLogInformation; external advapi32 name 'GetEventLogInformation';
--%% function DuplicateToken; external advapi32 name 'DuplicateToken';
--%% function GetKernelObjectSecurity; external advapi32 name 'GetKernelObjectSecurity';
--%% function ImpersonateNamedPipeClient; external advapi32 name 'ImpersonateNamedPipeClient';
--%% function ImpersonateSelf; external advapi32 name 'ImpersonateSelf';
--%% function RevertToSelf; external advapi32 name 'RevertToSelf';
--%% function SetThreadToken; external advapi32 name 'SetThreadToken';
--%% function AccessCheck; external advapi32 name 'AccessCheck';
--%% function AccessCheckByType; external advapi32 name 'AccessCheckByType';
--%% function AccessCheckByTypeResultList; external advapi32 name 'AccessCheckByTypeResultList';
--%% function OpenProcessToken; external advapi32 name 'OpenProcessToken';
--%% function OpenThreadToken; external advapi32 name 'OpenThreadToken';
--%% function GetTokenInformation; external advapi32 name 'GetTokenInformation';
--%% function SetTokenInformation; external advapi32 name 'SetTokenInformation';
--%% function AdjustTokenPrivileges; external advapi32 name 'AdjustTokenPrivileges';
--%% function AdjustTokenGroups; external advapi32 name 'AdjustTokenGroups';
--%% function PrivilegeCheck; external advapi32 name 'PrivilegeCheck';
--%% function AccessCheckAndAuditAlarmA; external advapi32 name 'AccessCheckAndAuditAlarmA';
--%% function AccessCheckAndAuditAlarmW; external advapi32 name 'AccessCheckAndAuditAlarmW';
--%% function AccessCheckAndAuditAlarm; external advapi32 name 'AccessCheckAndAuditAlarm' + AWSuffix;
--%% function AccessCheckByTypeAndAuditAlarmA; external advapi32 name 'AccessCheckByTypeAndAuditAlarmA';
--%% function AccessCheckByTypeAndAuditAlarmW; external advapi32 name 'AccessCheckByTypeAndAuditAlarmW';
--%% function AccessCheckByTypeAndAuditAlarm; external advapi32 name 'AccessCheckByTypeAndAuditAlarm' + AWSuffix;
--%% function AccessCheckByTypeResultListAndAuditAlarmA; external advapi32 name 'AccessCheckByTypeResultListAndAuditAlarmA';
--%% function AccessCheckByTypeResultListAndAuditAlarmW; external advapi32 name 'AccessCheckByTypeResultListAndAuditAlarmW';
--%% function AccessCheckByTypeResultListAndAuditAlarm; external advapi32 name 'AccessCheckByTypeResultListAndAuditAlarm' + AWSuffix;
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandleA; external advapi32 name 'AccessCheckByTypeResultListAndAuditAlarmByHandleA';
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandleW; external advapi32 name 'AccessCheckByTypeResultListAndAuditAlarmByHandleW';
--%% function AccessCheckByTypeResultListAndAuditAlarmByHandle; external advapi32 name 'AccessCheckByTypeResultListAndAuditAlarmByHandle' + AWSuffix;
--%% function ObjectOpenAuditAlarmA; external advapi32 name 'ObjectOpenAuditAlarmA';
--%% function ObjectOpenAuditAlarmW; external advapi32 name 'ObjectOpenAuditAlarmW';
--%% function ObjectOpenAuditAlarm; external advapi32 name 'ObjectOpenAuditAlarm' + AWSuffix;
--%% function ObjectPrivilegeAuditAlarmA; external advapi32 name 'ObjectPrivilegeAuditAlarmA';
--%% function ObjectPrivilegeAuditAlarmW; external advapi32 name 'ObjectPrivilegeAuditAlarmW';
--%% function ObjectPrivilegeAuditAlarm; external advapi32 name 'ObjectPrivilegeAuditAlarm' + AWSuffix;
--%% function ObjectCloseAuditAlarmA; external advapi32 name 'ObjectCloseAuditAlarmA';
--%% function ObjectCloseAuditAlarmW; external advapi32 name 'ObjectCloseAuditAlarmW';
--%% function ObjectCloseAuditAlarm; external advapi32 name 'ObjectCloseAuditAlarm' + AWSuffix;
--%% function ObjectDeleteAuditAlarmA; external advapi32 name 'ObjectDeleteAuditAlarmA';
--%% function ObjectDeleteAuditAlarmW; external advapi32 name 'ObjectDeleteAuditAlarmW';
--%% function ObjectDeleteAuditAlarm; external advapi32 name 'ObjectDeleteAuditAlarm' + AWSuffix;
--%% function PrivilegedServiceAuditAlarmA; external advapi32 name 'PrivilegedServiceAuditAlarmA';
--%% function PrivilegedServiceAuditAlarmW; external advapi32 name 'PrivilegedServiceAuditAlarmW';
--%% function PrivilegedServiceAuditAlarm; external advapi32 name 'PrivilegedServiceAuditAlarm' + AWSuffix;
--%% function IsWellKnownSid; external advapi32 name 'IsWellKnownSid';
--%% function CreateWellKnownSid; external advapi32 name 'CreateWellKnownSid';
--%% function EqualDomainSid; external advapi32 name 'EqualDomainSid';
--%% function GetWindowsAccountDomainSid; external advapi32 name 'GetWindowsAccountDomainSid';
--%% function IsValidSid; external advapi32 name 'IsValidSid';
--%% function EqualSid; external advapi32 name 'EqualSid';
--%% function EqualPrefixSid; external advapi32 name 'EqualPrefixSid';
--%% function GetSidLengthRequired; external advapi32 name 'GetSidLengthRequired';
--%% function AllocateAndInitializeSid; external advapi32 name 'AllocateAndInitializeSid';
--%% function FreeSid; external advapi32 name 'FreeSid';
--%% function InitializeSid; external advapi32 name 'InitializeSid';
--%% function GetSidIdentifierAuthority; external advapi32 name 'GetSidIdentifierAuthority';
--%% function GetSidSubAuthority; external advapi32 name 'GetSidSubAuthority';
--%% function GetSidSubAuthorityCount; external advapi32 name 'GetSidSubAuthorityCount';
--%% function GetLengthSid; external advapi32 name 'GetLengthSid';
--%% function CopySid; external advapi32 name 'CopySid';
--%% function AreAllAccessesGranted; external advapi32 name 'AreAllAccessesGranted';
--%% function AreAnyAccessesGranted; external advapi32 name 'AreAnyAccessesGranted';
--%% procedure MapGenericMask; external advapi32 name 'MapGenericMask';
--%% function IsValidAcl; external advapi32 name 'IsValidAcl';
--%% function InitializeAcl; external advapi32 name 'InitializeAcl';
--%% function GetAclInformation; external advapi32 name 'GetAclInformation';
--%% function SetAclInformation; external advapi32 name 'SetAclInformation';
--%% function AddAce; external advapi32 name 'AddAce';
--%% function DeleteAce; external advapi32 name 'DeleteAce';
--%% function GetAce; external advapi32 name 'GetAce';
--%% function AddAccessAllowedAce; external advapi32 name 'AddAccessAllowedAce';
--%% function AddAccessAllowedAceEx; external advapi32 name 'AddAccessAllowedAceEx';
--%% function AddAccessDeniedAce; external advapi32 name 'AddAccessDeniedAce';
--%% function AddAccessDeniedAceEx; external advapi32 name 'AddAccessDeniedAceEx';
--%% function AddAuditAccessAce; external advapi32 name 'AddAuditAccessAce';
--%% function AddAuditAccessAceEx; external advapi32 name 'AddAuditAccessAceEx';
--%% function AddAccessAllowedObjectAce; external advapi32 name 'AddAccessAllowedObjectAce';
--%% function AddAccessDeniedObjectAce; external advapi32 name 'AddAccessDeniedObjectAce';
--%% function AddAuditAccessObjectAce; external advapi32 name 'AddAuditAccessObjectAce';
--%% function FindFirstFreeAce; external advapi32 name 'FindFirstFreeAce';
--%% function InitializeSecurityDescriptor; external advapi32 name 'InitializeSecurityDescriptor';
--%% function IsValidSecurityDescriptor; external advapi32 name 'IsValidSecurityDescriptor';
--%% function GetSecurityDescriptorLength; external advapi32 name 'GetSecurityDescriptorLength';
--%% function GetSecurityDescriptorControl; external advapi32 name 'GetSecurityDescriptorControl';
--%% function SetSecurityDescriptorControl; external advapi32 name 'SetSecurityDescriptorControl';
--%% function SetSecurityDescriptorDacl; external advapi32 name 'SetSecurityDescriptorDacl';
--%% function GetSecurityDescriptorDacl; external advapi32 name 'GetSecurityDescriptorDacl';
--%% function SetSecurityDescriptorSacl; external advapi32 name 'SetSecurityDescriptorSacl';
--%% function GetSecurityDescriptorSacl; external advapi32 name 'GetSecurityDescriptorSacl';
--%% function SetSecurityDescriptorOwner; external advapi32 name 'SetSecurityDescriptorOwner';
--%% function GetSecurityDescriptorOwner; external advapi32 name 'GetSecurityDescriptorOwner';
--%% function SetSecurityDescriptorGroup; external advapi32 name 'SetSecurityDescriptorGroup';
--%% function GetSecurityDescriptorGroup; external advapi32 name 'GetSecurityDescriptorGroup';
--%% function SetSecurityDescriptorRMControl; external advapi32 name 'SetSecurityDescriptorRMControl';
--%% function GetSecurityDescriptorRMControl; external advapi32 name 'GetSecurityDescriptorRMControl';
--%% function CreatePrivateObjectSecurity; external advapi32 name 'CreatePrivateObjectSecurity';
--%% function ConvertToAutoInheritPrivateObjectSecurity; external advapi32 name 'ConvertToAutoInheritPrivateObjectSecurity';
--%% function CreatePrivateObjectSecurityEx; external advapi32 name 'CreatePrivateObjectSecurityEx';
--%% function SetPrivateObjectSecurity; external advapi32 name 'SetPrivateObjectSecurity';
--%% function SetPrivateObjectSecurityEx; external advapi32 name 'SetPrivateObjectSecurityEx';
--%% function GetPrivateObjectSecurity; external advapi32 name 'GetPrivateObjectSecurity';
--%% function DestroyPrivateObjectSecurity; external advapi32 name 'DestroyPrivateObjectSecurity';
--%% function MakeSelfRelativeSD; external advapi32 name 'MakeSelfRelativeSD';
--%% function MakeAbsoluteSD; external advapi32 name 'MakeAbsoluteSD';
--%% function MakeAbsoluteSD2; external advapi32 name 'MakeAbsoluteSD2';
--%% function SetFileSecurityA; external advapi32 name 'SetFileSecurityA';
--%% function SetFileSecurityW; external advapi32 name 'SetFileSecurityW';
--%% function SetFileSecurity; external advapi32 name 'SetFileSecurity' + AWSuffix;
--%% function GetFileSecurityA; external advapi32 name 'GetFileSecurityA';
--%% function GetFileSecurityW; external advapi32 name 'GetFileSecurityW';
--%% function GetFileSecurity; external advapi32 name 'GetFileSecurity' + AWSuffix;
--%% function SetKernelObjectSecurity; external advapi32 name 'SetKernelObjectSecurity';
--%% function FindFirstChangeNotificationA; external kernel32 name 'FindFirstChangeNotificationA';
--%% function FindFirstChangeNotificationW; external kernel32 name 'FindFirstChangeNotificationW';
--%% function FindFirstChangeNotification; external kernel32 name 'FindFirstChangeNotification' + AWSuffix;
--%% function FindNextChangeNotification; external kernel32 name 'FindNextChangeNotification';
--%% function FindCloseChangeNotification; external kernel32 name 'FindCloseChangeNotification';
--%% function ReadDirectoryChangesW; external kernel32 name 'ReadDirectoryChangesW';
--%% function VirtualLock; external kernel32 name 'VirtualLock';
--%% function VirtualUnlock; external kernel32 name 'VirtualUnlock';
--%% function MapViewOfFileEx; external kernel32 name 'MapViewOfFileEx';
--%% function SetPriorityClass; external kernel32 name 'SetPriorityClass';
--%% function GetPriorityClass; external kernel32 name 'GetPriorityClass';
--%% function IsBadReadPtr; external kernel32 name 'IsBadReadPtr';
--%% function IsBadWritePtr; external kernel32 name 'IsBadWritePtr';
--%% function IsBadHugeReadPtr; external kernel32 name 'IsBadHugeReadPtr';
--%% function IsBadHugeWritePtr; external kernel32 name 'IsBadHugeWritePtr';
--%% function IsBadCodePtr; external kernel32 name 'IsBadCodePtr';
--%% function IsBadStringPtrA; external kernel32 name 'IsBadStringPtrA';
--%% function IsBadStringPtrW; external kernel32 name 'IsBadStringPtrW';
--%% function IsBadStringPtr; external kernel32 name 'IsBadStringPtr' + AWSuffix;
--%% function LookupAccountSidA; external advapi32 name 'LookupAccountSidA';
--%% function LookupAccountSidW; external advapi32 name 'LookupAccountSidW';
--%% function LookupAccountSid; external advapi32 name 'LookupAccountSid' + AWSuffix;
--%% function LookupAccountNameA; external advapi32 name 'LookupAccountNameA';
--%% function LookupAccountNameW; external advapi32 name 'LookupAccountNameW';
--%% function LookupAccountName; external advapi32 name 'LookupAccountName' + AWSuffix;
--%% function LookupPrivilegeValueA; external advapi32 name 'LookupPrivilegeValueA';
--%% function LookupPrivilegeValueW; external advapi32 name 'LookupPrivilegeValueW';
--%% function LookupPrivilegeValue; external advapi32 name 'LookupPrivilegeValue' + AWSuffix;
--%% function LookupPrivilegeNameA; external advapi32 name 'LookupPrivilegeNameA';
--%% function LookupPrivilegeNameW; external advapi32 name 'LookupPrivilegeNameW';
--%% function LookupPrivilegeName; external advapi32 name 'LookupPrivilegeName' + AWSuffix;
--%% function LookupPrivilegeDisplayNameA; external advapi32 name 'LookupPrivilegeDisplayNameA';
--%% function LookupPrivilegeDisplayNameW; external advapi32 name 'LookupPrivilegeDisplayNameW';
--%% function LookupPrivilegeDisplayName; external advapi32 name 'LookupPrivilegeDisplayName' + AWSuffix;
--%% function AllocateLocallyUniqueId; external advapi32 name 'AllocateLocallyUniqueId';
--%% function BuildCommDCBA; external kernel32 name 'BuildCommDCBA';
--%% function BuildCommDCBW; external kernel32 name 'BuildCommDCBW';
--%% function BuildCommDCB; external kernel32 name 'BuildCommDCB' + AWSuffix;
--%% function BuildCommDCBAndTimeoutsA; external kernel32 name 'BuildCommDCBAndTimeoutsA';
--%% function BuildCommDCBAndTimeoutsW; external kernel32 name 'BuildCommDCBAndTimeoutsW';
--%% function BuildCommDCBAndTimeouts; external kernel32 name 'BuildCommDCBAndTimeouts' + AWSuffix;
--%% function CommConfigDialogA; external kernel32 name 'CommConfigDialogA';
--%% function CommConfigDialogW; external kernel32 name 'CommConfigDialogW';
--%% function CommConfigDialog; external kernel32 name 'CommConfigDialog' + AWSuffix;
--%% function GetDefaultCommConfigA; external kernel32 name 'GetDefaultCommConfigA';
--%% function GetDefaultCommConfigW; external kernel32 name 'GetDefaultCommConfigW';
--%% function GetDefaultCommConfig; external kernel32 name 'GetDefaultCommConfig' + AWSuffix;
--%% function SetDefaultCommConfigA; external kernel32 name 'SetDefaultCommConfigA';
--%% function SetDefaultCommConfigW; external kernel32 name 'SetDefaultCommConfigW';
--%% function SetDefaultCommConfig; external kernel32 name 'SetDefaultCommConfig' + AWSuffix;
--%% function GetComputerNameA; external kernel32 name 'GetComputerNameA';
--%% function GetComputerNameW; external kernel32 name 'GetComputerNameW';
--%% function GetComputerName; external kernel32 name 'GetComputerName' + AWSuffix;
--%% function SetComputerNameA; external kernel32 name 'SetComputerNameA';
--%% function SetComputerNameW; external kernel32 name 'SetComputerNameW';
--%% function SetComputerName; external kernel32 name 'SetComputerName' + AWSuffix;
--%% function GetComputerNameExA; external kernel32 name 'GetComputerNameExA';
--%% function GetComputerNameExW; external kernel32 name 'GetComputerNameExW';
--%% function GetComputerNameEx; external kernel32 name 'GetComputerNameEx' + AWSuffix;
--%% function SetComputerNameExA; external kernel32 name 'SetComputerNameExA';
--%% function SetComputerNameExW; external kernel32 name 'SetComputerNameExW';
--%% function SetComputerNameEx; external kernel32 name 'SetComputerNameEx' + AWSuffix;
--%% function DnsHostnameToComputerNameA; external kernel32 name 'DnsHostnameToComputerNameA';
--%% function DnsHostnameToComputerNameW; external kernel32 name 'DnsHostnameToComputerNameW';
--%% function DnsHostnameToComputerName; external kernel32 name 'DnsHostnameToComputerName' + AWSuffix;
--%% function GetUserNameA; external advapi32 name 'GetUserNameA';
--%% function GetUserNameW; external advapi32 name 'GetUserNameW';
--%% function GetUserName; external advapi32 name 'GetUserName' + AWSuffix;
--%% function LogonUserA; external advapi32 name 'LogonUserA';
--%% function LogonUserW; external advapi32 name 'LogonUserW';
--%% function LogonUser; external advapi32 name 'LogonUser' + AWSuffix;
--%% function LogonUserExA; external advapi32 name 'LogonUserExA';
--%% function LogonUserExW; external advapi32 name 'LogonUserExW';
--%% function LogonUserEx; external advapi32 name 'LogonUserEx' + AWSuffix;
--%% function ImpersonateLoggedOnUser; external advapi32 name 'ImpersonateLoggedOnUser';
--%% function CreateProcessAsUserA; external advapi32 name 'CreateProcessAsUserA';
--%% function CreateProcessAsUserW; external advapi32 name 'CreateProcessAsUserW';
--%% function CreateProcessAsUser; external advapi32 name 'CreateProcessAsUser' + AWSuffix;
--%% function CreateProcessWithLogonW; external advapi32 name 'CreateProcessWithLogonW';
--%% function CreateProcessWithTokenW; external advapi32 name 'CreateProcessWithTokenW';
--%% function ImpersonateAnonymousToken; external advapi32 name 'ImpersonateAnonymousToken';
--%% function DuplicateTokenEx; external advapi32 name 'DuplicateTokenEx';
--%% function CreateRestrictedToken; external advapi32 name 'CreateRestrictedToken';
--%% function IsTokenRestricted; external advapi32 name 'IsTokenRestricted';
--%% function CheckTokenMembership; external advapi32 name 'CheckTokenMembership';
--%% function IsTokenUntrusted; external advapi32 name 'IsTokenUntrusted';
--%% function RegisterWaitForSingleObject; external kernel32 name 'RegisterWaitForSingleObject';
--%% function RegisterWaitForSingleObjectEx; external kernel32 name 'RegisterWaitForSingleObjectEx';
--%% function UnregisterWait; external kernel32 name 'UnregisterWait';
--%% function UnregisterWaitEx; external kernel32 name 'UnregisterWaitEx';
--%% function QueueUserWorkItem; external kernel32 name 'QueueUserWorkItem';
--%% function BindIoCompletionCallback; external kernel32 name 'BindIoCompletionCallback';
--%% function CreateTimerQueue; external kernel32 name 'CreateTimerQueue';
--%% function CreateTimerQueueTimer; external kernel32 name 'CreateTimerQueueTimer';
--%% function ChangeTimerQueueTimer; external kernel32 name 'ChangeTimerQueueTimer';
--%% function DeleteTimerQueueTimer; external kernel32 name 'DeleteTimerQueueTimer';
--%% function DeleteTimerQueueEx; external kernel32 name 'DeleteTimerQueueEx';
--%% function SetTimerQueueTimer; external kernel32 name 'SetTimerQueueTimer';
--%% function CancelTimerQueueTimer; external kernel32 name 'CancelTimerQueueTimer';
--%% function DeleteTimerQueue; external kernel32 name 'DeleteTimerQueue';
--%% function GetCurrentHwProfileA; external advapi32 name 'GetCurrentHwProfileA';
--%% function GetCurrentHwProfileW; external advapi32 name 'GetCurrentHwProfileW';
--%% function GetCurrentHwProfile; external advapi32 name 'GetCurrentHwProfile' + AWSuffix;
--%% function QueryPerformanceCounter; external kernel32 name 'QueryPerformanceCounter';
--%% function QueryPerformanceFrequency; external kernel32 name 'QueryPerformanceFrequency';
--%% function GetVersionExA; external kernel32 name 'GetVersionExA';
--%% function GetVersionExW; external kernel32 name 'GetVersionExW';
--%% function GetVersionEx; external kernel32 name 'GetVersionEx' + AWSuffix;
--%% function VerifyVersionInfoA; external kernel32 name 'VerifyVersionInfoA';
--%% function VerifyVersionInfoW; external kernel32 name 'VerifyVersionInfoW';
--%% function VerifyVersionInfo; external kernel32 name 'VerifyVersionInfo' + AWSuffix;
--%% function GetSystemPowerStatus; external kernel32 name 'GetSystemPowerStatus';
--%% function SetSystemPowerState; external kernel32 name 'SetSystemPowerState';
--%% function AllocateUserPhysicalPages; external kernel32 name 'AllocateUserPhysicalPages';
--%% function FreeUserPhysicalPages; external kernel32 name 'FreeUserPhysicalPages';
--%% function MapUserPhysicalPages; external kernel32 name 'MapUserPhysicalPages';
--%% function MapUserPhysicalPagesScatter; external kernel32 name 'MapUserPhysicalPagesScatter';
--%% function CreateJobObjectA; external kernel32 name 'CreateJobObjectA';
--%% function CreateJobObjectW; external kernel32 name 'CreateJobObjectW';
--%% function CreateJobObject; external kernel32 name 'CreateJobObject' + AWSuffix;
--%% function OpenJobObjectA; external kernel32 name 'OpenJobObjectA';
--%% function OpenJobObjectW; external kernel32 name 'OpenJobObjectW';
--%% function OpenJobObject; external kernel32 name 'OpenJobObject' + AWSuffix;
--%% function AssignProcessToJobObject; external kernel32 name 'AssignProcessToJobObject';
--%% function TerminateJobObject; external kernel32 name 'TerminateJobObject';
--%% function QueryInformationJobObject; external kernel32 name 'QueryInformationJobObject';
--%% function SetInformationJobObject; external kernel32 name 'SetInformationJobObject';
--%% function IsProcessInJob; external kernel32 name 'IsProcessInJob';
--%% function CreateJobSet; external kernel32 name 'CreateJobSet';
--%% function AddVectoredExceptionHandler; external kernel32 name 'AddVectoredExceptionHandler';
--%% function RemoveVectoredExceptionHandler; external kernel32 name 'RemoveVectoredExceptionHandler';
--%% function FindFirstVolumeA; external kernel32 name 'FindFirstVolumeA';
--%% function FindFirstVolumeW; external kernel32 name 'FindFirstVolumeW';
--%% function FindFirstVolume; external kernel32 name 'FindFirstVolume' + AWSuffix;
--%% function FindNextVolumeA; external kernel32 name 'FindNextVolumeA';
--%% function FindNextVolumeW; external kernel32 name 'FindNextVolumeW';
--%% function FindNextVolume; external kernel32 name 'FindNextVolume' + AWSuffix;
--%% function FindVolumeClose; external kernel32 name 'FindVolumeClose';
--%% function FindFirstVolumeMountPointA; external kernel32 name 'FindFirstVolumeMountPointA';
--%% function FindFirstVolumeMountPointW; external kernel32 name 'FindFirstVolumeMountPointW';
--%% function FindFirstVolumeMountPoint; external kernel32 name 'FindFirstVolumeMountPoint' + AWSuffix;
--%% function FindNextVolumeMountPointA; external kernel32 name 'FindNextVolumeMountPointA';
--%% function FindNextVolumeMountPointW; external kernel32 name 'FindNextVolumeMountPointW';
--%% function FindNextVolumeMountPoint; external kernel32 name 'FindNextVolumeMountPoint' + AWSuffix;
--%% function FindVolumeMountPointClose; external kernel32 name 'FindVolumeMountPointClose';
--%% function SetVolumeMountPointA; external kernel32 name 'SetVolumeMountPointA';
--%% function SetVolumeMountPointW; external kernel32 name 'SetVolumeMountPointW';
--%% function SetVolumeMountPoint; external kernel32 name 'SetVolumeMountPoint' + AWSuffix;
--%% function DeleteVolumeMountPointA; external kernel32 name 'DeleteVolumeMountPointA';
--%% function DeleteVolumeMountPointW; external kernel32 name 'DeleteVolumeMountPointW';
--%% function DeleteVolumeMountPoint; external kernel32 name 'DeleteVolumeMountPoint' + AWSuffix;
--%% function GetVolumeNameForVolumeMountPointA; external kernel32 name 'GetVolumeNameForVolumeMountPointA';
--%% function GetVolumeNameForVolumeMountPointW; external kernel32 name 'GetVolumeNameForVolumeMountPointW';
--%% function GetVolumeNameForVolumeMountPoint; external kernel32 name 'GetVolumeNameForVolumeMountPoint' + AWSuffix;
--%% function GetVolumePathNameA; external kernel32 name 'GetVolumePathNameA';
--%% function GetVolumePathNameW; external kernel32 name 'GetVolumePathNameW';
--%% function GetVolumePathName; external kernel32 name 'GetVolumePathName' + AWSuffix;
--%% function GetVolumePathNamesForVolumeNameA; external kernel32 name 'GetVolumePathNamesForVolumeNameA';
--%% function GetVolumePathNamesForVolumeNameW; external kernel32 name 'GetVolumePathNamesForVolumeNameW';
--%% function GetVolumePathNamesForVolumeName; external kernel32 name 'GetVolumePathNamesForVolumeName' + AWSuffix;
--%% function CreateActCtxA; external kernel32 name 'CreateActCtxA';
--%% function CreateActCtxW; external kernel32 name 'CreateActCtxW';
--%% function CreateActCtx; external kernel32 name 'CreateActCtx' + AWSuffix;
--%% procedure AddRefActCtx; external kernel32 name 'AddRefActCtx';
--%% procedure ReleaseActCtx; external kernel32 name 'ReleaseActCtx';
--%% function ZombifyActCtx; external kernel32 name 'ZombifyActCtx';
--%% function ActivateActCtx; external kernel32 name 'ActivateActCtx';
--%% function DeactivateActCtx; external kernel32 name 'DeactivateActCtx';
--%% function GetCurrentActCtx; external kernel32 name 'GetCurrentActCtx';
--%% function FindActCtxSectionStringA; external kernel32 name 'FindActCtxSectionStringA';
--%% function FindActCtxSectionStringW; external kernel32 name 'FindActCtxSectionStringW';
--%% function FindActCtxSectionString; external kernel32 name 'FindActCtxSectionString' + AWSuffix;
--%% function FindActCtxSectionGuid; external kernel32 name 'FindActCtxSectionGuid';
--%% function QueryActCtxW; external kernel32 name 'QueryActCtxW';
--%% function ProcessIdToSessionId; external kernel32 name 'ProcessIdToSessionId';
--%% function WTSGetActiveConsoleSessionId; external kernel32 name 'WTSGetActiveConsoleSessionId';
--%% function IsWow64Process; external kernel32 name 'IsWow64Process';
--%% function GetLogicalProcessorInformation; external kernel32 name 'GetLogicalProcessorInformation';
--%% function GetNumaHighestNodeNumber; external kernel32 name 'GetNumaHighestNodeNumber';
--%% function GetNumaProcessorNode; external kernel32 name 'GetNumaProcessorNode';
--%% function GetNumaNodeProcessorMask; external kernel32 name 'GetNumaNodeProcessorMask';
--%% function GetNumaAvailableMemoryNode; external kernel32 name 'GetNumaAvailableMemoryNode';
--%%
--%% {$ENDIF DYNAMIC_LINK}
--%%
--%% {$ENDIF JWA_INTERFACESECTION}
--%%
--%% {$IFNDEF JWA_OMIT_SECTIONS}
--%% end.
--%% {$ENDIF JWA_OMIT_SECTIONS}
