!
! ********************************************************************
! *                                                                  *
! *  Copyright 2001 Compaq Computer Corporation                      *
! *                                                                  *
! *  COMPAQ Registered in U.S. Patent and Trademark Office.          *
! *                                                                  *
! *  Confidential computer software. Valid license from Compaq or    *
! *  authorized sublicensor required for possession, use or copying. *
! *  Consistent with FAR 12.211 and 12.212, Commercial Computer      *
! *  Software, Computer Software Documentation, and Technical Data   *
! *  for Commercial Items are licensed to the U.S. Government under  *
! *  vendor's standard commercial license.                           *
! *                                                                  *
! ********************************************************************
!
!DEC$ IF .NOT. DEFINED (KERNEL32_ )
!DEC$ DEFINE xKERNEL32_  
!
!
!
!         *****KERNEL32.LIB Interfaces*****
! 
!     This module defines routine interfaces to the Windows APIs
!     for both the 32-bit (_M_IX86) and 64-bit (_M_IA64) versions of the
!     NT4 and WIN2000 operating systems.  
!
!     The base for this version is: 
!
!           Microsoft Platform Software Development Kit (SDK)
!                Win64 Pre-alpha February 2000
!
!     As with the C header files distributed with the SDK, there
!     is only one common set of files for both 64-bit and 32-bit
!     operating systems.
!   
!     Within the Fortran versions of the header files, the
!     following symbols are used to control the compilation.
! 
!     _M_IA64 conditionally compiles items for 64 bit systems.
!     _M_IX86 conditionally compiles items for 32 bit systesm.
!
!     Known problems: 
!
!07-12-00
!
module kernel32
use dfwinty
!DEC$OBJCOMMENT LIB:"KERNEL32.LIB"
!
INTERFACE 
FUNCTION VerSetConditionMask( &
        ConditionMask, &
        TypeMask, &
        Condition)
USE DFWINTY
  TYPE(T_LARGE_INTEGERX) :: VerSetConditionMask ! ULONGLONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VerSetConditionMask' :: VerSetConditionMask
  TYPE(T_LARGE_INTEGERX) ConditionMask ! ULONGLONG ConditionMask
  integer(DWORD) TypeMask ! DWORD TypeMask
  integer(BYTE) Condition ! BYTE Condition
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION InterlockedIncrement( &
        lpAddend)
USE DFWINTY
  integer(LONG) :: InterlockedIncrement ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedIncrement' :: InterlockedIncrement
  integer(LPLONG) lpAddend ! LPLONG lpAddend
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InterlockedDecrement( &
        lpAddend)
USE DFWINTY
  integer(LONG) :: InterlockedDecrement ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedDecrement' :: InterlockedDecrement
  integer(LPLONG) lpAddend ! LPLONG lpAddend
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InterlockedExchange( &
        Target, &
        Value)
USE DFWINTY
  integer(LONG) :: InterlockedExchange ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedExchange' :: InterlockedExchange
  integer(LPLONG) Target ! LPLONG Target
  integer(LONG) Value ! LONG Value
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InterlockedExchangeAdd( &
        Addend, &
        Value)
USE DFWINTY
  integer(LONG) :: InterlockedExchangeAdd ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedExchangeAdd' :: InterlockedExchangeAdd
  integer(LPLONG) Addend ! LPLONG Addend
  integer(LONG) Value ! LONG Value
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InterlockedCompareExchange( &
        Destination, &
        Exchange, &
        Comperand)
USE DFWINTY
  integer(LONG) :: InterlockedCompareExchange ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedCompareExchange' :: InterlockedCompareExchange
  integer(LPLONG) Destination ! LPLONG Destination
  integer(LONG) Exchange ! LONG Exchange
  integer(LONG) Comperand ! LONG Comperand
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
   SUBROUTINE InitializeSListHead( &
        ListHead)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InitializeSListHead' :: InitializeSListHead
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: ListHead
  TYPE (T_SLIST_HEADER) ListHead ! PSLIST_HEADER ListHead
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION InterlockedPopEntrySList( &
        ListHead)
USE DFWINTY
 integer(LPVOID):: InterlockedPopEntrySList ! PSINGLE_LIST_ENTRY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedPopEntrySList' :: InterlockedPopEntrySList
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: ListHead
  TYPE (T_SLIST_HEADER) ListHead ! PSLIST_HEADER ListHead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InterlockedPushEntrySList( &
        ListHead, &
        ListEntry)
USE DFWINTY
 integer(LPVOID):: InterlockedPushEntrySList ! PSINGLE_LIST_ENTRY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedPushEntrySList' :: InterlockedPushEntrySList
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: ListHead
  TYPE (T_SLIST_HEADER) ListHead ! PSLIST_HEADER ListHead
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: ListEntry
  TYPE (T_SINGLE_LIST_ENTRY) ListEntry ! PSINGLE_LIST_ENTRY ListEntry
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InterlockedFlushSList( &
        ListHead)
USE DFWINTY
 integer(LPVOID):: InterlockedFlushSList ! PSINGLE_LIST_ENTRY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InterlockedFlushSList' :: InterlockedFlushSList
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: ListHead
  TYPE (T_SLIST_HEADER) ListHead ! PSLIST_HEADER ListHead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FreeResource( &
        hResData)
USE DFWINTY
  integer(BOOL) :: FreeResource ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FreeResource' :: FreeResource
  integer(HANDLE) hResData ! HGLOBAL hResData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LockResource( &
        hResData)
USE DFWINTY
  integer(LPVOID) :: LockResource ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LockResource' :: LockResource
  integer(HANDLE) hResData ! HGLOBAL hResData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FreeLibrary( &
        hLibModule)
USE DFWINTY
  integer(BOOL) :: FreeLibrary ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FreeLibrary' :: FreeLibrary
  integer(HANDLE) hLibModule ! HMODULE hLibModule
 END FUNCTION
END INTERFACE
INTERFACE 
SUBROUTINE FreeLibraryAndExitThread( &
        hLibModule, &
        dwExitCode)
USE DFWINTY
  !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FreeLibraryAndExitThread' :: FreeLibraryAndExitThread
  integer(HANDLE) hLibModule ! HMODULE hLibModule
  integer(DWORD) dwExitCode ! DWORD dwExitCode
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION DisableThreadLibraryCalls( &
        hLibModule)
USE DFWINTY
  integer(BOOL) :: DisableThreadLibraryCalls ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DisableThreadLibraryCalls' :: DisableThreadLibraryCalls
  integer(HANDLE) hLibModule ! HMODULE hLibModule
 END FUNCTION
END INTERFACE
INTERFACE GetProcAddress
FUNCTION GetProcAddress_G1( &
        hModule, &
        lpProcName)
USE DFWINTY
    integer(LPVOID) :: GetProcAddress_G1 ! FARPROC
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcAddress' :: GetProcAddress_G1
  integer(HANDLE) hModule ! HMODULE hModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpProcName
  character*(*) lpProcName ! LPCSTR lpProcName
 END FUNCTION
FUNCTION GetProcAddress_G2( &
        hModule, &
        lpProcName)
USE DFWINTY
    integer(LPVOID) :: GetProcAddress_G2 ! FARPROC
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcAddress' :: GetProcAddress_G2
  integer(HANDLE) hModule ! HMODULE hModule
  integer(LPVOID) lpProcName ! LPCSTR lpProcName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetVersion( &
             )
USE DFWINTY
  integer(DWORD) :: GetVersion ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetVersion' :: GetVersion
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalAlloc( &
        uFlags, &
        dwBytes)
USE DFWINTY
  integer(HANDLE) :: GlobalAlloc ! HGLOBAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalAlloc' :: GlobalAlloc
  integer(UINT) uFlags ! UINT uFlags
  integer(SIZE_T) dwBytes ! SIZE_T dwBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalReAlloc( &
        hMem, &
        dwBytes, &
        uFlags)
USE DFWINTY
  integer(HANDLE) :: GlobalReAlloc ! HGLOBAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalReAlloc' :: GlobalReAlloc
  integer(HANDLE) hMem ! HGLOBAL hMem
  integer(SIZE_T) dwBytes ! SIZE_T dwBytes
  integer(UINT) uFlags ! UINT uFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalSize( &
        hMem)
USE DFWINTY
  integer(SIZE_T) :: GlobalSize ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalSize' :: GlobalSize
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalFlags( &
        hMem)
USE DFWINTY
  integer(UINT) :: GlobalFlags ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalFlags' :: GlobalFlags
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalLock( &
        hMem)
USE DFWINTY
  integer(LPVOID) :: GlobalLock ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalLock' :: GlobalLock
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalHandle( &
        pMem)
USE DFWINTY
  integer(HANDLE) :: GlobalHandle ! HGLOBAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalHandle' :: GlobalHandle
  integer(LPCVOID) pMem ! LPCVOID pMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalUnlock( &
        hMem)
USE DFWINTY
  integer(BOOL) :: GlobalUnlock ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalUnlock' :: GlobalUnlock
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalFree( &
        hMem)
USE DFWINTY
  integer(HANDLE) :: GlobalFree ! HGLOBAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalFree' :: GlobalFree
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalCompact( &
        dwMinFree)
USE DFWINTY
  integer(SIZE_T) :: GlobalCompact ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalCompact' :: GlobalCompact
  integer(DWORD) dwMinFree ! DWORD dwMinFree
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE GlobalFix( &
        hMem)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalFix' :: GlobalFix
  integer(HANDLE) hMem ! HGLOBAL hMem
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE GlobalUnfix( &
        hMem)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalUnfix' :: GlobalUnfix
  integer(HANDLE) hMem ! HGLOBAL hMem
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION GlobalWire( &
        hMem)
USE DFWINTY
  integer(LPVOID) :: GlobalWire ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalWire' :: GlobalWire
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalUnWire( &
        hMem)
USE DFWINTY
  integer(BOOL) :: GlobalUnWire ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalUnWire' :: GlobalUnWire
  integer(HANDLE) hMem ! HGLOBAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE GlobalMemoryStatus( &
        lpBuffer)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalMemoryStatus' :: GlobalMemoryStatus
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  TYPE (T_MEMORYSTATUS) lpBuffer ! LPMEMORYSTATUS lpBuffer
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION GlobalMemoryStatusEx( &
        lpBuffer)
USE DFWINTY
  integer(BOOL) :: GlobalMemoryStatusEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalMemoryStatusEx' :: GlobalMemoryStatusEx
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpBuffer
  TYPE (T_MEMORYSTATUSEX) lpBuffer ! LPMEMORYSTATUSEX lpBuffer
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalAlloc( &
        uFlags, &
        uBytes)
USE DFWINTY
  integer(HANDLE) :: LocalAlloc ! HLOCAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalAlloc' :: LocalAlloc
  integer(UINT) uFlags ! UINT uFlags
  integer(SIZE_T) uBytes ! SIZE_T uBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalReAlloc( &
        hMem, &
        uBytes, &
        uFlags)
USE DFWINTY
  integer(HANDLE) :: LocalReAlloc ! HLOCAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalReAlloc' :: LocalReAlloc
  integer(HANDLE) hMem ! HLOCAL hMem
  integer(SIZE_T) uBytes ! SIZE_T uBytes
  integer(UINT) uFlags ! UINT uFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalLock( &
        hMem)
USE DFWINTY
  integer(LPVOID) :: LocalLock ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalLock' :: LocalLock
  integer(HANDLE) hMem ! HLOCAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalHandle( &
        pMem)
USE DFWINTY
  integer(HANDLE) :: LocalHandle ! HLOCAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalHandle' :: LocalHandle
  integer(LPCVOID) pMem ! LPCVOID pMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalUnlock( &
        hMem)
USE DFWINTY
  integer(BOOL) :: LocalUnlock ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalUnlock' :: LocalUnlock
  integer(HANDLE) hMem ! HLOCAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalSize( &
        hMem)
USE DFWINTY
  integer(SIZE_T) :: LocalSize ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalSize' :: LocalSize
  integer(HANDLE) hMem ! HLOCAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalFlags( &
        hMem)
USE DFWINTY
  integer(UINT) :: LocalFlags ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalFlags' :: LocalFlags
  integer(HANDLE) hMem ! HLOCAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalFree( &
        hMem)
USE DFWINTY
  integer(HANDLE) :: LocalFree ! HLOCAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalFree' :: LocalFree
  integer(HANDLE) hMem ! HLOCAL hMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalShrink( &
        hMem, &
        cbNewSize)
USE DFWINTY
  integer(SIZE_T) :: LocalShrink ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalShrink' :: LocalShrink
  integer(HANDLE) hMem ! HLOCAL hMem
  integer(UINT) cbNewSize ! UINT cbNewSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalCompact( &
        uMinFree)
USE DFWINTY
  integer(SIZE_T) :: LocalCompact ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalCompact' :: LocalCompact
  integer(UINT) uMinFree ! UINT uMinFree
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualAlloc( &
        lpAddress, &
        dwSize, &
        flAllocationType, &
        flProtect)
USE DFWINTY
  integer(LPVOID) :: VirtualAlloc ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualAlloc' :: VirtualAlloc
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
  integer(DWORD) flAllocationType ! DWORD flAllocationType
  integer(DWORD) flProtect ! DWORD flProtect
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualFree( &
        lpAddress, &
        dwSize, &
        dwFreeType)
USE DFWINTY
  integer(BOOL) :: VirtualFree ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualFree' :: VirtualFree
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
  integer(DWORD) dwFreeType ! DWORD dwFreeType
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualProtect( &
        lpAddress, &
        dwSize, &
        flNewProtect, &
        lpflOldProtect)
USE DFWINTY
  integer(BOOL) :: VirtualProtect ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualProtect' :: VirtualProtect
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
  integer(DWORD) flNewProtect ! DWORD flNewProtect
  integer(LPDWORD) lpflOldProtect ! PDWORD lpflOldProtect
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualQuery( &
        lpAddress, &
        lpBuffer, &
        dwLength)
USE DFWINTY
  integer(DWORD) :: VirtualQuery ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualQuery' :: VirtualQuery
  integer(LPCVOID) lpAddress ! LPCVOID lpAddress
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  TYPE (T_MEMORY_BASIC_INFORMATION) lpBuffer ! PMEMORY_BASIC_INFORMATION lpBuffer
  integer(DWORD) dwLength ! DWORD dwLength
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualAllocEx( &
        hProcess, &
        lpAddress, &
        dwSize, &
        flAllocationType, &
        flProtect)
USE DFWINTY
  integer(LPVOID) :: VirtualAllocEx ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualAllocEx' :: VirtualAllocEx
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
  integer(DWORD) flAllocationType ! DWORD flAllocationType
  integer(DWORD) flProtect ! DWORD flProtect
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetWriteWatch( &
        dwFlags, &
        lpBaseAddress, &
        dwRegionSize, &
        lpAddresses, &
        lpdwCount, &
        lpdwGranularity)
USE DFWINTY
  integer(UINT) :: GetWriteWatch ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetWriteWatch' :: GetWriteWatch
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(PVOID) lpBaseAddress ! PVOID lpBaseAddress
  integer(SIZE_T) dwRegionSize ! SIZE_T dwRegionSize
!DEC$ ATTRIBUTES REFERENCE :: lpAddresses
  integer(PVOID) lpAddresses ! PVOID* lpAddresses
!DEC$ ATTRIBUTES REFERENCE :: lpdwCount
  integer(UINT_PTR) lpdwCount ! PULONG_PTR lpdwCount
  integer(LPULONG) lpdwGranularity ! PULONG lpdwGranularity
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ResetWriteWatch( &
        lpBaseAddress, &
        dwRegionSize)
USE DFWINTY
  integer(UINT) :: ResetWriteWatch ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ResetWriteWatch' :: ResetWriteWatch
  integer(LPVOID) lpBaseAddress ! LPVOID lpBaseAddress
  integer(SIZE_T) dwRegionSize ! SIZE_T dwRegionSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualFreeEx( &
        hProcess, &
        lpAddress, &
        dwSize, &
        dwFreeType)
USE DFWINTY
  integer(BOOL) :: VirtualFreeEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualFreeEx' :: VirtualFreeEx
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
  integer(DWORD) dwFreeType ! DWORD dwFreeType
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualProtectEx( &
        hProcess, &
        lpAddress, &
        dwSize, &
        flNewProtect, &
        lpflOldProtect)
USE DFWINTY
  integer(BOOL) :: VirtualProtectEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualProtectEx' :: VirtualProtectEx
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
  integer(DWORD) flNewProtect ! DWORD flNewProtect
  integer(LPDWORD) lpflOldProtect ! PDWORD lpflOldProtect
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualQueryEx( &
        hProcess, &
        lpAddress, &
        lpBuffer, &
        dwLength)
USE DFWINTY
  integer(DWORD) :: VirtualQueryEx ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualQueryEx' :: VirtualQueryEx
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPCVOID) lpAddress ! LPCVOID lpAddress
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  TYPE (T_MEMORY_BASIC_INFORMATION) lpBuffer ! PMEMORY_BASIC_INFORMATION lpBuffer
  integer(DWORD) dwLength ! DWORD dwLength
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapCreate( &
        flOptions, &
        dwInitialSize, &
        dwMaximumSize)
USE DFWINTY
  integer(HANDLE) :: HeapCreate ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapCreate' :: HeapCreate
  integer(DWORD) flOptions ! DWORD flOptions
  integer(SIZE_T) dwInitialSize ! SIZE_T dwInitialSize
  integer(SIZE_T) dwMaximumSize ! SIZE_T dwMaximumSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapDestroy( &
        hHeap)
USE DFWINTY
  integer(BOOL) :: HeapDestroy ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapDestroy' :: HeapDestroy
  integer(HANDLE) hHeap ! HANDLE hHeap
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapAlloc( &
        hHeap, &
        dwFlags, &
        dwBytes)
USE DFWINTY
  integer(LPVOID) :: HeapAlloc ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapAlloc' :: HeapAlloc
  integer(HANDLE) hHeap ! HANDLE hHeap
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(SIZE_T) dwBytes ! SIZE_T dwBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapReAlloc( &
        hHeap, &
        dwFlags, &
        lpMem, &
        dwBytes)
USE DFWINTY
  integer(LPVOID) :: HeapReAlloc ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapReAlloc' :: HeapReAlloc
  integer(HANDLE) hHeap ! HANDLE hHeap
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPVOID) lpMem ! LPVOID lpMem
  integer(SIZE_T) dwBytes ! SIZE_T dwBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapFree( &
        hHeap, &
        dwFlags, &
        lpMem)
USE DFWINTY
  integer(BOOL) :: HeapFree ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapFree' :: HeapFree
  integer(HANDLE) hHeap ! HANDLE hHeap
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPVOID) lpMem ! LPVOID lpMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapSize( &
        hHeap, &
        dwFlags, &
        lpMem)
USE DFWINTY
  integer(SIZE_T) :: HeapSize ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapSize' :: HeapSize
  integer(HANDLE) hHeap ! HANDLE hHeap
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPCVOID) lpMem ! LPCVOID lpMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapValidate( &
        hHeap, &
        dwFlags, &
        lpMem)
USE DFWINTY
  integer(BOOL) :: HeapValidate ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapValidate' :: HeapValidate
  integer(HANDLE) hHeap ! HANDLE hHeap
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPCVOID) lpMem ! LPCVOID lpMem
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapCompact( &
        hHeap, &
        dwFlags)
USE DFWINTY
  integer(SIZE_T) :: HeapCompact ! SIZE_T
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapCompact' :: HeapCompact
  integer(HANDLE) hHeap ! HANDLE hHeap
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessHeap( &
             )
USE DFWINTY
  integer(HANDLE) :: GetProcessHeap ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessHeap' :: GetProcessHeap
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessHeaps( &
        NumberOfHeaps, &
        ProcessHeaps)
USE DFWINTY
  integer(DWORD) :: GetProcessHeaps ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessHeaps' :: GetProcessHeaps
  integer(DWORD) NumberOfHeaps ! DWORD NumberOfHeaps
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: ProcessHeaps
  integer(HANDLE) ProcessHeaps ! PHANDLE ProcessHeaps
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapLock( &
        hHeap)
USE DFWINTY
  integer(BOOL) :: HeapLock ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapLock' :: HeapLock
  integer(HANDLE) hHeap ! HANDLE hHeap
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapUnlock( &
        hHeap)
USE DFWINTY
  integer(BOOL) :: HeapUnlock ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapUnlock' :: HeapUnlock
  integer(HANDLE) hHeap ! HANDLE hHeap
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION HeapWalk( &
        hHeap, &
        lpEntry)
USE DFWINTY
  integer(BOOL) :: HeapWalk ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'HeapWalk' :: HeapWalk
  integer(HANDLE) hHeap ! HANDLE hHeap
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpEntry
  TYPE (T_PROCESS_HEAP_ENTRY) lpEntry ! LPPROCESS_HEAP_ENTRY lpEntry
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetBinaryType( &
        lpApplicationName, &
        lpBinaryType)
USE DFWINTY
  integer(BOOL) :: GetBinaryType ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetBinaryTypeA' :: GetBinaryType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpApplicationName
  character*(*) lpApplicationName ! LPCSTR lpApplicationName
  integer(LPDWORD) lpBinaryType ! LPDWORD lpBinaryType
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetShortPathName( &
        lpszLongPath, &
        lpszShortPath, &
        cchBuffer)
USE DFWINTY
  integer(DWORD) :: GetShortPathName ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetShortPathNameA' :: GetShortPathName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszLongPath
  character*(*) lpszLongPath ! LPCSTR lpszLongPath
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszShortPath
  character*(*) lpszShortPath ! LPSTR lpszShortPath
  integer(DWORD) cchBuffer ! DWORD cchBuffer
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetLongPathName( &
        lpszShortPath, &
        lpszLongPath, &
        cchBuffer)
USE DFWINTY
  integer(DWORD) :: GetLongPathName ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLongPathNameA' :: GetLongPathName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszShortPath
  character*(*) lpszShortPath ! LPCSTR lpszShortPath
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszLongPath
  character*(*) lpszLongPath ! LPSTR lpszLongPath
  integer(DWORD) cchBuffer ! DWORD cchBuffer
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessAffinityMask( &
        hProcess, &
        lpProcessAffinityMask, &
        lpSystemAffinityMask)
USE DFWINTY
  integer(BOOL) :: GetProcessAffinityMask ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessAffinityMask' :: GetProcessAffinityMask
  integer(HANDLE) hProcess ! HANDLE hProcess
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpProcessAffinityMask
  integer(ULONG_PTR) lpProcessAffinityMask ! PDWORD_PTR lpProcessAffinityMask
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpSystemAffinityMask
  integer(ULONG_PTR) lpSystemAffinityMask ! PDWORD_PTR lpSystemAffinityMask
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetProcessAffinityMask( &
        hProcess, &
        dwProcessAffinityMask)
USE DFWINTY
  integer(BOOL) :: SetProcessAffinityMask ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetProcessAffinityMask' :: SetProcessAffinityMask
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(DWORD_PTR) dwProcessAffinityMask ! DWORD_PTR dwProcessAffinityMask
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessTimes( &
        hProcess, &
        lpCreationTime, &
        lpExitTime, &
        lpKernelTime, &
        lpUserTime)
USE DFWINTY
  integer(BOOL) :: GetProcessTimes ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessTimes' :: GetProcessTimes
  integer(HANDLE) hProcess ! HANDLE hProcess
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCreationTime
  TYPE (T_FILETIME) lpCreationTime ! LPFILETIME lpCreationTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpExitTime
  TYPE (T_FILETIME) lpExitTime ! LPFILETIME lpExitTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKernelTime
  TYPE (T_FILETIME) lpKernelTime ! LPFILETIME lpKernelTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpUserTime
  TYPE (T_FILETIME) lpUserTime ! LPFILETIME lpUserTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessIoCounters( &
        hProcess, &
        lpIoCounters)
USE DFWINTY
  integer(BOOL) :: GetProcessIoCounters ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessIoCounters' :: GetProcessIoCounters
  integer(HANDLE) hProcess ! HANDLE hProcess
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpIoCounters
  TYPE(T_IO_COUNTERS)  lpIoCounters ! PIO_COUNTERS lpIoCounters
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessWorkingSetSize( &
        hProcess, &
        lpMinimumWorkingSetSize, &
        lpMaximumWorkingSetSize)
USE DFWINTY
  integer(BOOL) :: GetProcessWorkingSetSize ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessWorkingSetSize' :: GetProcessWorkingSetSize
  integer(HANDLE) hProcess ! HANDLE hProcess
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpMinimumWorkingSetSize
  integer(SIZE_T) lpMinimumWorkingSetSize ! PSIZE_T lpMinimumWorkingSetSize
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpMaximumWorkingSetSize
  integer(SIZE_T) lpMaximumWorkingSetSize ! PSIZE_T lpMaximumWorkingSetSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetProcessWorkingSetSize( &
        hProcess, &
        dwMinimumWorkingSetSize, &
        dwMaximumWorkingSetSize)
USE DFWINTY
  integer(BOOL) :: SetProcessWorkingSetSize ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetProcessWorkingSetSize' :: SetProcessWorkingSetSize
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(SIZE_T) dwMinimumWorkingSetSize ! SIZE_T dwMinimumWorkingSetSize
  integer(SIZE_T) dwMaximumWorkingSetSize ! SIZE_T dwMaximumWorkingSetSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenProcess( &
        dwDesiredAccess, &
        bInheritHandle, &
        dwProcessId)
USE DFWINTY
  integer(HANDLE) :: OpenProcess ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenProcess' :: OpenProcess
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
  integer(DWORD) dwProcessId ! DWORD dwProcessId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCurrentProcess( &
             )
USE DFWINTY
  integer(HANDLE) :: GetCurrentProcess ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCurrentProcess' :: GetCurrentProcess
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCurrentProcessId( &
             )
USE DFWINTY
  integer(DWORD) :: GetCurrentProcessId ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCurrentProcessId' :: GetCurrentProcessId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TerminateProcess( &
        hProcess, &
        uExitCode)
USE DFWINTY
  integer(BOOL) :: TerminateProcess ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TerminateProcess' :: TerminateProcess
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(UINT) uExitCode ! UINT uExitCode
 END FUNCTION
END INTERFACE
INTERFACE 
SUBROUTINE ExitProcess(&
            uExitCode )
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ExitProcess' :: ExitProcess
 integer(UINT) uExitCode
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION GetExitCodeProcess( &
        hProcess, &
        lpExitCode)
USE DFWINTY
  integer(BOOL) :: GetExitCodeProcess ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetExitCodeProcess' :: GetExitCodeProcess
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPDWORD) lpExitCode ! LPDWORD lpExitCode
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE FatalExit( &
        ExitCode)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FatalExit' :: FatalExit
  integer(SINT) ExitCode ! int ExitCode
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION GetEnvironmentStrings( &
             )
USE DFWINTY
  integer(LPSTR) :: GetEnvironmentStrings ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetEnvironmentStrings' :: GetEnvironmentStrings
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FreeEnvironmentStrings( &
        arg1)
USE DFWINTY
  integer(BOOL) :: FreeEnvironmentStrings ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FreeEnvironmentStringsA' :: FreeEnvironmentStrings
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: arg1
  character*(*) arg1 ! LPSTR arg1
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE RaiseException( &
        dwExceptionCode, &
        dwExceptionFlags, &
        nNumberOfArguments, &
        lpArguments)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RaiseException' :: RaiseException
  integer(DWORD) dwExceptionCode ! DWORD dwExceptionCode
  integer(DWORD) dwExceptionFlags ! DWORD dwExceptionFlags
  integer(DWORD) nNumberOfArguments ! DWORD nNumberOfArguments
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpArguments
  integer(ULONG_PTR) lpArguments ! ULONG_PTR* lpArguments
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION UnhandledExceptionFilter( &
        lpTopLevelExceptionFilter)
USE DFWINTY
  integer(LONG) :: UnhandledExceptionFilter ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'UnhandledExceptionFilter' :: UnhandledExceptionFilter
     integer(LPVOID) lpTopLevelExceptionFilter ! LPTOP_LEVEL_EXCEPTION_FILTER __stdcall SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION CreateFiber( &
        dwStackSize, &
        lpStartAddress, &
        lpParameter)
USE DFWINTY
  integer(LPVOID) :: CreateFiber ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateFiber' :: CreateFiber
  integer(DWORD) dwStackSize ! DWORD dwStackSize
  integer(LPVOID) lpStartAddress ! LPFIBER_START_ROUTINE lpStartAddress
  integer(LPVOID) lpParameter ! LPVOID lpParameter
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE DeleteFiber( &
        lpFiber)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DeleteFiber' :: DeleteFiber
  integer(LPVOID) lpFiber ! LPVOID lpFiber
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION ConvertThreadToFiber( &
        lpParameter)
USE DFWINTY
  integer(LPVOID) :: ConvertThreadToFiber ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ConvertThreadToFiber' :: ConvertThreadToFiber
  integer(LPVOID) lpParameter ! LPVOID lpParameter
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE SwitchToFiber( &
        lpFiber)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SwitchToFiber' :: SwitchToFiber
  integer(LPVOID) lpFiber ! LPVOID lpFiber
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION SwitchToThread( &
             )
USE DFWINTY
  integer(BOOL) :: SwitchToThread ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SwitchToThread' :: SwitchToThread
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION CreateThread( &
        lpThreadAttributes, &
        dwStackSize, &
        lpStartAddress, &
        lpParameter, &
        dwCreationFlags, &
        lpThreadId)
USE DFWINTY
  integer(HANDLE) :: CreateThread ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateThread' :: CreateThread
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpThreadAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpThreadAttributes ! LPSECURITY_ATTRIBUTES lpThreadAttributes
  integer(DWORD) dwStackSize ! DWORD dwStackSize
  integer(LPVOID) lpStartAddress ! LPTHREAD_START_ROUTINE lpStartAddress
  integer(LPVOID) lpParameter ! LPVOID lpParameter
  integer(DWORD) dwCreationFlags ! DWORD dwCreationFlags
  integer(LPDWORD) lpThreadId ! LPDWORD lpThreadId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateRemoteThread( &
        hProcess, &
        lpThreadAttributes, &
        dwStackSize, &
        lpStartAddress, &
        lpParameter, &
        dwCreationFlags, &
        lpThreadId)
USE DFWINTY
  integer(HANDLE) :: CreateRemoteThread ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateRemoteThread' :: CreateRemoteThread
  integer(HANDLE) hProcess ! HANDLE hProcess
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpThreadAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpThreadAttributes ! LPSECURITY_ATTRIBUTES lpThreadAttributes
  integer(DWORD) dwStackSize ! DWORD dwStackSize
  integer(LPVOID) lpStartAddress ! LPTHREAD_START_ROUTINE lpStartAddress
  integer(LPVOID) lpParameter ! LPVOID lpParameter
  integer(DWORD) dwCreationFlags ! DWORD dwCreationFlags
  integer(LPDWORD) lpThreadId ! LPDWORD lpThreadId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCurrentThread( &
             )
USE DFWINTY
  integer(HANDLE) :: GetCurrentThread ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCurrentThread' :: GetCurrentThread
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCurrentThreadId( &
             )
USE DFWINTY
  integer(DWORD) :: GetCurrentThreadId ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCurrentThreadId' :: GetCurrentThreadId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetThreadAffinityMask( &
        hThread, &
        dwThreadAffinityMask)
USE DFWINTY
  integer(DWORD_PTR) :: SetThreadAffinityMask ! DWORD_PTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadAffinityMask' :: SetThreadAffinityMask
  integer(HANDLE) hThread ! HANDLE hThread
  integer(DWORD_PTR) dwThreadAffinityMask ! DWORD_PTR dwThreadAffinityMask
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION SetThreadIdealProcessor( &
        hThread, &
        dwIdealProcessor)
USE DFWINTY
  integer(DWORD) :: SetThreadIdealProcessor ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadIdealProcessor' :: SetThreadIdealProcessor
  integer(HANDLE) hThread ! HANDLE hThread
  integer(DWORD) dwIdealProcessor ! DWORD dwIdealProcessor
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION SetProcessPriorityBoost( &
        hProcess, &
        bDisablePriorityBoost)
USE DFWINTY
  integer(BOOL) :: SetProcessPriorityBoost ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetProcessPriorityBoost' :: SetProcessPriorityBoost
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(BOOL) bDisablePriorityBoost ! BOOL bDisablePriorityBoost
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessPriorityBoost( &
        hProcess, &
        pDisablePriorityBoost)
USE DFWINTY
  integer(BOOL) :: GetProcessPriorityBoost ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessPriorityBoost' :: GetProcessPriorityBoost
  integer(HANDLE) hProcess ! HANDLE hProcess
!DEC$ ATTRIBUTES REFERENCE :: pDisablePriorityBoost
  integer(BOOL) pDisablePriorityBoost ! PBOOL pDisablePriorityBoost
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION RequestWakeupLatency( &
        latency)
USE DFWINTY
  integer(BOOL) :: RequestWakeupLatency ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RequestWakeupLatency' :: RequestWakeupLatency
    integer(ENUM) latency ! LATENCY_TIME latency
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsSystemResumeAutomatic( &
             )
USE DFWINTY
  integer(BOOL) :: IsSystemResumeAutomatic ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsSystemResumeAutomatic' :: IsSystemResumeAutomatic
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenThread( &
        dwDesiredAccess, &
        bInheritHandle, &
        dwThreadId)
USE DFWINTY
  integer(HANDLE) :: OpenThread ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenThread' :: OpenThread
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
  integer(DWORD) dwThreadId ! DWORD dwThreadId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetThreadPriority( &
        hThread, &
        nPriority)
USE DFWINTY
  integer(BOOL) :: SetThreadPriority ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadPriority' :: SetThreadPriority
  integer(HANDLE) hThread ! HANDLE hThread
  integer(SINT) nPriority ! int nPriority
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetThreadPriorityBoost( &
        hThread, &
        bDisablePriorityBoost)
USE DFWINTY
  integer(BOOL) :: SetThreadPriorityBoost ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadPriorityBoost' :: SetThreadPriorityBoost
  integer(HANDLE) hThread ! HANDLE hThread
  integer(BOOL) bDisablePriorityBoost ! BOOL bDisablePriorityBoost
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetThreadPriorityBoost( &
        hThread, &
        pDisablePriorityBoost)
USE DFWINTY
  integer(BOOL) :: GetThreadPriorityBoost ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetThreadPriorityBoost' :: GetThreadPriorityBoost
  integer(HANDLE) hThread ! HANDLE hThread
!DEC$ ATTRIBUTES REFERENCE :: pDisablePriorityBoost
  integer(BOOL) pDisablePriorityBoost ! PBOOL pDisablePriorityBoost
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetThreadPriority( &
        hThread)
USE DFWINTY
  integer(SINT) :: GetThreadPriority ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetThreadPriority' :: GetThreadPriority
  integer(HANDLE) hThread ! HANDLE hThread
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetThreadTimes( &
        hThread, &
        lpCreationTime, &
        lpExitTime, &
        lpKernelTime, &
        lpUserTime)
USE DFWINTY
  integer(BOOL) :: GetThreadTimes ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetThreadTimes' :: GetThreadTimes
  integer(HANDLE) hThread ! HANDLE hThread
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCreationTime
  TYPE (T_FILETIME) lpCreationTime ! LPFILETIME lpCreationTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpExitTime
  TYPE (T_FILETIME) lpExitTime ! LPFILETIME lpExitTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKernelTime
  TYPE (T_FILETIME) lpKernelTime ! LPFILETIME lpKernelTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpUserTime
  TYPE (T_FILETIME) lpUserTime ! LPFILETIME lpUserTime
 END FUNCTION
END INTERFACE
INTERFACE
SUBROUTINE ExitThread( &
        dwExitCode)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS: 'ExitThread' :: ExitThread
  integer(DWORD) dwExitCode ! DWORD dwExitCode
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION TerminateThread( &
        hThread, &
        dwExitCode)
USE DFWINTY
  integer(BOOL) :: TerminateThread ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TerminateThread' :: TerminateThread
  integer(HANDLE) hThread ! HANDLE hThread
  integer(DWORD) dwExitCode ! DWORD dwExitCode
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetExitCodeThread( &
        hThread, &
        lpExitCode)
USE DFWINTY
  integer(BOOL) :: GetExitCodeThread ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetExitCodeThread' :: GetExitCodeThread
  integer(HANDLE) hThread ! HANDLE hThread
  integer(LPDWORD) lpExitCode ! LPDWORD lpExitCode
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetThreadSelectorEntry( &
        hThread, &
        dwSelector, &
        lpSelectorEntry)
USE DFWINTY
  integer(BOOL) :: GetThreadSelectorEntry ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetThreadSelectorEntry' :: GetThreadSelectorEntry
  integer(HANDLE) hThread ! HANDLE hThread
  integer(DWORD) dwSelector ! DWORD dwSelector
  integer(LPVOID) lpSelectorEntry ! LPLDT_ENTRY lpSelectorEntry
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetThreadExecutionState( &
        esFlags)
USE DFWINTY
  integer(ULONG) :: SetThreadExecutionState ! EXECUTION_STATE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadExecutionState' :: SetThreadExecutionState
  integer(ULONG) esFlags ! EXECUTION_STATE esFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetLastError( &
             )
USE DFWINTY
  integer(DWORD) :: GetLastError ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLastError' :: GetLastError
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE SetLastError( &
        dwErrCode)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetLastError' :: SetLastError
  integer(DWORD) dwErrCode ! DWORD dwErrCode
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION GetOverlappedResult( &
        hFile, &
        lpOverlapped, &
        lpNumberOfBytesTransferred, &
        bWait)
USE DFWINTY
  integer(BOOL) :: GetOverlappedResult ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetOverlappedResult' :: GetOverlappedResult
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
  integer(LPDWORD) lpNumberOfBytesTransferred ! LPDWORD lpNumberOfBytesTransferred
  integer(BOOL) bWait ! BOOL bWait
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateIoCompletionPort( &
        FileHandle, &
        ExistingCompletionPort, &
        CompletionKey, &
        NumberOfConcurrentThreads)
USE DFWINTY
  integer(HANDLE) :: CreateIoCompletionPort ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateIoCompletionPort' :: CreateIoCompletionPort
  integer(HANDLE) FileHandle ! HANDLE FileHandle
  integer(HANDLE) ExistingCompletionPort ! HANDLE ExistingCompletionPort
  integer(ULONG_PTR) CompletionKey ! ULONG_PTR CompletionKey
  integer(DWORD) NumberOfConcurrentThreads ! DWORD NumberOfConcurrentThreads
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetQueuedCompletionStatus( &
        CompletionPort, &
        lpNumberOfBytesTransferred, &
        lpCompletionKey, &
        lpOverlapped, &
        dwMilliseconds)
USE DFWINTY
  integer(BOOL) :: GetQueuedCompletionStatus ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetQueuedCompletionStatus' :: GetQueuedCompletionStatus
  integer(HANDLE) CompletionPort ! HANDLE CompletionPort
  integer(LPDWORD) lpNumberOfBytesTransferred ! LPDWORD lpNumberOfBytesTransferred
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpCompletionKey
  integer(UINT_PTR) lpCompletionKey ! PULONG_PTR lpCompletionKey
  integer(LPVOID) lpOverlapped ! LPOVERLAPPED* lpOverlapped
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION PostQueuedCompletionStatus( &
        CompletionPort, &
        dwNumberOfBytesTransferred, &
        dwCompletionKey, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: PostQueuedCompletionStatus ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'PostQueuedCompletionStatus' :: PostQueuedCompletionStatus
  integer(HANDLE) CompletionPort ! HANDLE CompletionPort
  integer(DWORD) dwNumberOfBytesTransferred ! DWORD dwNumberOfBytesTransferred
  integer(ULONG_PTR) dwCompletionKey ! ULONG_PTR dwCompletionKey
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetErrorMode( &
        uMode)
USE DFWINTY
  integer(UINT) :: SetErrorMode ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetErrorMode' :: SetErrorMode
  integer(UINT) uMode ! UINT uMode
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadProcessMemory( &
        hProcess, &
        lpBaseAddress, &
        lpBuffer, &
        nSize, &
        lpNumberOfBytesRead)
USE DFWINTY
  integer(BOOL) :: ReadProcessMemory ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadProcessMemory' :: ReadProcessMemory
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPCVOID) lpBaseAddress ! LPCVOID lpBaseAddress
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(DWORD) nSize ! DWORD nSize
  integer(LPDWORD) lpNumberOfBytesRead ! LPDWORD lpNumberOfBytesRead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteProcessMemory( &
        hProcess, &
        lpBaseAddress, &
        lpBuffer, &
        nSize, &
        lpNumberOfBytesWritten)
USE DFWINTY
  integer(BOOL) :: WriteProcessMemory ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteProcessMemory' :: WriteProcessMemory
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(LPVOID) lpBaseAddress ! LPVOID lpBaseAddress
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(DWORD) nSize ! DWORD nSize
  integer(LPDWORD) lpNumberOfBytesWritten ! LPDWORD lpNumberOfBytesWritten
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetThreadContext( &
        hThread, &
        lpContext)
USE DFWINTY
  integer(BOOL) :: GetThreadContext ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetThreadContext' :: GetThreadContext
  integer(HANDLE) hThread ! HANDLE hThread
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpContext
 TYPE(T_CONTEXT) lpContext ! LPCONTEXT lpContext
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetThreadContext( &
        hThread, &
        lpContext)
USE DFWINTY
  integer(BOOL) :: SetThreadContext ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadContext' :: SetThreadContext
  integer(HANDLE) hThread ! HANDLE hThread
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpContext
  TYPE (T_CONTEXT) lpContext ! CONTEXT* lpContext
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SuspendThread( &
        hThread)
USE DFWINTY
  integer(DWORD) :: SuspendThread ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SuspendThread' :: SuspendThread
  integer(HANDLE) hThread ! HANDLE hThread
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ResumeThread( &
        hThread)
USE DFWINTY
  integer(DWORD) :: ResumeThread ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ResumeThread' :: ResumeThread
  integer(HANDLE) hThread ! HANDLE hThread
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION QueueUserAPC( &
        pfnAPC, &
        hThread, &
        dwData)
USE DFWINTY
  integer(DWORD) :: QueueUserAPC ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'QueueUserAPC' :: QueueUserAPC
    integer(LPVOID) pfnAPC ! PAPCFUNC pfnAPC
  integer(HANDLE) hThread ! HANDLE hThread
  integer(ULONG_PTR) dwData ! ULONG_PTR dwData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsDebuggerPresent( &
             )
USE DFWINTY
  integer(BOOL) :: IsDebuggerPresent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsDebuggerPresent' :: IsDebuggerPresent
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
   SUBROUTINE DebugBreak( &
             )
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DebugBreak' :: DebugBreak
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION WaitForDebugEvent( &
        lpDebugEvent, &
        dwMilliseconds)
USE DFWINTY
  integer(BOOL) :: WaitForDebugEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitForDebugEvent' :: WaitForDebugEvent
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDebugEvent
  TYPE (T_DEBUG_EVENT) lpDebugEvent ! LPDEBUG_EVENT lpDebugEvent
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ContinueDebugEvent( &
        dwProcessId, &
        dwThreadId, &
        dwContinueStatus)
USE DFWINTY
  integer(BOOL) :: ContinueDebugEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ContinueDebugEvent' :: ContinueDebugEvent
  integer(DWORD) dwProcessId ! DWORD dwProcessId
  integer(DWORD) dwThreadId ! DWORD dwThreadId
  integer(DWORD) dwContinueStatus ! DWORD dwContinueStatus
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DebugActiveProcess( &
        dwProcessId)
USE DFWINTY
  integer(BOOL) :: DebugActiveProcess ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DebugActiveProcess' :: DebugActiveProcess
  integer(DWORD) dwProcessId ! DWORD dwProcessId
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE InitializeCriticalSection( &
        lpCriticalSection)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InitializeCriticalSection' :: InitializeCriticalSection
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCriticalSection
 TYPE(T_RTL_CRITICAL_SECTION) lpCriticalSection ! LPCRITICAL_SECTION lpCriticalSection
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE EnterCriticalSection( &
        lpCriticalSection)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnterCriticalSection' :: EnterCriticalSection
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCriticalSection
 TYPE(T_RTL_CRITICAL_SECTION) lpCriticalSection ! LPCRITICAL_SECTION lpCriticalSection
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE LeaveCriticalSection( &
        lpCriticalSection)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LeaveCriticalSection' :: LeaveCriticalSection
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCriticalSection
 TYPE(T_RTL_CRITICAL_SECTION) lpCriticalSection ! LPCRITICAL_SECTION lpCriticalSection
 END SUBROUTINE
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION TryEnterCriticalSection( &
        lpCriticalSection)
USE DFWINTY
  integer(BOOL) :: TryEnterCriticalSection ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TryEnterCriticalSection' :: TryEnterCriticalSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCriticalSection
 TYPE(T_RTL_CRITICAL_SECTION) lpCriticalSection ! LPCRITICAL_SECTION lpCriticalSection
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
   SUBROUTINE DeleteCriticalSection( &
        lpCriticalSection)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DeleteCriticalSection' :: DeleteCriticalSection
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCriticalSection
 TYPE(T_RTL_CRITICAL_SECTION) lpCriticalSection ! LPCRITICAL_SECTION lpCriticalSection
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION SetEvent( &
        hEvent)
USE DFWINTY
  integer(BOOL) :: SetEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetEvent' :: SetEvent
  integer(HANDLE) hEvent ! HANDLE hEvent
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ResetEvent( &
        hEvent)
USE DFWINTY
  integer(BOOL) :: ResetEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ResetEvent' :: ResetEvent
  integer(HANDLE) hEvent ! HANDLE hEvent
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION PulseEvent( &
        hEvent)
USE DFWINTY
  integer(BOOL) :: PulseEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'PulseEvent' :: PulseEvent
  integer(HANDLE) hEvent ! HANDLE hEvent
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReleaseSemaphore( &
        hSemaphore, &
        lReleaseCount, &
        lpPreviousCount)
USE DFWINTY
  integer(BOOL) :: ReleaseSemaphore ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReleaseSemaphore' :: ReleaseSemaphore
  integer(HANDLE) hSemaphore ! HANDLE hSemaphore
  integer(LONG) lReleaseCount ! LONG lReleaseCount
  integer(LPLONG) lpPreviousCount ! LPLONG lpPreviousCount
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReleaseMutex( &
        hMutex)
USE DFWINTY
  integer(BOOL) :: ReleaseMutex ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReleaseMutex' :: ReleaseMutex
  integer(HANDLE) hMutex ! HANDLE hMutex
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WaitForSingleObject( &
        hHandle, &
        dwMilliseconds)
USE DFWINTY
  integer(DWORD) :: WaitForSingleObject ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitForSingleObject' :: WaitForSingleObject
  integer(HANDLE) hHandle ! HANDLE hHandle
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WaitForMultipleObjects( &
        nCount, &
        lpHandles, &
        bWaitAll, &
        dwMilliseconds)
USE DFWINTY
  integer(DWORD) :: WaitForMultipleObjects ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitForMultipleObjects' :: WaitForMultipleObjects
  integer(DWORD) nCount ! DWORD nCount
  integer(PHANDLE) lpHandles ! HANDLE* lpHandles
  integer(BOOL) bWaitAll ! BOOL bWaitAll
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE Sleep( &
        dwMilliseconds)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'Sleep' :: Sleep
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION LoadResource( &
        hModule, &
        hResInfo)
USE DFWINTY
  integer(HANDLE) :: LoadResource ! HGLOBAL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LoadResource' :: LoadResource
  integer(HANDLE) hModule ! HMODULE hModule
  integer(HANDLE) hResInfo ! HRSRC hResInfo
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SizeofResource( &
        hModule, &
        hResInfo)
USE DFWINTY
  integer(DWORD) :: SizeofResource ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SizeofResource' :: SizeofResource
  integer(HANDLE) hModule ! HMODULE hModule
  integer(HANDLE) hResInfo ! HRSRC hResInfo
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalDeleteAtom( &
        nAtom)
USE DFWINTY
  integer(USHORT) :: GlobalDeleteAtom ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalDeleteAtom' :: GlobalDeleteAtom
  integer(USHORT) nAtom ! ATOM nAtom
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION InitAtomTable( &
        nSize)
USE DFWINTY
  integer(BOOL) :: InitAtomTable ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'InitAtomTable' :: InitAtomTable
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DeleteAtom( &
        nAtom)
USE DFWINTY
  integer(USHORT) :: DeleteAtom ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DeleteAtom' :: DeleteAtom
  integer(USHORT) nAtom ! ATOM nAtom
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetHandleCount( &
        uNumber)
USE DFWINTY
  integer(UINT) :: SetHandleCount ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetHandleCount' :: SetHandleCount
  integer(UINT) uNumber ! UINT uNumber
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetLogicalDrives( &
             )
USE DFWINTY
  integer(DWORD) :: GetLogicalDrives ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLogicalDrives' :: GetLogicalDrives
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LockFile( &
        hFile, &
        dwFileOffsetLow, &
        dwFileOffsetHigh, &
        nNumberOfBytesToLockLow, &
        nNumberOfBytesToLockHigh)
USE DFWINTY
  integer(BOOL) :: LockFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LockFile' :: LockFile
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwFileOffsetLow ! DWORD dwFileOffsetLow
  integer(DWORD) dwFileOffsetHigh ! DWORD dwFileOffsetHigh
  integer(DWORD) nNumberOfBytesToLockLow ! DWORD nNumberOfBytesToLockLow
  integer(DWORD) nNumberOfBytesToLockHigh ! DWORD nNumberOfBytesToLockHigh
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION UnlockFile( &
        hFile, &
        dwFileOffsetLow, &
        dwFileOffsetHigh, &
        nNumberOfBytesToUnlockLow, &
        nNumberOfBytesToUnlockHigh)
USE DFWINTY
  integer(BOOL) :: UnlockFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'UnlockFile' :: UnlockFile
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwFileOffsetLow ! DWORD dwFileOffsetLow
  integer(DWORD) dwFileOffsetHigh ! DWORD dwFileOffsetHigh
  integer(DWORD) nNumberOfBytesToUnlockLow ! DWORD nNumberOfBytesToUnlockLow
  integer(DWORD) nNumberOfBytesToUnlockHigh ! DWORD nNumberOfBytesToUnlockHigh
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LockFileEx( &
        hFile, &
        dwFlags, &
        dwReserved, &
        nNumberOfBytesToLockLow, &
        nNumberOfBytesToLockHigh, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: LockFileEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LockFileEx' :: LockFileEx
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(DWORD) dwReserved ! DWORD dwReserved
  integer(DWORD) nNumberOfBytesToLockLow ! DWORD nNumberOfBytesToLockLow
  integer(DWORD) nNumberOfBytesToLockHigh ! DWORD nNumberOfBytesToLockHigh
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION UnlockFileEx( &
        hFile, &
        dwReserved, &
        nNumberOfBytesToUnlockLow, &
        nNumberOfBytesToUnlockHigh, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: UnlockFileEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'UnlockFileEx' :: UnlockFileEx
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwReserved ! DWORD dwReserved
  integer(DWORD) nNumberOfBytesToUnlockLow ! DWORD nNumberOfBytesToUnlockLow
  integer(DWORD) nNumberOfBytesToUnlockHigh ! DWORD nNumberOfBytesToUnlockHigh
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileInformationByHandle( &
        hFile, &
        lpFileInformation)
USE DFWINTY
  integer(BOOL) :: GetFileInformationByHandle ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileInformationByHandle' :: GetFileInformationByHandle
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileInformation
  TYPE (T_BY_HANDLE_FILE_INFORMATION) lpFileInformation ! LPBY_HANDLE_FILE_INFORMATION lpFileInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileType( &
        hFile)
USE DFWINTY
  integer(DWORD) :: GetFileType ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileType' :: GetFileType
  integer(HANDLE) hFile ! HANDLE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileSize( &
        hFile, &
        lpFileSizeHigh)
USE DFWINTY
  integer(DWORD) :: GetFileSize ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileSize' :: GetFileSize
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPDWORD) lpFileSizeHigh ! LPDWORD lpFileSizeHigh
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileSizeEx( &
        hFile, &
        lpFileSize)
USE DFWINTY
  integer(BOOL) :: GetFileSizeEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileSizeEx' :: GetFileSizeEx
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileSize
  TYPE(T_LARGE_INTEGER)  lpFileSize ! PLARGE_INTEGER lpFileSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetStdHandle( &
        nStdHandle)
USE DFWINTY
  integer(HANDLE) :: GetStdHandle ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetStdHandle' :: GetStdHandle
  integer(DWORD) nStdHandle ! DWORD nStdHandle
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetStdHandle( &
        nStdHandle, &
        hHandle)
USE DFWINTY
  integer(BOOL) :: SetStdHandle ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetStdHandle' :: SetStdHandle
  integer(DWORD) nStdHandle ! DWORD nStdHandle
  integer(HANDLE) hHandle ! HANDLE hHandle
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteFile( &
        hFile, &
        lpBuffer, &
        nNumberOfBytesToWrite, &
        lpNumberOfBytesWritten, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: WriteFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteFile' :: WriteFile
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPCVOID) lpBuffer ! LPCVOID lpBuffer
  integer(DWORD) nNumberOfBytesToWrite ! DWORD nNumberOfBytesToWrite
  integer(LPDWORD) lpNumberOfBytesWritten ! LPDWORD lpNumberOfBytesWritten
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadFile( &
        hFile, &
        lpBuffer, &
        nNumberOfBytesToRead, &
        lpNumberOfBytesRead, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: ReadFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadFile' :: ReadFile
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(DWORD) nNumberOfBytesToRead ! DWORD nNumberOfBytesToRead
  integer(LPDWORD) lpNumberOfBytesRead ! LPDWORD lpNumberOfBytesRead
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FlushFileBuffers( &
        hFile)
USE DFWINTY
  integer(BOOL) :: FlushFileBuffers ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FlushFileBuffers' :: FlushFileBuffers
  integer(HANDLE) hFile ! HANDLE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DeviceIoControl( &
        hDevice, &
        dwIoControlCode, &
        lpInBuffer, &
        nInBufferSize, &
        lpOutBuffer, &
        nOutBufferSize, &
        lpBytesReturned, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: DeviceIoControl ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DeviceIoControl' :: DeviceIoControl
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwIoControlCode ! DWORD dwIoControlCode
  integer(LPVOID) lpInBuffer ! LPVOID lpInBuffer
  integer(DWORD) nInBufferSize ! DWORD nInBufferSize
  integer(LPVOID) lpOutBuffer ! LPVOID lpOutBuffer
  integer(DWORD) nOutBufferSize ! DWORD nOutBufferSize
  integer(LPDWORD) lpBytesReturned ! LPDWORD lpBytesReturned
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION RequestDeviceWakeup( &
        hDevice)
USE DFWINTY
  integer(BOOL) :: RequestDeviceWakeup ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RequestDeviceWakeup' :: RequestDeviceWakeup
  integer(HANDLE) hDevice ! HANDLE hDevice
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CancelDeviceWakeupRequest( &
        hDevice)
USE DFWINTY
  integer(BOOL) :: CancelDeviceWakeupRequest ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CancelDeviceWakeupRequest' :: CancelDeviceWakeupRequest
  integer(HANDLE) hDevice ! HANDLE hDevice
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetDevicePowerState( &
        hDevice, &
        pfOn)
USE DFWINTY
  integer(BOOL) :: GetDevicePowerState ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetDevicePowerState' :: GetDevicePowerState
  integer(HANDLE) hDevice ! HANDLE hDevice
!DEC$ ATTRIBUTES REFERENCE :: pfOn
  integer(BOOL) pfOn ! BOOL* pfOn
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetMessageWaitingIndicator( &
        hMsgIndicator, &
        ulMsgCount)
USE DFWINTY
  integer(BOOL) :: SetMessageWaitingIndicator ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetMessageWaitingIndicator' :: SetMessageWaitingIndicator
  integer(HANDLE) hMsgIndicator ! HANDLE hMsgIndicator
  integer(ULONG) ulMsgCount ! ULONG ulMsgCount
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetEndOfFile( &
        hFile)
USE DFWINTY
  integer(BOOL) :: SetEndOfFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetEndOfFile' :: SetEndOfFile
  integer(HANDLE) hFile ! HANDLE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetFilePointer( &
        hFile, &
        lDistanceToMove, &
        lpDistanceToMoveHigh, &
        dwMoveMethod)
USE DFWINTY
  integer(DWORD) :: SetFilePointer ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetFilePointer' :: SetFilePointer
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LONG) lDistanceToMove ! LONG lDistanceToMove
  integer(LPLONG) lpDistanceToMoveHigh ! PLONG lpDistanceToMoveHigh
  integer(DWORD) dwMoveMethod ! DWORD dwMoveMethod
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetFilePointerEx( &
        hFile, &
        liDistanceToMove, &
        lpNewFilePointer, &
        dwMoveMethod)
USE DFWINTY
  integer(BOOL) :: SetFilePointerEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetFilePointerEx' :: SetFilePointerEx
  integer(HANDLE) hFile ! HANDLE hFile
  TYPE (T_LARGE_INTEGER) liDistanceToMove ! LARGE_INTEGER liDistanceToMove
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNewFilePointer
  TYPE(T_LARGE_INTEGER)  lpNewFilePointer ! PLARGE_INTEGER lpNewFilePointer
  integer(DWORD) dwMoveMethod ! DWORD dwMoveMethod
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FindClose( &
        hFindFile)
USE DFWINTY
  integer(BOOL) :: FindClose ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindClose' :: FindClose
  integer(HANDLE) hFindFile ! HANDLE hFindFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileTime( &
        hFile, &
        lpCreationTime, &
        lpLastAccessTime, &
        lpLastWriteTime)
USE DFWINTY
  integer(BOOL) :: GetFileTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileTime' :: GetFileTime
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCreationTime
  TYPE (T_FILETIME) lpCreationTime ! LPFILETIME lpCreationTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLastAccessTime
  TYPE (T_FILETIME) lpLastAccessTime ! LPFILETIME lpLastAccessTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLastWriteTime
  TYPE (T_FILETIME) lpLastWriteTime ! LPFILETIME lpLastWriteTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetFileTime( &
        hFile, &
        lpCreationTime, &
        lpLastAccessTime, &
        lpLastWriteTime)
USE DFWINTY
  integer(BOOL) :: SetFileTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetFileTime' :: SetFileTime
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCreationTime
  TYPE (T_FILETIME) lpCreationTime ! FILETIME* lpCreationTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLastAccessTime
  TYPE (T_FILETIME) lpLastAccessTime ! FILETIME* lpLastAccessTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLastWriteTime
  TYPE (T_FILETIME) lpLastWriteTime ! FILETIME* lpLastWriteTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CloseHandle( &
        hObject)
USE DFWINTY
  integer(BOOL) :: CloseHandle ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CloseHandle' :: CloseHandle
  integer(HANDLE) hObject ! HANDLE hObject
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DuplicateHandle( &
        hSourceProcessHandle, &
        hSourceHandle, &
        hTargetProcessHandle, &
        lpTargetHandle, &
        dwDesiredAccess, &
        bInheritHandle, &
        dwOptions)
USE DFWINTY
  integer(BOOL) :: DuplicateHandle ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DuplicateHandle' :: DuplicateHandle
  integer(HANDLE) hSourceProcessHandle ! HANDLE hSourceProcessHandle
  integer(HANDLE) hSourceHandle ! HANDLE hSourceHandle
  integer(HANDLE) hTargetProcessHandle ! HANDLE hTargetProcessHandle
  integer(LPHANDLE) lpTargetHandle ! LPHANDLE lpTargetHandle
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
  integer(DWORD) dwOptions ! DWORD dwOptions
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetHandleInformation( &
        hObject, &
        lpdwFlags)
USE DFWINTY
  integer(BOOL) :: GetHandleInformation ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetHandleInformation' :: GetHandleInformation
  integer(HANDLE) hObject ! HANDLE hObject
  integer(LPDWORD) lpdwFlags ! LPDWORD lpdwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetHandleInformation( &
        hObject, &
        dwMask, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: SetHandleInformation ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetHandleInformation' :: SetHandleInformation
  integer(HANDLE) hObject ! HANDLE hObject
  integer(DWORD) dwMask ! DWORD dwMask
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LoadModule( &
        lpModuleName, &
        lpParameterBlock)
USE DFWINTY
  integer(DWORD) :: LoadModule ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LoadModule' :: LoadModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpModuleName
  character*(*) lpModuleName ! LPCSTR lpModuleName
  integer(LPVOID) lpParameterBlock ! LPVOID lpParameterBlock
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WinExec( &
        lpCmdLine, &
        uCmdShow)
USE DFWINTY
  integer(UINT) :: WinExec ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WinExec' :: WinExec
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCmdLine
  character*(*) lpCmdLine ! LPCSTR lpCmdLine
  integer(UINT) uCmdShow ! UINT uCmdShow
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ClearCommBreak( &
        hFile)
USE DFWINTY
  integer(BOOL) :: ClearCommBreak ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ClearCommBreak' :: ClearCommBreak
  integer(HANDLE) hFile ! HANDLE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ClearCommError( &
        hFile, &
        lpErrors, &
        lpStat)
USE DFWINTY
  integer(BOOL) :: ClearCommError ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ClearCommError' :: ClearCommError
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPDWORD) lpErrors ! LPDWORD lpErrors
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpStat
  TYPE (T_COMSTAT) lpStat ! LPCOMSTAT lpStat
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetupComm( &
        hFile, &
        dwInQueue, &
        dwOutQueue)
USE DFWINTY
  integer(BOOL) :: SetupComm ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetupComm' :: SetupComm
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwInQueue ! DWORD dwInQueue
  integer(DWORD) dwOutQueue ! DWORD dwOutQueue
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EscapeCommFunction( &
        hFile, &
        dwFunc)
USE DFWINTY
  integer(BOOL) :: EscapeCommFunction ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EscapeCommFunction' :: EscapeCommFunction
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwFunc ! DWORD dwFunc
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCommConfig( &
        hCommDev, &
        lpCC, &
        lpdwSize)
USE DFWINTY
  integer(BOOL) :: GetCommConfig ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommConfig' :: GetCommConfig
  integer(HANDLE) hCommDev ! HANDLE hCommDev
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCC
  TYPE (T_COMMCONFIG) lpCC ! LPCOMMCONFIG lpCC
  integer(LPDWORD) lpdwSize ! LPDWORD lpdwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCommMask( &
        hFile, &
        lpEvtMask)
USE DFWINTY
  integer(BOOL) :: GetCommMask ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommMask' :: GetCommMask
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPDWORD) lpEvtMask ! LPDWORD lpEvtMask
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCommProperties( &
        hFile, &
        lpCommProp)
USE DFWINTY
  integer(BOOL) :: GetCommProperties ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommProperties' :: GetCommProperties
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCommProp
  TYPE (T_COMMPROP) lpCommProp ! LPCOMMPROP lpCommProp
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCommModemStatus( &
        hFile, &
        lpModemStat)
USE DFWINTY
  integer(BOOL) :: GetCommModemStatus ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommModemStatus' :: GetCommModemStatus
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPDWORD) lpModemStat ! LPDWORD lpModemStat
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCommState( &
        hFile, &
        lpDCB)
USE DFWINTY
  integer(BOOL) :: GetCommState ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommState' :: GetCommState
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDCB
  TYPE (T_DCB) lpDCB ! LPDCB lpDCB
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCommTimeouts( &
        hFile, &
        lpCommTimeouts)
USE DFWINTY
  integer(BOOL) :: GetCommTimeouts ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommTimeouts' :: GetCommTimeouts
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCommTimeouts
  TYPE (T_COMMTIMEOUTS) lpCommTimeouts ! LPCOMMTIMEOUTS lpCommTimeouts
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION PurgeComm( &
        hFile, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: PurgeComm ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'PurgeComm' :: PurgeComm
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCommBreak( &
        hFile)
USE DFWINTY
  integer(BOOL) :: SetCommBreak ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCommBreak' :: SetCommBreak
  integer(HANDLE) hFile ! HANDLE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCommConfig( &
        hCommDev, &
        lpCC, &
        dwSize)
USE DFWINTY
  integer(BOOL) :: SetCommConfig ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCommConfig' :: SetCommConfig
  integer(HANDLE) hCommDev ! HANDLE hCommDev
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCC
  TYPE (T_COMMCONFIG) lpCC ! LPCOMMCONFIG lpCC
  integer(DWORD) dwSize ! DWORD dwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCommMask( &
        hFile, &
        dwEvtMask)
USE DFWINTY
  integer(BOOL) :: SetCommMask ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCommMask' :: SetCommMask
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwEvtMask ! DWORD dwEvtMask
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCommState( &
        hFile, &
        lpDCB)
USE DFWINTY
  integer(BOOL) :: SetCommState ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCommState' :: SetCommState
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDCB
  TYPE (T_DCB) lpDCB ! LPDCB lpDCB
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCommTimeouts( &
        hFile, &
        lpCommTimeouts)
USE DFWINTY
  integer(BOOL) :: SetCommTimeouts ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCommTimeouts' :: SetCommTimeouts
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCommTimeouts
  TYPE (T_COMMTIMEOUTS) lpCommTimeouts ! LPCOMMTIMEOUTS lpCommTimeouts
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TransmitCommChar( &
        hFile, &
        cChar)
USE DFWINTY
  integer(BOOL) :: TransmitCommChar ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TransmitCommChar' :: TransmitCommChar
  integer(HANDLE) hFile ! HANDLE hFile
  character(SCHAR) cChar ! char cChar
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WaitCommEvent( &
        hFile, &
        lpEvtMask, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: WaitCommEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitCommEvent' :: WaitCommEvent
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPDWORD) lpEvtMask ! LPDWORD lpEvtMask
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetTapePosition( &
        hDevice, &
        dwPositionMethod, &
        dwPartition, &
        dwOffsetLow, &
        dwOffsetHigh, &
        bImmediate)
USE DFWINTY
  integer(DWORD) :: SetTapePosition ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetTapePosition' :: SetTapePosition
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwPositionMethod ! DWORD dwPositionMethod
  integer(DWORD) dwPartition ! DWORD dwPartition
  integer(DWORD) dwOffsetLow ! DWORD dwOffsetLow
  integer(DWORD) dwOffsetHigh ! DWORD dwOffsetHigh
  integer(BOOL) bImmediate ! BOOL bImmediate
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTapePosition( &
        hDevice, &
        dwPositionType, &
        lpdwPartition, &
        lpdwOffsetLow, &
        lpdwOffsetHigh)
USE DFWINTY
  integer(DWORD) :: GetTapePosition ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTapePosition' :: GetTapePosition
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwPositionType ! DWORD dwPositionType
  integer(LPDWORD) lpdwPartition ! LPDWORD lpdwPartition
  integer(LPDWORD) lpdwOffsetLow ! LPDWORD lpdwOffsetLow
  integer(LPDWORD) lpdwOffsetHigh ! LPDWORD lpdwOffsetHigh
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION PrepareTape( &
        hDevice, &
        dwOperation, &
        bImmediate)
USE DFWINTY
  integer(DWORD) :: PrepareTape ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'PrepareTape' :: PrepareTape
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwOperation ! DWORD dwOperation
  integer(BOOL) bImmediate ! BOOL bImmediate
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EraseTape( &
        hDevice, &
        dwEraseType, &
        bImmediate)
USE DFWINTY
  integer(DWORD) :: EraseTape ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EraseTape' :: EraseTape
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwEraseType ! DWORD dwEraseType
  integer(BOOL) bImmediate ! BOOL bImmediate
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateTapePartition( &
        hDevice, &
        dwPartitionMethod, &
        dwCount, &
        dwSize)
USE DFWINTY
  integer(DWORD) :: CreateTapePartition ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateTapePartition' :: CreateTapePartition
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwPartitionMethod ! DWORD dwPartitionMethod
  integer(DWORD) dwCount ! DWORD dwCount
  integer(DWORD) dwSize ! DWORD dwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteTapemark( &
        hDevice, &
        dwTapemarkType, &
        dwTapemarkCount, &
        bImmediate)
USE DFWINTY
  integer(DWORD) :: WriteTapemark ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteTapemark' :: WriteTapemark
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwTapemarkType ! DWORD dwTapemarkType
  integer(DWORD) dwTapemarkCount ! DWORD dwTapemarkCount
  integer(BOOL) bImmediate ! BOOL bImmediate
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTapeStatus( &
        hDevice)
USE DFWINTY
  integer(DWORD) :: GetTapeStatus ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTapeStatus' :: GetTapeStatus
  integer(HANDLE) hDevice ! HANDLE hDevice
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTapeParameters( &
        hDevice, &
        dwOperation, &
        lpdwSize, &
        lpTapeInformation)
USE DFWINTY
  integer(DWORD) :: GetTapeParameters ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTapeParameters' :: GetTapeParameters
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwOperation ! DWORD dwOperation
  integer(LPDWORD) lpdwSize ! LPDWORD lpdwSize
  integer(LPVOID) lpTapeInformation ! LPVOID lpTapeInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetTapeParameters( &
        hDevice, &
        dwOperation, &
        lpTapeInformation)
USE DFWINTY
  integer(DWORD) :: SetTapeParameters ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetTapeParameters' :: SetTapeParameters
  integer(HANDLE) hDevice ! HANDLE hDevice
  integer(DWORD) dwOperation ! DWORD dwOperation
  integer(LPVOID) lpTapeInformation ! LPVOID lpTapeInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION Beep( &
        dwFreq, &
        dwDuration)
USE DFWINTY
  integer(BOOL) :: Beep ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'Beep' :: Beep
  integer(DWORD) dwFreq ! DWORD dwFreq
  integer(DWORD) dwDuration ! DWORD dwDuration
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION MulDiv( &
        nNumber, &
        nNumerator, &
        nDenominator)
USE DFWINTY
  integer(SINT) :: MulDiv ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'MulDiv' :: MulDiv
  integer(SINT) nNumber ! int nNumber
  integer(SINT) nNumerator ! int nNumerator
  integer(SINT) nDenominator ! int nDenominator
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE GetSystemTime( &
        lpSystemTime)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemTime' :: GetSystemTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemTime
  TYPE (T_SYSTEMTIME) lpSystemTime ! LPSYSTEMTIME lpSystemTime
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE GetSystemTimeAsFileTime( &
        lpSystemTimeAsFileTime)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemTimeAsFileTime' :: GetSystemTimeAsFileTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemTimeAsFileTime
  TYPE (T_FILETIME) lpSystemTimeAsFileTime ! LPFILETIME lpSystemTimeAsFileTime
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION SetSystemTime( &
        lpSystemTime)
USE DFWINTY
  integer(BOOL) :: SetSystemTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetSystemTime' :: SetSystemTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemTime
  TYPE (T_SYSTEMTIME) lpSystemTime ! SYSTEMTIME* lpSystemTime
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE GetLocalTime( &
        lpSystemTime)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLocalTime' :: GetLocalTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemTime
  TYPE (T_SYSTEMTIME) lpSystemTime ! LPSYSTEMTIME lpSystemTime
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION SetLocalTime( &
        lpSystemTime)
USE DFWINTY
  integer(BOOL) :: SetLocalTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetLocalTime' :: SetLocalTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemTime
  TYPE (T_SYSTEMTIME) lpSystemTime ! SYSTEMTIME* lpSystemTime
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE GetSystemInfo( &
        lpSystemInfo)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemInfo' :: GetSystemInfo
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemInfo
  TYPE (T_SYSTEM_INFO) lpSystemInfo ! LPSYSTEM_INFO lpSystemInfo
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION IsProcessorFeaturePresent( &
        ProcessorFeature)
USE DFWINTY
  integer(BOOL) :: IsProcessorFeaturePresent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsProcessorFeaturePresent' :: IsProcessorFeaturePresent
  integer(DWORD) ProcessorFeature ! DWORD ProcessorFeature
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SystemTimeToTzSpecificLocalTime( &
        lpTimeZoneInformation, &
        lpUniversalTime, &
        lpLocalTime)
USE DFWINTY
  integer(BOOL) :: SystemTimeToTzSpecificLocalTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SystemTimeToTzSpecificLocalTime' :: SystemTimeToTzSpecificLocalTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimeZoneInformation
  TYPE (T_TIME_ZONE_INFORMATION) lpTimeZoneInformation ! LPTIME_ZONE_INFORMATION lpTimeZoneInformation
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpUniversalTime
  TYPE (T_SYSTEMTIME) lpUniversalTime ! LPSYSTEMTIME lpUniversalTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLocalTime
  TYPE (T_SYSTEMTIME) lpLocalTime ! LPSYSTEMTIME lpLocalTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTimeZoneInformation( &
        lpTimeZoneInformation)
USE DFWINTY
  integer(DWORD) :: GetTimeZoneInformation ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTimeZoneInformation' :: GetTimeZoneInformation
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimeZoneInformation
  TYPE (T_TIME_ZONE_INFORMATION) lpTimeZoneInformation ! LPTIME_ZONE_INFORMATION lpTimeZoneInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetTimeZoneInformation( &
        lpTimeZoneInformation)
USE DFWINTY
  integer(BOOL) :: SetTimeZoneInformation ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetTimeZoneInformation' :: SetTimeZoneInformation
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimeZoneInformation
  TYPE (T_TIME_ZONE_INFORMATION) lpTimeZoneInformation ! TIME_ZONE_INFORMATION* lpTimeZoneInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SystemTimeToFileTime( &
        lpSystemTime, &
        lpFileTime)
USE DFWINTY
  integer(BOOL) :: SystemTimeToFileTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SystemTimeToFileTime' :: SystemTimeToFileTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemTime
  TYPE (T_SYSTEMTIME) lpSystemTime ! SYSTEMTIME* lpSystemTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileTime
  TYPE (T_FILETIME) lpFileTime ! LPFILETIME lpFileTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FileTimeToLocalFileTime( &
        lpFileTime, &
        lpLocalFileTime)
USE DFWINTY
  integer(BOOL) :: FileTimeToLocalFileTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FileTimeToLocalFileTime' :: FileTimeToLocalFileTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileTime
  TYPE (T_FILETIME) lpFileTime ! FILETIME* lpFileTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpLocalFileTime
  TYPE (T_FILETIME) lpLocalFileTime ! LPFILETIME lpLocalFileTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LocalFileTimeToFileTime( &
        lpLocalFileTime, &
        lpFileTime)
USE DFWINTY
  integer(BOOL) :: LocalFileTimeToFileTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LocalFileTimeToFileTime' :: LocalFileTimeToFileTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpLocalFileTime
  TYPE (T_FILETIME) lpLocalFileTime ! FILETIME* lpLocalFileTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileTime
  TYPE (T_FILETIME) lpFileTime ! LPFILETIME lpFileTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FileTimeToSystemTime( &
        lpFileTime, &
        lpSystemTime)
USE DFWINTY
  integer(BOOL) :: FileTimeToSystemTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FileTimeToSystemTime' :: FileTimeToSystemTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileTime
  TYPE (T_FILETIME) lpFileTime ! FILETIME* lpFileTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpSystemTime
  TYPE (T_SYSTEMTIME) lpSystemTime ! LPSYSTEMTIME lpSystemTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CompareFileTime( &
        lpFileTime1, &
        lpFileTime2)
USE DFWINTY
  integer(LONG) :: CompareFileTime ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CompareFileTime' :: CompareFileTime
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileTime1
  TYPE (T_FILETIME) lpFileTime1 ! FILETIME* lpFileTime1
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileTime2
  TYPE (T_FILETIME) lpFileTime2 ! FILETIME* lpFileTime2
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FileTimeToDosDateTime( &
        lpFileTime, &
        lpFatDate, &
        lpFatTime)
USE DFWINTY
  integer(BOOL) :: FileTimeToDosDateTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FileTimeToDosDateTime' :: FileTimeToDosDateTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileTime
  TYPE (T_FILETIME) lpFileTime ! FILETIME* lpFileTime
  integer(LPWORD) lpFatDate ! LPWORD lpFatDate
  integer(LPWORD) lpFatTime ! LPWORD lpFatTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DosDateTimeToFileTime( &
        wFatDate, &
        wFatTime, &
        lpFileTime)
USE DFWINTY
  integer(BOOL) :: DosDateTimeToFileTime ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DosDateTimeToFileTime' :: DosDateTimeToFileTime
  integer(WORD) wFatDate ! WORD wFatDate
  integer(WORD) wFatTime ! WORD wFatTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileTime
  TYPE (T_FILETIME) lpFileTime ! LPFILETIME lpFileTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTickCount( &
             )
USE DFWINTY
  integer(DWORD) :: GetTickCount ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTickCount' :: GetTickCount
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetSystemTimeAdjustment( &
        dwTimeAdjustment, &
        bTimeAdjustmentDisabled)
USE DFWINTY
  integer(BOOL) :: SetSystemTimeAdjustment ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetSystemTimeAdjustment' :: SetSystemTimeAdjustment
  integer(DWORD) dwTimeAdjustment ! DWORD dwTimeAdjustment
  integer(BOOL) bTimeAdjustmentDisabled ! BOOL bTimeAdjustmentDisabled
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetSystemTimeAdjustment( &
        lpTimeAdjustment, &
        lpTimeIncrement, &
        lpTimeAdjustmentDisabled)
USE DFWINTY
  integer(BOOL) :: GetSystemTimeAdjustment ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemTimeAdjustment' :: GetSystemTimeAdjustment
  integer(LPDWORD) lpTimeAdjustment ! PDWORD lpTimeAdjustment
  integer(LPDWORD) lpTimeIncrement ! PDWORD lpTimeIncrement
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpTimeAdjustmentDisabled
  integer(BOOL) lpTimeAdjustmentDisabled ! PBOOL lpTimeAdjustmentDisabled
 END FUNCTION
END INTERFACE
INTERFACE FormatMessage
FUNCTION FormatMessage_G1( &
        dwFlags, &
        lpSource, &
        dwMessageId, &
        dwLanguageId, &
        lpBuffer, &
        nSize, &
        Arguments)
USE DFWINTY
  integer(DWORD) :: FormatMessage_G1 ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FormatMessageA' :: FormatMessage_G1
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPCVOID) lpSource ! LPCVOID lpSource
  integer(DWORD) dwMessageId ! DWORD dwMessageId
  integer(DWORD) dwLanguageId ! DWORD dwLanguageId
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(DWORD) nSize ! DWORD nSize
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: Arguments
  TYPE(T_VA_LIST) Arguments ! va_list* Arguments
 END FUNCTION
FUNCTION FormatMessage_G2( &
        dwFlags, &
        lpSource, &
        dwMessageId, &
        dwLanguageId, &
        lpBuffer, &
        nSize, &
        Arguments)
USE DFWINTY
  integer(DWORD) :: FormatMessage_G2 ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FormatMessageA' :: FormatMessage_G2
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPCVOID) lpSource ! LPCVOID lpSource
  integer(DWORD) dwMessageId ! DWORD dwMessageId
  integer(DWORD) dwLanguageId ! DWORD dwLanguageId
  integer(LPVOID) lpBuffer ! LPSTR lpBuffer
  integer(DWORD) nSize ! DWORD nSize
  integer(LPVOID) Arguments ! va_list* Arguments
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreatePipe( &
        hReadPipe, &
        hWritePipe, &
        lpPipeAttributes, &
        nSize)
USE DFWINTY
  integer(BOOL) :: CreatePipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreatePipe' :: CreatePipe
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: hReadPipe
  integer(HANDLE) hReadPipe ! PHANDLE hReadPipe
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: hWritePipe
  integer(HANDLE) hWritePipe ! PHANDLE hWritePipe
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpPipeAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpPipeAttributes ! LPSECURITY_ATTRIBUTES lpPipeAttributes
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ConnectNamedPipe( &
        hNamedPipe, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: ConnectNamedPipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ConnectNamedPipe' :: ConnectNamedPipe
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DisconnectNamedPipe( &
        hNamedPipe)
USE DFWINTY
  integer(BOOL) :: DisconnectNamedPipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DisconnectNamedPipe' :: DisconnectNamedPipe
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetNamedPipeHandleState( &
        hNamedPipe, &
        lpMode, &
        lpMaxCollectionCount, &
        lpCollectDataTimeout)
USE DFWINTY
  integer(BOOL) :: SetNamedPipeHandleState ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetNamedPipeHandleState' :: SetNamedPipeHandleState
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
  integer(LPDWORD) lpMode ! LPDWORD lpMode
  integer(LPDWORD) lpMaxCollectionCount ! LPDWORD lpMaxCollectionCount
  integer(LPDWORD) lpCollectDataTimeout ! LPDWORD lpCollectDataTimeout
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetNamedPipeInfo( &
        hNamedPipe, &
        lpFlags, &
        lpOutBufferSize, &
        lpInBufferSize, &
        lpMaxInstances)
USE DFWINTY
  integer(BOOL) :: GetNamedPipeInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetNamedPipeInfo' :: GetNamedPipeInfo
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
  integer(LPDWORD) lpFlags ! LPDWORD lpFlags
  integer(LPDWORD) lpOutBufferSize ! LPDWORD lpOutBufferSize
  integer(LPDWORD) lpInBufferSize ! LPDWORD lpInBufferSize
  integer(LPDWORD) lpMaxInstances ! LPDWORD lpMaxInstances
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION PeekNamedPipe( &
        hNamedPipe, &
        lpBuffer, &
        nBufferSize, &
        lpBytesRead, &
        lpTotalBytesAvail, &
        lpBytesLeftThisMessage)
USE DFWINTY
  integer(BOOL) :: PeekNamedPipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'PeekNamedPipe' :: PeekNamedPipe
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(DWORD) nBufferSize ! DWORD nBufferSize
  integer(LPDWORD) lpBytesRead ! LPDWORD lpBytesRead
  integer(LPDWORD) lpTotalBytesAvail ! LPDWORD lpTotalBytesAvail
  integer(LPDWORD) lpBytesLeftThisMessage ! LPDWORD lpBytesLeftThisMessage
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TransactNamedPipe( &
        hNamedPipe, &
        lpInBuffer, &
        nInBufferSize, &
        lpOutBuffer, &
        nOutBufferSize, &
        lpBytesRead, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: TransactNamedPipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TransactNamedPipe' :: TransactNamedPipe
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
  integer(LPVOID) lpInBuffer ! LPVOID lpInBuffer
  integer(DWORD) nInBufferSize ! DWORD nInBufferSize
  integer(LPVOID) lpOutBuffer ! LPVOID lpOutBuffer
  integer(DWORD) nOutBufferSize ! DWORD nOutBufferSize
  integer(LPDWORD) lpBytesRead ! LPDWORD lpBytesRead
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateMailslot( &
        lpName, &
        nMaxMessageSize, &
        lReadTimeout, &
        lpSecurityAttributes)
USE DFWINTY
  integer(HANDLE) :: CreateMailslot ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateMailslotA' :: CreateMailslot
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
  integer(DWORD) nMaxMessageSize ! DWORD nMaxMessageSize
  integer(DWORD) lReadTimeout ! DWORD lReadTimeout
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSecurityAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSecurityAttributes ! LPSECURITY_ATTRIBUTES lpSecurityAttributes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetMailslotInfo( &
        hMailslot, &
        lpMaxMessageSize, &
        lpNextSize, &
        lpMessageCount, &
        lpReadTimeout)
USE DFWINTY
  integer(BOOL) :: GetMailslotInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetMailslotInfo' :: GetMailslotInfo
  integer(HANDLE) hMailslot ! HANDLE hMailslot
  integer(LPDWORD) lpMaxMessageSize ! LPDWORD lpMaxMessageSize
  integer(LPDWORD) lpNextSize ! LPDWORD lpNextSize
  integer(LPDWORD) lpMessageCount ! LPDWORD lpMessageCount
  integer(LPDWORD) lpReadTimeout ! LPDWORD lpReadTimeout
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetMailslotInfo( &
        hMailslot, &
        lReadTimeout)
USE DFWINTY
  integer(BOOL) :: SetMailslotInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetMailslotInfo' :: SetMailslotInfo
  integer(HANDLE) hMailslot ! HANDLE hMailslot
  integer(DWORD) lReadTimeout ! DWORD lReadTimeout
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION MapViewOfFile( &
        hFileMappingObject, &
        dwDesiredAccess, &
        dwFileOffsetHigh, &
        dwFileOffsetLow, &
        dwNumberOfBytesToMap)
USE DFWINTY
  integer(LPVOID) :: MapViewOfFile ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'MapViewOfFile' :: MapViewOfFile
  integer(HANDLE) hFileMappingObject ! HANDLE hFileMappingObject
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(DWORD) dwFileOffsetHigh ! DWORD dwFileOffsetHigh
  integer(DWORD) dwFileOffsetLow ! DWORD dwFileOffsetLow
  integer(SIZE_T) dwNumberOfBytesToMap ! SIZE_T dwNumberOfBytesToMap
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FlushViewOfFile( &
        lpBaseAddress, &
        dwNumberOfBytesToFlush)
USE DFWINTY
  integer(BOOL) :: FlushViewOfFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FlushViewOfFile' :: FlushViewOfFile
  integer(LPCVOID) lpBaseAddress ! LPCVOID lpBaseAddress
  integer(SIZE_T) dwNumberOfBytesToFlush ! SIZE_T dwNumberOfBytesToFlush
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION UnmapViewOfFile( &
        lpBaseAddress)
USE DFWINTY
  integer(BOOL) :: UnmapViewOfFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'UnmapViewOfFile' :: UnmapViewOfFile
  integer(LPCVOID) lpBaseAddress ! LPCVOID lpBaseAddress
 END FUNCTION
END INTERFACE
!>>>>>>wrc start 01-25-01
INTERFACE lstrcmp 
FUNCTION lstrcmp_G1( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(SINT) :: lstrcmp_G1 ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcmpA' :: lstrcmp_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString1
  character*(*) lpString1 ! LPCSTR lpString1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString2
  character*(*) lpString2 ! LPCSTR lpString2
 END FUNCTION
FUNCTION lstrcmp_G2( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(SINT) :: lstrcmp_G2 ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcmpA' :: lstrcmp_G2
  integer(LPCSTR) lpString1 ! LPCSTR lpString1
  integer(LPCSTR) lpString2 ! LPCSTR lpString2
 END FUNCTION
END INTERFACE
INTERFACE lstrcmpi
FUNCTION lstrcmpi_G1( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(SINT) :: lstrcmpi_G1 ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcmpiA' :: lstrcmpi_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString1
  character*(*) lpString1 ! LPCSTR lpString1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString2
  character*(*) lpString2 ! LPCSTR lpString2
 END FUNCTION
FUNCTION lstrcmpi_G2( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(SINT) :: lstrcmpi_G2 ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcmpiA' :: lstrcmpi_G2
  integer(LPCSTR) lpString1 ! LPCSTR lpString1
  integer(LPCSTR) lpString2 ! LPCSTR lpString2
 END FUNCTION
END INTERFACE
INTERFACE lstrcpyn
 
FUNCTION lstrcpyn_G1( &
        lpString1, &
        lpString2, &
        iMaxLength)
USE DFWINTY
  integer(LPSTR) :: lstrcpyn_G1 ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcpynA' :: lstrcpyn_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString1
  character*(*) lpString1 ! LPSTR lpString1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString2
  character*(*) lpString2 ! LPCSTR lpString2
  integer(SINT) iMaxLength ! int iMaxLength
 END FUNCTION
FUNCTION lstrcpyn_G2( &
        lpString1, &
        lpString2, &
        iMaxLength)
USE DFWINTY
  integer(LPSTR) :: lstrcpyn_G2 ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcpynA' :: lstrcpyn_G2
  integer(LPSTR)  lpString1 ! LPSTR lpString1
  integer(LPCSTR) lpString2 ! LPCSTR lpString2
  integer(SINT) iMaxLength ! int iMaxLength
 END FUNCTION
END INTERFACE
INTERFACE lstrcpy 
FUNCTION lstrcpy_G1( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(LPSTR) :: lstrcpy_G1 ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcpyA' :: lstrcpy_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString1
  character*(*) lpString1 ! LPSTR lpString1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString2
  character*(*) lpString2 ! LPCSTR lpString2
 END FUNCTION
FUNCTION lstrcpy_G2( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(LPSTR) :: lstrcpy_G2 ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcpyA' :: lstrcpy_G2
  integer(LPSTR)  lpString1 ! LPSTR lpString1
  integer(LPCSTR) lpString2 ! LPCSTR lpString2
 END FUNCTION
END INTERFACE
INTERFACE lstrcat 
FUNCTION lstrcat_G1( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(LPSTR) :: lstrcat_G1 ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcatA' :: lstrcat_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString1
  character*(*) lpString1 ! LPSTR lpString1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString2
  character*(*) lpString2 ! LPCSTR lpString2
 END FUNCTION
FUNCTION lstrcat_G2( &
        lpString1, &
        lpString2)
USE DFWINTY
  integer(LPSTR) :: lstrcat_G2 ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrcatA' :: lstrcat_G2
  integer(LPSTR)  lpString1 ! LPSTR lpString1
  integer(LPCSTR) lpString2 ! LPCSTR lpString2
 END FUNCTION
END INTERFACE
INTERFACE lstrlen 
FUNCTION lstrlen_G1( &
        lpString)
USE DFWINTY
  integer(SINT) :: lstrlen_G1 ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrlenA' :: lstrlen_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
FUNCTION lstrlen_G2( &
        lpString)
USE DFWINTY
  integer(SINT) :: lstrlen_G2 ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'lstrlenA' :: lstrlen_G2
  integer(LPCSTR) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
!>>>>>wrc end 01-25-01
INTERFACE 
FUNCTION OpenFile( &
        lpFileName, &
        lpReOpenBuff, &
        uStyle)
USE DFWINTY
  integer(SINT) :: OpenFile ! HFILE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenFile' :: OpenFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpReOpenBuff
  TYPE (T_OFSTRUCT) lpReOpenBuff ! LPOFSTRUCT lpReOpenBuff
  integer(UINT) uStyle ! UINT uStyle
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION lopen( &
        lpPathName, &
        iReadWrite)
USE DFWINTY
  integer(SINT) :: lopen ! HFILE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_lopen' :: lopen
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
  integer(SINT) iReadWrite ! int iReadWrite
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION lcreat( &
        lpPathName, &
        iAttribute)
USE DFWINTY
  integer(SINT) :: lcreat ! HFILE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_lcreat' :: lcreat
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
  integer(SINT) iAttribute ! int iAttribute
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION lread( &
        hFile, &
        lpBuffer, &
        uBytes)
USE DFWINTY
  integer(UINT) :: lread ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_lread' :: lread
  integer(SINT) hFile ! HFILE hFile
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(UINT) uBytes ! UINT uBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION lwrite( &
        hFile, &
        lpBuffer, &
        uBytes)
USE DFWINTY
  integer(UINT) :: lwrite ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_lwrite' :: lwrite
  integer(SINT) hFile ! HFILE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPCSTR lpBuffer
  integer(UINT) uBytes ! UINT uBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION hread( &
        hFile, &
        lpBuffer, &
        lBytes)
USE DFWINTY
  integer(LONG) :: hread ! long
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_hread' :: hread
  integer(SINT) hFile ! HFILE hFile
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(LONG) lBytes ! long lBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION hwrite( &
        hFile, &
        lpBuffer, &
        lBytes)
USE DFWINTY
  integer(LONG) :: hwrite ! long
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_hwrite' :: hwrite
  integer(SINT) hFile ! HFILE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPCSTR lpBuffer
  integer(LONG) lBytes ! long lBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION lclose( &
        hFile)
USE DFWINTY
  integer(SINT) :: lclose ! HFILE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_lclose' :: lclose
  integer(SINT) hFile ! HFILE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION llseek( &
        hFile, &
        lOffset, &
        iOrigin)
USE DFWINTY
  integer(LONG) :: llseek ! LONG
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'_llseek' :: llseek
  integer(SINT) hFile ! HFILE hFile
  integer(LONG) lOffset ! LONG lOffset
  integer(SINT) iOrigin ! int iOrigin
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TlsAlloc( &
             )
USE DFWINTY
  integer(DWORD) :: TlsAlloc ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TlsAlloc' :: TlsAlloc
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TlsGetValue( &
        dwTlsIndex)
USE DFWINTY
  integer(LPVOID) :: TlsGetValue ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TlsGetValue' :: TlsGetValue
  integer(DWORD) dwTlsIndex ! DWORD dwTlsIndex
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TlsSetValue( &
        dwTlsIndex, &
        lpTlsValue)
USE DFWINTY
  integer(BOOL) :: TlsSetValue ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TlsSetValue' :: TlsSetValue
  integer(DWORD) dwTlsIndex ! DWORD dwTlsIndex
  integer(LPVOID) lpTlsValue ! LPVOID lpTlsValue
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION TlsFree( &
        dwTlsIndex)
USE DFWINTY
  integer(BOOL) :: TlsFree ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'TlsFree' :: TlsFree
  integer(DWORD) dwTlsIndex ! DWORD dwTlsIndex
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SleepEx( &
        dwMilliseconds, &
        bAlertable)
USE DFWINTY
  integer(DWORD) :: SleepEx ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SleepEx' :: SleepEx
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
  integer(BOOL) bAlertable ! BOOL bAlertable
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WaitForSingleObjectEx( &
        hHandle, &
        dwMilliseconds, &
        bAlertable)
USE DFWINTY
  integer(DWORD) :: WaitForSingleObjectEx ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitForSingleObjectEx' :: WaitForSingleObjectEx
  integer(HANDLE) hHandle ! HANDLE hHandle
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
  integer(BOOL) bAlertable ! BOOL bAlertable
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WaitForMultipleObjectsEx( &
        nCount, &
        lpHandles, &
        bWaitAll, &
        dwMilliseconds, &
        bAlertable)
USE DFWINTY
  integer(DWORD) :: WaitForMultipleObjectsEx ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitForMultipleObjectsEx' :: WaitForMultipleObjectsEx
  integer(DWORD) nCount ! DWORD nCount
  integer(PHANDLE) lpHandles ! HANDLE* lpHandles
  integer(BOOL) bWaitAll ! BOOL bWaitAll
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
  integer(BOOL) bAlertable ! BOOL bAlertable
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION SignalObjectAndWait( &
        hObjectToSignal, &
        hObjectToWaitOn, &
        dwMilliseconds, &
        bAlertable)
USE DFWINTY
  integer(DWORD) :: SignalObjectAndWait ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SignalObjectAndWait' :: SignalObjectAndWait
  integer(HANDLE) hObjectToSignal ! HANDLE hObjectToSignal
  integer(HANDLE) hObjectToWaitOn ! HANDLE hObjectToWaitOn
  integer(DWORD) dwMilliseconds ! DWORD dwMilliseconds
  integer(BOOL) bAlertable ! BOOL bAlertable
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION ReadFileEx( &
        hFile, &
        lpBuffer, &
        nNumberOfBytesToRead, &
        lpOverlapped, &
        lpCompletionRoutine)
USE DFWINTY
  integer(BOOL) :: ReadFileEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadFileEx' :: ReadFileEx
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(DWORD) nNumberOfBytesToRead ! DWORD nNumberOfBytesToRead
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
  integer(LPVOID) lpCompletionRoutine ! LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteFileEx( &
        hFile, &
        lpBuffer, &
        nNumberOfBytesToWrite, &
        lpOverlapped, &
        lpCompletionRoutine)
USE DFWINTY
  integer(BOOL) :: WriteFileEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteFileEx' :: WriteFileEx
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPCVOID) lpBuffer ! LPCVOID lpBuffer
  integer(DWORD) nNumberOfBytesToWrite ! DWORD nNumberOfBytesToWrite
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
  integer(LPVOID) lpCompletionRoutine ! LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION BackupRead( &
        hFile, &
        lpBuffer, &
        nNumberOfBytesToRead, &
        lpNumberOfBytesRead, &
        bAbort, &
        bProcessSecurity, &
        lpContext)
USE DFWINTY
  integer(BOOL) :: BackupRead ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'BackupRead' :: BackupRead
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPBYTE) lpBuffer ! LPBYTE lpBuffer
  integer(DWORD) nNumberOfBytesToRead ! DWORD nNumberOfBytesToRead
  integer(LPDWORD) lpNumberOfBytesRead ! LPDWORD lpNumberOfBytesRead
  integer(BOOL) bAbort ! BOOL bAbort
  integer(BOOL) bProcessSecurity ! BOOL bProcessSecurity
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpContext
  integer(LPVOID) lpContext ! LPVOID* lpContext
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION BackupSeek( &
        hFile, &
        dwLowBytesToSeek, &
        dwHighBytesToSeek, &
        lpdwLowByteSeeked, &
        lpdwHighByteSeeked, &
        lpContext)
USE DFWINTY
  integer(BOOL) :: BackupSeek ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'BackupSeek' :: BackupSeek
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwLowBytesToSeek ! DWORD dwLowBytesToSeek
  integer(DWORD) dwHighBytesToSeek ! DWORD dwHighBytesToSeek
  integer(LPDWORD) lpdwLowByteSeeked ! LPDWORD lpdwLowByteSeeked
  integer(LPDWORD) lpdwHighByteSeeked ! LPDWORD lpdwHighByteSeeked
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpContext
  integer(LPVOID) lpContext ! LPVOID* lpContext
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION BackupWrite( &
        hFile, &
        lpBuffer, &
        nNumberOfBytesToWrite, &
        lpNumberOfBytesWritten, &
        bAbort, &
        bProcessSecurity, &
        lpContext)
USE DFWINTY
  integer(BOOL) :: BackupWrite ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'BackupWrite' :: BackupWrite
  integer(HANDLE) hFile ! HANDLE hFile
  integer(LPBYTE) lpBuffer ! LPBYTE lpBuffer
  integer(DWORD) nNumberOfBytesToWrite ! DWORD nNumberOfBytesToWrite
  integer(LPDWORD) lpNumberOfBytesWritten ! LPDWORD lpNumberOfBytesWritten
  integer(BOOL) bAbort ! BOOL bAbort
  integer(BOOL) bProcessSecurity ! BOOL bProcessSecurity
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpContext
  integer(LPVOID) lpContext ! LPVOID* lpContext
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadFileScatter( &
        hFile, &
        aSegmentArray, &
        nNumberOfBytesToRead, &
        lpReserved, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: ReadFileScatter ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadFileScatter' :: ReadFileScatter
  integer(HANDLE) hFile ! HANDLE hFile
  TYPE (T_FILE_SEGMENT_ELEMENT) aSegmentArray(*) ! FILE_SEGMENT_ELEMENT aSegmentArray[]
!  integer(LPVOID) aSegmentArray ! take loc(actual arg) 
  integer(DWORD) nNumberOfBytesToRead ! DWORD nNumberOfBytesToRead
  integer(LPDWORD) lpReserved ! LPDWORD lpReserved
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteFileGather( &
        hFile, &
        aSegmentArray, &
        nNumberOfBytesToWrite, &
        lpReserved, &
        lpOverlapped)
USE DFWINTY
  integer(BOOL) :: WriteFileGather ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteFileGather' :: WriteFileGather
  integer(HANDLE) hFile ! HANDLE hFile
  TYPE (T_FILE_SEGMENT_ELEMENT) aSegmentArray(*) ! FILE_SEGMENT_ELEMENT aSegmentArray[]
!  integer(LPVOID) aSegmentArray ! use loc(actual arg) 
  integer(DWORD) nNumberOfBytesToWrite ! DWORD nNumberOfBytesToWrite
  integer(LPDWORD) lpReserved ! LPDWORD lpReserved
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOverlapped
  TYPE (T_OVERLAPPED) lpOverlapped ! LPOVERLAPPED lpOverlapped
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateMutex( &
        lpMutexAttributes, &
        bInitialOwner, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: CreateMutex ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateMutexA' :: CreateMutex
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpMutexAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpMutexAttributes ! LPSECURITY_ATTRIBUTES lpMutexAttributes
  integer(BOOL) bInitialOwner ! BOOL bInitialOwner
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenMutex( &
        dwDesiredAccess, &
        bInheritHandle, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: OpenMutex ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenMutexA' :: OpenMutex
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateEvent( &
        lpEventAttributes, &
        bManualReset, &
        bInitialState, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: CreateEvent ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateEventA' :: CreateEvent
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpEventAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpEventAttributes ! LPSECURITY_ATTRIBUTES lpEventAttributes
  integer(BOOL) bManualReset ! BOOL bManualReset
  integer(BOOL) bInitialState ! BOOL bInitialState
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenEvent( &
        dwDesiredAccess, &
        bInheritHandle, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: OpenEvent ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenEventA' :: OpenEvent
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateSemaphore( &
        lpSemaphoreAttributes, &
        lInitialCount, &
        lMaximumCount, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: CreateSemaphore ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateSemaphoreA' :: CreateSemaphore
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSemaphoreAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSemaphoreAttributes ! LPSECURITY_ATTRIBUTES lpSemaphoreAttributes
  integer(LONG) lInitialCount ! LONG lInitialCount
  integer(LONG) lMaximumCount ! LONG lMaximumCount
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenSemaphore( &
        dwDesiredAccess, &
        bInheritHandle, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: OpenSemaphore ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenSemaphoreA' :: OpenSemaphore
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION CreateWaitableTimer( &
        lpTimerAttributes, &
        bManualReset, &
        lpTimerName)
USE DFWINTY
  integer(HANDLE) :: CreateWaitableTimer ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateWaitableTimerA' :: CreateWaitableTimer
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimerAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpTimerAttributes ! LPSECURITY_ATTRIBUTES lpTimerAttributes
  integer(BOOL) bManualReset ! BOOL bManualReset
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimerName
  character*(*) lpTimerName ! LPCSTR lpTimerName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenWaitableTimer( &
        dwDesiredAccess, &
        bInheritHandle, &
        lpTimerName)
USE DFWINTY
  integer(HANDLE) :: OpenWaitableTimer ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenWaitableTimerA' :: OpenWaitableTimer
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimerName
  character*(*) lpTimerName ! LPCSTR lpTimerName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetWaitableTimer( &
        hTimer, &
        lpDueTime, &
        lPeriod, &
        pfnCompletionRoutine, &
        lpArgToCompletionRoutine, &
        fResume)
USE DFWINTY
  integer(BOOL) :: SetWaitableTimer ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetWaitableTimer' :: SetWaitableTimer
  integer(HANDLE) hTimer ! HANDLE hTimer
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDueTime
  TYPE (T_LARGE_INTEGER) lpDueTime ! LARGE_INTEGER* lpDueTime
  integer(LONG) lPeriod ! LONG lPeriod
  integer(PVOID) pfnCompletionRoutine ! PTIMERAPCROUTINE pfnCompletionRoutine
  integer(LPVOID) lpArgToCompletionRoutine ! LPVOID lpArgToCompletionRoutine
  integer(BOOL) fResume ! BOOL fResume
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CancelWaitableTimer( &
        hTimer)
USE DFWINTY
  integer(BOOL) :: CancelWaitableTimer ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CancelWaitableTimer' :: CancelWaitableTimer
  integer(HANDLE) hTimer ! HANDLE hTimer
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION CreateFileMapping( &
        hFile, &
        lpFileMappingAttributes, &
        flProtect, &
        dwMaximumSizeHigh, &
        dwMaximumSizeLow, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: CreateFileMapping ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateFileMappingA' :: CreateFileMapping
  integer(HANDLE) hFile ! HANDLE hFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileMappingAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpFileMappingAttributes ! LPSECURITY_ATTRIBUTES lpFileMappingAttributes
  integer(DWORD) flProtect ! DWORD flProtect
  integer(DWORD) dwMaximumSizeHigh ! DWORD dwMaximumSizeHigh
  integer(DWORD) dwMaximumSizeLow ! DWORD dwMaximumSizeLow
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION OpenFileMapping( &
        dwDesiredAccess, &
        bInheritHandle, &
        lpName)
USE DFWINTY
  integer(HANDLE) :: OpenFileMapping ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OpenFileMappingA' :: OpenFileMapping
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(BOOL) bInheritHandle ! BOOL bInheritHandle
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetLogicalDriveStrings( &
        nBufferLength, &
        lpBuffer)
USE DFWINTY
  integer(DWORD) :: GetLogicalDriveStrings ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLogicalDriveStringsA' :: GetLogicalDriveStrings
  integer(DWORD) nBufferLength ! DWORD nBufferLength
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LoadLibrary( &
        lpLibFileName)
USE DFWINTY
  integer(HANDLE) :: LoadLibrary ! HMODULE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LoadLibraryA' :: LoadLibrary
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLibFileName
  character*(*) lpLibFileName ! LPCSTR lpLibFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LoadLibraryEx( &
        lpLibFileName, &
        hFile, &
        dwFlags)
USE DFWINTY
  integer(HANDLE) :: LoadLibraryEx ! HMODULE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LoadLibraryExA' :: LoadLibraryEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLibFileName
  character*(*) lpLibFileName ! LPCSTR lpLibFileName
  integer(HANDLE) hFile ! HANDLE hFile
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetModuleFileName( &
        hModule, &
        lpFilename, &
        nSize)
USE DFWINTY
  integer(DWORD) :: GetModuleFileName ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetModuleFileNameA' :: GetModuleFileName
  integer(HANDLE) hModule ! HMODULE hModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFilename
  character*(*) lpFilename ! LPSTR lpFilename
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetModuleHandle( &
        lpModuleName)
USE DFWINTY
  integer(HANDLE) :: GetModuleHandle ! HMODULE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetModuleHandleA' :: GetModuleHandle
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpModuleName
  character*(*) lpModuleName ! LPCSTR lpModuleName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateProcess( &
        lpApplicationName, &
        lpCommandLine, &
        lpProcessAttributes, &
        lpThreadAttributes, &
        bInheritHandles, &
        dwCreationFlags, &
        lpEnvironment, &
        lpCurrentDirectory, &
        lpStartupInfo, &
        lpProcessInformation)
USE DFWINTY
  integer(BOOL) :: CreateProcess ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateProcessA' :: CreateProcess
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpApplicationName
  character*(*) lpApplicationName ! LPCSTR lpApplicationName
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCommandLine
  character*(*) lpCommandLine ! LPSTR lpCommandLine
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpProcessAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpProcessAttributes ! LPSECURITY_ATTRIBUTES lpProcessAttributes
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpThreadAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpThreadAttributes ! LPSECURITY_ATTRIBUTES lpThreadAttributes
  integer(BOOL) bInheritHandles ! BOOL bInheritHandles
  integer(DWORD) dwCreationFlags ! DWORD dwCreationFlags
  integer(LPVOID) lpEnvironment ! LPVOID lpEnvironment
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCurrentDirectory
  character*(*) lpCurrentDirectory ! LPCSTR lpCurrentDirectory
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpStartupInfo
  TYPE (T_STARTUPINFO) lpStartupInfo ! LPSTARTUPINFOA lpStartupInfo
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpProcessInformation
  TYPE (T_PROCESS_INFORMATION) lpProcessInformation ! LPPROCESS_INFORMATION lpProcessInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetProcessShutdownParameters( &
        dwLevel, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: SetProcessShutdownParameters ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetProcessShutdownParameters' :: SetProcessShutdownParameters
  integer(DWORD) dwLevel ! DWORD dwLevel
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessShutdownParameters( &
        lpdwLevel, &
        lpdwFlags)
USE DFWINTY
  integer(BOOL) :: GetProcessShutdownParameters ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessShutdownParameters' :: GetProcessShutdownParameters
  integer(LPDWORD) lpdwLevel ! LPDWORD lpdwLevel
  integer(LPDWORD) lpdwFlags ! LPDWORD lpdwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProcessVersion( &
        ProcessId)
USE DFWINTY
  integer(DWORD) :: GetProcessVersion ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProcessVersion' :: GetProcessVersion
  integer(DWORD) ProcessId ! DWORD ProcessId
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE FatalAppExit( &
        uAction, &
        lpMessageText)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FatalAppExitA' :: FatalAppExit
  integer(UINT) uAction ! UINT uAction
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpMessageText
  character*(*) lpMessageText ! LPCSTR lpMessageText
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE GetStartupInfo( &
        lpStartupInfo)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetStartupInfoA' :: GetStartupInfo
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpStartupInfo
  TYPE (T_STARTUPINFO) lpStartupInfo ! LPSTARTUPINFOA lpStartupInfo
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION GetCommandLine( &
             )
USE DFWINTY
  integer(LPSTR) :: GetCommandLine ! LPSTR
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCommandLineA' :: GetCommandLine
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetEnvironmentVariable( &
        lpName, &
        lpBuffer, &
        nSize)
USE DFWINTY
  integer(DWORD) :: GetEnvironmentVariable ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetEnvironmentVariableA' :: GetEnvironmentVariable
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetEnvironmentVariable( &
        lpName, &
        lpValue)
USE DFWINTY
  integer(BOOL) :: SetEnvironmentVariable ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetEnvironmentVariableA' :: SetEnvironmentVariable
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpValue
  character*(*) lpValue ! LPCSTR lpValue
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ExpandEnvironmentStrings( &
        lpSrc, &
        lpDst, &
        nSize)
USE DFWINTY
  integer(DWORD) :: ExpandEnvironmentStrings ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ExpandEnvironmentStringsA' :: ExpandEnvironmentStrings
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSrc
  character*(*) lpSrc ! LPCSTR lpSrc
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDst
  character*(*) lpDst ! LPSTR lpDst
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE OutputDebugString( &
        lpOutputString)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'OutputDebugStringA' :: OutputDebugString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpOutputString
  character*(*) lpOutputString ! LPCSTR lpOutputString
 END SUBROUTINE
END INTERFACE
INTERFACE FindResource
FUNCTION FindResource_G1( &
        hModule, &
        lpName, &
        lpType)
USE DFWINTY
  integer(HANDLE) :: FindResource_G1 ! HRSRC
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindResourceA' :: FindResource_G1
  integer(HANDLE) hModule ! HMODULE hModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpType
  character*(*) lpType ! LPCSTR lpType
 END FUNCTION
FUNCTION FindResource_G2( &
        hModule, &
        lpName, &
        lpType)
USE DFWINTY
  integer(HANDLE) :: FindResource_G2 ! HRSRC
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindResourceA' :: FindResource_G2
  integer(HANDLE) hModule ! HMODULE hModule
  integer(LPVOID) lpName ! LPCSTR lpName
  integer(LPVOID) lpType ! LPCSTR lpType
 END FUNCTION
END INTERFACE
INTERFACE FindResourceEx
FUNCTION FindResourceEx_G1( &
        hModule, &
        lpType, &
        lpName, &
        wLanguage)
USE DFWINTY
  integer(HANDLE) :: FindResourceEx_G1 ! HRSRC
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindResourceExA' :: FindResourceEx_G1
  integer(HANDLE) hModule ! HMODULE hModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpType
  character*(*) lpType ! LPCSTR lpType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
  integer(WORD) wLanguage ! WORD wLanguage
 END FUNCTION
FUNCTION FindResourceEx_G2( &
        hModule, &
        lpType, &
        lpName, &
        wLanguage)
USE DFWINTY
  integer(HANDLE) :: FindResourceEx_G2 ! HRSRC
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindResourceExA' :: FindResourceEx_G2
  integer(HANDLE) hModule ! HMODULE hModule
  integer(LPVOID) lpType ! LPCSTR lpType
  integer(LPVOID) lpName ! LPCSTR lpName
  integer(WORD) wLanguage ! WORD wLanguage
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EnumResourceTypes( &
        hModule, &
        lpEnumFunc, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumResourceTypes ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumResourceTypesA' :: EnumResourceTypes
  integer(HANDLE) hModule ! HMODULE hModule
  integer(LPVOID) lpEnumFunc ! ENUMRESTYPEPROCA lpEnumFunc
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
END INTERFACE
INTERFACE EnumResourceNames
FUNCTION EnumResourceNames_G1( &
        hModule, &
        lpType, &
        lpEnumFunc, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumResourceNames_G1 ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumResourceNamesA' :: EnumResourceNames_G1
  integer(HANDLE) hModule ! HMODULE hModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpType
  character*(*) lpType ! LPCSTR lpType
  integer(LPVOID) lpEnumFunc ! ENUMRESNAMEPROCA lpEnumFunc
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
FUNCTION EnumResourceNames_G2( &
        hModule, &
        lpType, &
        lpEnumFunc, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumResourceNames_G2 ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumResourceNamesA' :: EnumResourceNames_G2
  integer(HANDLE) hModule ! HMODULE hModule
  integer(LPVOID) lpType ! LPCSTR lpType
  integer(LPVOID) lpEnumFunc ! ENUMRESNAMEPROCA lpEnumFunc
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
END INTERFACE
INTERFACE EnumResourceLanguages
FUNCTION EnumResourceLanguages_G1( &
        hModule, &
        lpType, &
        lpName, &
        lpEnumFunc, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumResourceLanguages_G1 ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumResourceLanguagesA' :: EnumResourceLanguages_G1
  integer(HANDLE) hModule ! HMODULE hModule
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpType
  character*(*) lpType ! LPCSTR lpType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
  integer(LPVOID) lpEnumFunc ! ENUMRESLANGPROCA lpEnumFunc
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
FUNCTION EnumResourceLanguages_G2( &
        hModule, &
        lpType, &
        lpName, &
        lpEnumFunc, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumResourceLanguages_G2 ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumResourceLanguagesA' :: EnumResourceLanguages_G2
  integer(HANDLE) hModule ! HMODULE hModule
  integer(LPVOID) lpType ! LPCSTR lpType
  integer(LPVOID) lpName ! LPCSTR lpName
  integer(LPVOID) lpEnumFunc ! ENUMRESLANGPROCA lpEnumFunc
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION BeginUpdateResource( &
        pFileName, &
        bDeleteExistingResources)
USE DFWINTY
  integer(HANDLE) :: BeginUpdateResource ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'BeginUpdateResourceA' :: BeginUpdateResource
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: pFileName
  character*(*) pFileName ! LPCSTR pFileName
  integer(BOOL) bDeleteExistingResources ! BOOL bDeleteExistingResources
 END FUNCTION
END INTERFACE
INTERFACE UpdateResource
FUNCTION UpdateResource_G1( &
        hUpdate, &
        lpType, &
        lpName, &
        wLanguage, &
        lpData, &
        cbData)
USE DFWINTY
  integer(BOOL) :: UpdateResource_G1 ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'UpdateResourceA' :: UpdateResource_G1
  integer(HANDLE) hUpdate ! HANDLE hUpdate
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpType
  character*(*) lpType ! LPCSTR lpType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
  integer(WORD) wLanguage ! WORD wLanguage
  integer(LPVOID) lpData ! LPVOID lpData
  integer(DWORD) cbData ! DWORD cbData
 END FUNCTION
FUNCTION UpdateResource_G2( &
        hUpdate, &
        lpType, &
        lpName, &
        wLanguage, &
        lpData, &
        cbData)
USE DFWINTY
  integer(BOOL) :: UpdateResource_G2 ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'UpdateResourceA' :: UpdateResource_G2
  integer(HANDLE) hUpdate ! HANDLE hUpdate
  integer(LPVOID) lpType ! LPCSTR lpType
  integer(LPVOID) lpName ! LPCSTR lpName
  integer(WORD) wLanguage ! WORD wLanguage
  integer(LPVOID) lpData ! LPVOID lpData
  integer(DWORD) cbData ! DWORD cbData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EndUpdateResource( &
        hUpdate, &
        fDiscard)
USE DFWINTY
  integer(BOOL) :: EndUpdateResource ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EndUpdateResourceA' :: EndUpdateResource
  integer(HANDLE) hUpdate ! HANDLE hUpdate
  integer(BOOL) fDiscard ! BOOL fDiscard
 END FUNCTION
END INTERFACE
INTERFACE GlobalAddAtom
FUNCTION GlobalAddAtom_G1( &
        lpString)
USE DFWINTY
  integer(USHORT) :: GlobalAddAtom_G1 ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalAddAtomA' :: GlobalAddAtom_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
FUNCTION GlobalAddAtom_G2( &
        lpString)
USE DFWINTY
  integer(USHORT) :: GlobalAddAtom_G2 ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalAddAtomA' :: GlobalAddAtom_G2
  integer(LPVOID) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalFindAtom( &
        lpString)
USE DFWINTY
  integer(USHORT) :: GlobalFindAtom ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalFindAtomA' :: GlobalFindAtom
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GlobalGetAtomName( &
        nAtom, &
        lpBuffer, &
        nSize)
USE DFWINTY
  integer(UINT) :: GlobalGetAtomName ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GlobalGetAtomNameA' :: GlobalGetAtomName
  integer(USHORT) nAtom ! ATOM nAtom
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(SINT) nSize ! int nSize
 END FUNCTION
END INTERFACE
INTERFACE AddAtom
FUNCTION AddAtom_G1( &
        lpString)
USE DFWINTY
  integer(USHORT) :: AddAtom_G1 ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'AddAtomA' :: AddAtom_G1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
FUNCTION AddAtom_G2( &
        lpString)
USE DFWINTY
  integer(USHORT) :: AddAtom_G2 ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'AddAtomA' :: AddAtom_G2
  integer(LPVOID) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FindAtom( &
        lpString)
USE DFWINTY
  integer(USHORT) :: FindAtom ! ATOM
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindAtomA' :: FindAtom
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetAtomName( &
        nAtom, &
        lpBuffer, &
        nSize)
USE DFWINTY
  integer(UINT) :: GetAtomName ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetAtomNameA' :: GetAtomName
  integer(USHORT) nAtom ! ATOM nAtom
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(SINT) nSize ! int nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProfileInt( &
        lpAppName, &
        lpKeyName, &
        nDefault)
USE DFWINTY
  integer(UINT) :: GetProfileInt ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProfileIntA' :: GetProfileInt
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKeyName
  character*(*) lpKeyName ! LPCSTR lpKeyName
  integer(SINT) nDefault ! INT nDefault
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProfileString( &
        lpAppName, &
        lpKeyName, &
        lpDefault, &
        lpReturnedString, &
        nSize)
USE DFWINTY
  integer(DWORD) :: GetProfileString ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProfileStringA' :: GetProfileString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKeyName
  character*(*) lpKeyName ! LPCSTR lpKeyName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDefault
  character*(*) lpDefault ! LPCSTR lpDefault
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpReturnedString
  character*(*) lpReturnedString ! LPSTR lpReturnedString
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteProfileString( &
        lpAppName, &
        lpKeyName, &
        lpString)
USE DFWINTY
  integer(BOOL) :: WriteProfileString ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteProfileStringA' :: WriteProfileString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKeyName
  character*(*) lpKeyName ! LPCSTR lpKeyName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetProfileSection( &
        lpAppName, &
        lpReturnedString, &
        nSize)
USE DFWINTY
  integer(DWORD) :: GetProfileSection ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetProfileSectionA' :: GetProfileSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpReturnedString
  character*(*) lpReturnedString ! LPSTR lpReturnedString
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteProfileSection( &
        lpAppName, &
        lpString)
USE DFWINTY
  integer(BOOL) :: WriteProfileSection ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteProfileSectionA' :: WriteProfileSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetPrivateProfileInt( &
        lpAppName, &
        lpKeyName, &
        nDefault, &
        lpFileName)
USE DFWINTY
  integer(UINT) :: GetPrivateProfileInt ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetPrivateProfileIntA' :: GetPrivateProfileInt
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKeyName
  character*(*) lpKeyName ! LPCSTR lpKeyName
  integer(SINT) nDefault ! INT nDefault
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetPrivateProfileString( &
        lpAppName, &
        lpKeyName, &
        lpDefault, &
        lpReturnedString, &
        nSize, &
        lpFileName)
USE DFWINTY
  integer(DWORD) :: GetPrivateProfileString ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetPrivateProfileStringA' :: GetPrivateProfileString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKeyName
  character*(*) lpKeyName ! LPCSTR lpKeyName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDefault
  character*(*) lpDefault ! LPCSTR lpDefault
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpReturnedString
  character*(*) lpReturnedString ! LPSTR lpReturnedString
  integer(DWORD) nSize ! DWORD nSize
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WritePrivateProfileString( &
        lpAppName, &
        lpKeyName, &
        lpString, &
        lpFileName)
USE DFWINTY
  integer(BOOL) :: WritePrivateProfileString ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WritePrivateProfileStringA' :: WritePrivateProfileString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpKeyName
  character*(*) lpKeyName ! LPCSTR lpKeyName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetPrivateProfileSection( &
        lpAppName, &
        lpReturnedString, &
        nSize, &
        lpFileName)
USE DFWINTY
  integer(DWORD) :: GetPrivateProfileSection ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetPrivateProfileSectionA' :: GetPrivateProfileSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpReturnedString
  character*(*) lpReturnedString ! LPSTR lpReturnedString
  integer(DWORD) nSize ! DWORD nSize
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WritePrivateProfileSection( &
        lpAppName, &
        lpString, &
        lpFileName)
USE DFWINTY
  integer(BOOL) :: WritePrivateProfileSection ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WritePrivateProfileSectionA' :: WritePrivateProfileSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpAppName
  character*(*) lpAppName ! LPCSTR lpAppName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString
  character*(*) lpString ! LPCSTR lpString
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetPrivateProfileSectionNames( &
        lpszReturnBuffer, &
        nSize, &
        lpFileName)
USE DFWINTY
  integer(DWORD) :: GetPrivateProfileSectionNames ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetPrivateProfileSectionNamesA' :: GetPrivateProfileSectionNames
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszReturnBuffer
  character*(*) lpszReturnBuffer ! LPSTR lpszReturnBuffer
  integer(DWORD) nSize ! DWORD nSize
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetPrivateProfileStruct( &
        lpszSection, &
        lpszKey, &
        lpStruct, &
        uSizeStruct, &
        szFile)
USE DFWINTY
  integer(BOOL) :: GetPrivateProfileStruct ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetPrivateProfileStructA' :: GetPrivateProfileStruct
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszSection
  character*(*) lpszSection ! LPCSTR lpszSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszKey
  character*(*) lpszKey ! LPCSTR lpszKey
  integer(LPVOID) lpStruct ! LPVOID lpStruct
  integer(UINT) uSizeStruct ! UINT uSizeStruct
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: szFile
  character*(*) szFile ! LPCSTR szFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WritePrivateProfileStruct( &
        lpszSection, &
        lpszKey, &
        lpStruct, &
        uSizeStruct, &
        szFile)
USE DFWINTY
  integer(BOOL) :: WritePrivateProfileStruct ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WritePrivateProfileStructA' :: WritePrivateProfileStruct
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszSection
  character*(*) lpszSection ! LPCSTR lpszSection
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpszKey
  character*(*) lpszKey ! LPCSTR lpszKey
  integer(LPVOID) lpStruct ! LPVOID lpStruct
  integer(UINT) uSizeStruct ! UINT uSizeStruct
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: szFile
  character*(*) szFile ! LPCSTR szFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetDriveType( &
        lpRootPathName)
USE DFWINTY
  integer(UINT) :: GetDriveType ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetDriveTypeA' :: GetDriveType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpRootPathName
  character*(*) lpRootPathName ! LPCSTR lpRootPathName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetSystemDirectory( &
        lpBuffer, &
        uSize)
USE DFWINTY
  integer(UINT) :: GetSystemDirectory ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemDirectoryA' :: GetSystemDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(UINT) uSize ! UINT uSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTempPath( &
        nBufferLength, &
        lpBuffer)
USE DFWINTY
  integer(DWORD) :: GetTempPath ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTempPathA' :: GetTempPath
  integer(DWORD) nBufferLength ! DWORD nBufferLength
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetTempFileName( &
        lpPathName, &
        lpPrefixString, &
        uUnique, &
        lpTempFileName)
USE DFWINTY
  integer(UINT) :: GetTempFileName ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTempFileNameA' :: GetTempFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPrefixString
  character*(*) lpPrefixString ! LPCSTR lpPrefixString
  integer(UINT) uUnique ! UINT uUnique
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTempFileName
  character*(*) lpTempFileName ! LPSTR lpTempFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetWindowsDirectory( &
        lpBuffer, &
        uSize)
USE DFWINTY
  integer(UINT) :: GetWindowsDirectory ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetWindowsDirectoryA' :: GetWindowsDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(UINT) uSize ! UINT uSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetSystemWindowsDirectory( &
        lpBuffer, &
        uSize)
USE DFWINTY
  integer(UINT) :: GetSystemWindowsDirectory ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemWindowsDirectoryA' :: GetSystemWindowsDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(UINT) uSize ! UINT uSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCurrentDirectory( &
        lpPathName)
USE DFWINTY
  integer(BOOL) :: SetCurrentDirectory ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCurrentDirectoryA' :: SetCurrentDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCurrentDirectory( &
        nBufferLength, &
        lpBuffer)
USE DFWINTY
  integer(DWORD) :: GetCurrentDirectory ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCurrentDirectoryA' :: GetCurrentDirectory
  integer(DWORD) nBufferLength ! DWORD nBufferLength
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetDiskFreeSpace( &
        lpRootPathName, &
        lpSectorsPerCluster, &
        lpBytesPerSector, &
        lpNumberOfFreeClusters, &
        lpTotalNumberOfClusters)
USE DFWINTY
  integer(BOOL) :: GetDiskFreeSpace ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetDiskFreeSpaceA' :: GetDiskFreeSpace
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpRootPathName
  character*(*) lpRootPathName ! LPCSTR lpRootPathName
  integer(LPDWORD) lpSectorsPerCluster ! LPDWORD lpSectorsPerCluster
  integer(LPDWORD) lpBytesPerSector ! LPDWORD lpBytesPerSector
  integer(LPDWORD) lpNumberOfFreeClusters ! LPDWORD lpNumberOfFreeClusters
  integer(LPDWORD) lpTotalNumberOfClusters ! LPDWORD lpTotalNumberOfClusters
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetDiskFreeSpaceEx( &
        lpDirectoryName, &
        lpFreeBytesAvailableToCaller, &
        lpTotalNumberOfBytes, &
        lpTotalNumberOfFreeBytes)
USE DFWINTY
  integer(BOOL) :: GetDiskFreeSpaceEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetDiskFreeSpaceExA' :: GetDiskFreeSpaceEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDirectoryName
  character*(*) lpDirectoryName ! LPCSTR lpDirectoryName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFreeBytesAvailableToCaller
  TYPE(T_LARGE_INTEGER)  lpFreeBytesAvailableToCaller ! PULARGE_INTEGER lpFreeBytesAvailableToCaller
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTotalNumberOfBytes
  TYPE(T_LARGE_INTEGER)  lpTotalNumberOfBytes ! PULARGE_INTEGER lpTotalNumberOfBytes
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTotalNumberOfFreeBytes
  TYPE(T_LARGE_INTEGER) lpTotalNumberOfFreeBytes ! PULARGE_INTEGER lpTotalNumberOfFreeBytes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateDirectory( &
        lpPathName, &
        lpSecurityAttributes)
USE DFWINTY
  integer(BOOL) :: CreateDirectory ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateDirectoryA' :: CreateDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSecurityAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSecurityAttributes ! LPSECURITY_ATTRIBUTES lpSecurityAttributes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateDirectoryEx( &
        lpTemplateDirectory, &
        lpNewDirectory, &
        lpSecurityAttributes)
USE DFWINTY
  integer(BOOL) :: CreateDirectoryEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateDirectoryExA' :: CreateDirectoryEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTemplateDirectory
  character*(*) lpTemplateDirectory ! LPCSTR lpTemplateDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNewDirectory
  character*(*) lpNewDirectory ! LPCSTR lpNewDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSecurityAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSecurityAttributes ! LPSECURITY_ATTRIBUTES lpSecurityAttributes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION RemoveDirectory( &
        lpPathName)
USE DFWINTY
  integer(BOOL) :: RemoveDirectory ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RemoveDirectoryA' :: RemoveDirectory
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFullPathName( &
        lpFileName, &
        nBufferLength, &
        lpBuffer, &
        lpFilePart)
USE DFWINTY
  integer(DWORD) :: GetFullPathName ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFullPathNameA' :: GetFullPathName
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
  integer(DWORD) nBufferLength ! DWORD nBufferLength
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpFilePart
  integer(LPSTR) lpFilePart ! LPSTR* lpFilePart
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DefineDosDevice( &
        dwFlags, &
        lpDeviceName, &
        lpTargetPath)
USE DFWINTY
  integer(BOOL) :: DefineDosDevice ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DefineDosDeviceA' :: DefineDosDevice
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDeviceName
  character*(*) lpDeviceName ! LPCSTR lpDeviceName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTargetPath
  character*(*) lpTargetPath ! LPCSTR lpTargetPath
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION QueryDosDevice( &
        lpDeviceName, &
        lpTargetPath, &
        ucchMax)
USE DFWINTY
  integer(DWORD) :: QueryDosDevice ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'QueryDosDeviceA' :: QueryDosDevice
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDeviceName
  character*(*) lpDeviceName ! LPCSTR lpDeviceName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTargetPath
  character*(*) lpTargetPath ! LPSTR lpTargetPath
  integer(DWORD) ucchMax ! DWORD ucchMax
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateFile( &
        lpFileName, &
        dwDesiredAccess, &
        dwShareMode, &
        lpSecurityAttributes, &
        dwCreationDisposition, &
        dwFlagsAndAttributes, &
        hTemplateFile)
USE DFWINTY
  integer(HANDLE) :: CreateFile ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateFileA' :: CreateFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(DWORD) dwShareMode ! DWORD dwShareMode
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSecurityAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSecurityAttributes ! LPSECURITY_ATTRIBUTES lpSecurityAttributes
  integer(DWORD) dwCreationDisposition ! DWORD dwCreationDisposition
  integer(DWORD) dwFlagsAndAttributes ! DWORD dwFlagsAndAttributes
  integer(HANDLE) hTemplateFile ! HANDLE hTemplateFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetFileAttributes( &
        lpFileName, &
        dwFileAttributes)
USE DFWINTY
  integer(BOOL) :: SetFileAttributes ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetFileAttributesA' :: SetFileAttributes
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
  integer(DWORD) dwFileAttributes ! DWORD dwFileAttributes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileAttributes( &
        lpFileName)
USE DFWINTY
  integer(DWORD) :: GetFileAttributes ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileAttributesA' :: GetFileAttributes
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetFileAttributesEx( &
        lpFileName, &
        fInfoLevelId, &
        lpFileInformation)
USE DFWINTY
  integer(BOOL) :: GetFileAttributesEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetFileAttributesExA' :: GetFileAttributesEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
  integer(ENUM) fInfoLevelId ! GET_FILEEX_INFO_LEVELS fInfoLevelId
  integer(LPVOID) lpFileInformation ! LPVOID lpFileInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCompressedFileSize( &
        lpFileName, &
        lpFileSizeHigh)
USE DFWINTY
  integer(DWORD) :: GetCompressedFileSize ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCompressedFileSizeA' :: GetCompressedFileSize
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
  integer(LPDWORD) lpFileSizeHigh ! LPDWORD lpFileSizeHigh
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION DeleteFile( &
        lpFileName)
USE DFWINTY
  integer(BOOL) :: DeleteFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'DeleteFileA' :: DeleteFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION FindFirstFileEx( &
        lpFileName, &
        fInfoLevelId, &
        lpFindFileData, &
        fSearchOp, &
        lpSearchFilter, &
        dwAdditionalFlags)
USE DFWINTY
  integer(HANDLE) :: FindFirstFileEx ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindFirstFileExA' :: FindFirstFileEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
  integer(ENUM) fInfoLevelId ! FINDEX_INFO_LEVELS fInfoLevelId
  integer(LPVOID) lpFindFileData ! LPVOID lpFindFileData
  integer(ENUM) fSearchOp ! FINDEX_SEARCH_OPS fSearchOp
  integer(LPVOID) lpSearchFilter ! LPVOID lpSearchFilter
  integer(DWORD) dwAdditionalFlags ! DWORD dwAdditionalFlags
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION FindFirstFile( &
        lpFileName, &
        lpFindFileData)
USE DFWINTY
  integer(HANDLE) :: FindFirstFile ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindFirstFileA' :: FindFirstFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFindFileData
  TYPE (T_WIN32_FIND_DATA) lpFindFileData ! LP_WIN32FIND_DATAA lpFindFileData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FindNextFile( &
        hFindFile, &
        lpFindFileData)
USE DFWINTY
  integer(BOOL) :: FindNextFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindNextFileA' :: FindNextFile
  integer(HANDLE) hFindFile ! HANDLE hFindFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFindFileData
  TYPE (T_WIN32_FIND_DATA) lpFindFileData ! LP_WIN32FIND_DATAA lpFindFileData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SearchPath( &
        lpPath, &
        lpFileName, &
        lpExtension, &
        nBufferLength, &
        lpBuffer, &
        lpFilePart)
USE DFWINTY
  integer(DWORD) :: SearchPath ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SearchPathA' :: SearchPath
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpPath
  character*(*) lpPath ! LPCSTR lpPath
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFileName
  character*(*) lpFileName ! LPCSTR lpFileName
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpExtension
  character*(*) lpExtension ! LPCSTR lpExtension
  integer(DWORD) nBufferLength ! DWORD nBufferLength
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC :: lpFilePart
  integer(LPSTR) lpFilePart ! LPSTR* lpFilePart
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CopyFile( &
        lpExistingFileName, &
        lpNewFileName, &
        bFailIfExists)
USE DFWINTY
  integer(BOOL) :: CopyFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CopyFileA' :: CopyFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpExistingFileName
  character*(*) lpExistingFileName ! LPCSTR lpExistingFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNewFileName
  character*(*) lpNewFileName ! LPCSTR lpNewFileName
  integer(BOOL) bFailIfExists ! BOOL bFailIfExists
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IX86)
FUNCTION CopyFileEx( &
        lpExistingFileName, &
        lpNewFileName, &
        lpProgressRoutine, &
        lpData, &
        pbCancel, &
        dwCopyFlags)
USE DFWINTY
  integer(BOOL) :: CopyFileEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CopyFileExA' :: CopyFileEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpExistingFileName
  character*(*) lpExistingFileName ! LPCSTR lpExistingFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNewFileName
  character*(*) lpNewFileName ! LPCSTR lpNewFileName
  integer(LPVOID) lpProgressRoutine ! LPPROGRESS_ROUTINE lpProgressRoutine
  integer(LPVOID) lpData ! LPVOID lpData
!DEC$ ATTRIBUTES REFERENCE :: pbCancel
  integer(BOOL) pbCancel ! LPBOOL pbCancel
  integer(DWORD) dwCopyFlags ! DWORD dwCopyFlags
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION MoveFile( &
        lpExistingFileName, &
        lpNewFileName)
USE DFWINTY
  integer(BOOL) :: MoveFile ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'MoveFileA' :: MoveFile
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpExistingFileName
  character*(*) lpExistingFileName ! LPCSTR lpExistingFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNewFileName
  character*(*) lpNewFileName ! LPCSTR lpNewFileName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION MoveFileEx( &
        lpExistingFileName, &
        lpNewFileName, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: MoveFileEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'MoveFileExA' :: MoveFileEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpExistingFileName
  character*(*) lpExistingFileName ! LPCSTR lpExistingFileName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNewFileName
  character*(*) lpNewFileName ! LPCSTR lpNewFileName
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateNamedPipe( &
        lpName, &
        dwOpenMode, &
        dwPipeMode, &
        nMaxInstances, &
        nOutBufferSize, &
        nInBufferSize, &
        nDefaultTimeOut, &
        lpSecurityAttributes)
USE DFWINTY
  integer(HANDLE) :: CreateNamedPipe ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateNamedPipeA' :: CreateNamedPipe
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpName
  character*(*) lpName ! LPCSTR lpName
  integer(DWORD) dwOpenMode ! DWORD dwOpenMode
  integer(DWORD) dwPipeMode ! DWORD dwPipeMode
  integer(DWORD) nMaxInstances ! DWORD nMaxInstances
  integer(DWORD) nOutBufferSize ! DWORD nOutBufferSize
  integer(DWORD) nInBufferSize ! DWORD nInBufferSize
  integer(DWORD) nDefaultTimeOut ! DWORD nDefaultTimeOut
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSecurityAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSecurityAttributes ! LPSECURITY_ATTRIBUTES lpSecurityAttributes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetNamedPipeHandleState( &
        hNamedPipe, &
        lpState, &
        lpCurInstances, &
        lpMaxCollectionCount, &
        lpCollectDataTimeout, &
        lpUserName, &
        nMaxUserNameSize)
USE DFWINTY
  integer(BOOL) :: GetNamedPipeHandleState ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetNamedPipeHandleStateA' :: GetNamedPipeHandleState
  integer(HANDLE) hNamedPipe ! HANDLE hNamedPipe
  integer(LPDWORD) lpState ! LPDWORD lpState
  integer(LPDWORD) lpCurInstances ! LPDWORD lpCurInstances
  integer(LPDWORD) lpMaxCollectionCount ! LPDWORD lpMaxCollectionCount
  integer(LPDWORD) lpCollectDataTimeout ! LPDWORD lpCollectDataTimeout
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpUserName
  character*(*) lpUserName ! LPSTR lpUserName
  integer(DWORD) nMaxUserNameSize ! DWORD nMaxUserNameSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CallNamedPipe( &
        lpNamedPipeName, &
        lpInBuffer, &
        nInBufferSize, &
        lpOutBuffer, &
        nOutBufferSize, &
        lpBytesRead, &
        nTimeOut)
USE DFWINTY
  integer(BOOL) :: CallNamedPipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CallNamedPipeA' :: CallNamedPipe
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNamedPipeName
  character*(*) lpNamedPipeName ! LPCSTR lpNamedPipeName
  integer(LPVOID) lpInBuffer ! LPVOID lpInBuffer
  integer(DWORD) nInBufferSize ! DWORD nInBufferSize
  integer(LPVOID) lpOutBuffer ! LPVOID lpOutBuffer
  integer(DWORD) nOutBufferSize ! DWORD nOutBufferSize
  integer(LPDWORD) lpBytesRead ! LPDWORD lpBytesRead
  integer(DWORD) nTimeOut ! DWORD nTimeOut
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WaitNamedPipe( &
        lpNamedPipeName, &
        nTimeOut)
USE DFWINTY
  integer(BOOL) :: WaitNamedPipe ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WaitNamedPipeA' :: WaitNamedPipe
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNamedPipeName
  character*(*) lpNamedPipeName ! LPCSTR lpNamedPipeName
  integer(DWORD) nTimeOut ! DWORD nTimeOut
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetVolumeLabel( &
        lpRootPathName, &
        lpVolumeName)
USE DFWINTY
  integer(BOOL) :: SetVolumeLabel ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetVolumeLabelA' :: SetVolumeLabel
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpRootPathName
  character*(*) lpRootPathName ! LPCSTR lpRootPathName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpVolumeName
  character*(*) lpVolumeName ! LPCSTR lpVolumeName
 END FUNCTION
END INTERFACE
INTERFACE 
   SUBROUTINE SetFileApisToOEM( &
             )
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetFileApisToOEM' :: SetFileApisToOEM
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE SetFileApisToANSI( &
             )
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetFileApisToANSI' :: SetFileApisToANSI
 END SUBROUTINE
END INTERFACE
INTERFACE 
FUNCTION AreFileApisANSI( &
             )
USE DFWINTY
  integer(BOOL) :: AreFileApisANSI ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'AreFileApisANSI' :: AreFileApisANSI
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetVolumeInformation( &
        lpRootPathName, &
        lpVolumeNameBuffer, &
        nVolumeNameSize, &
        lpVolumeSerialNumber, &
        lpMaximumComponentLength, &
        lpFileSystemFlags, &
        lpFileSystemNameBuffer, &
        nFileSystemNameSize)
USE DFWINTY
  integer(BOOL) :: GetVolumeInformation ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetVolumeInformationA' :: GetVolumeInformation
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpRootPathName
  character*(*) lpRootPathName ! LPCSTR lpRootPathName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpVolumeNameBuffer
  character*(*) lpVolumeNameBuffer ! LPSTR lpVolumeNameBuffer
  integer(DWORD) nVolumeNameSize ! DWORD nVolumeNameSize
  integer(LPDWORD) lpVolumeSerialNumber ! LPDWORD lpVolumeSerialNumber
  integer(LPDWORD) lpMaximumComponentLength ! LPDWORD lpMaximumComponentLength
  integer(LPDWORD) lpFileSystemFlags ! LPDWORD lpFileSystemFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFileSystemNameBuffer
  character*(*) lpFileSystemNameBuffer ! LPSTR lpFileSystemNameBuffer
  integer(DWORD) nFileSystemNameSize ! DWORD nFileSystemNameSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CancelIo( &
        hFile)
USE DFWINTY
  integer(BOOL) :: CancelIo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CancelIo' :: CancelIo
  integer(HANDLE) hFile ! HANDLE hFile
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FindFirstChangeNotification( &
        lpPathName, &
        bWatchSubtree, &
        dwNotifyFilter)
USE DFWINTY
  integer(HANDLE) :: FindFirstChangeNotification ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindFirstChangeNotificationA' :: FindFirstChangeNotification
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpPathName
  character*(*) lpPathName ! LPCSTR lpPathName
  integer(BOOL) bWatchSubtree ! BOOL bWatchSubtree
  integer(DWORD) dwNotifyFilter ! DWORD dwNotifyFilter
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FindNextChangeNotification( &
        hChangeHandle)
USE DFWINTY
  integer(BOOL) :: FindNextChangeNotification ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindNextChangeNotification' :: FindNextChangeNotification
  integer(HANDLE) hChangeHandle ! HANDLE hChangeHandle
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FindCloseChangeNotification( &
        hChangeHandle)
USE DFWINTY
  integer(BOOL) :: FindCloseChangeNotification ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FindCloseChangeNotification' :: FindCloseChangeNotification
  integer(HANDLE) hChangeHandle ! HANDLE hChangeHandle
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualLock( &
        lpAddress, &
        dwSize)
USE DFWINTY
  integer(BOOL) :: VirtualLock ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualLock' :: VirtualLock
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VirtualUnlock( &
        lpAddress, &
        dwSize)
USE DFWINTY
  integer(BOOL) :: VirtualUnlock ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VirtualUnlock' :: VirtualUnlock
  integer(LPVOID) lpAddress ! LPVOID lpAddress
  integer(SIZE_T) dwSize ! SIZE_T dwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION MapViewOfFileEx( &
        hFileMappingObject, &
        dwDesiredAccess, &
        dwFileOffsetHigh, &
        dwFileOffsetLow, &
        dwNumberOfBytesToMap, &
        lpBaseAddress)
USE DFWINTY
  integer(LPVOID) :: MapViewOfFileEx ! LPVOID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'MapViewOfFileEx' :: MapViewOfFileEx
  integer(HANDLE) hFileMappingObject ! HANDLE hFileMappingObject
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(DWORD) dwFileOffsetHigh ! DWORD dwFileOffsetHigh
  integer(DWORD) dwFileOffsetLow ! DWORD dwFileOffsetLow
  integer(SIZE_T) dwNumberOfBytesToMap ! SIZE_T dwNumberOfBytesToMap
  integer(LPVOID) lpBaseAddress ! LPVOID lpBaseAddress
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetPriorityClass( &
        hProcess, &
        dwPriorityClass)
USE DFWINTY
  integer(BOOL) :: SetPriorityClass ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetPriorityClass' :: SetPriorityClass
  integer(HANDLE) hProcess ! HANDLE hProcess
  integer(DWORD) dwPriorityClass ! DWORD dwPriorityClass
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetPriorityClass( &
        hProcess)
USE DFWINTY
  integer(DWORD) :: GetPriorityClass ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetPriorityClass' :: GetPriorityClass
  integer(HANDLE) hProcess ! HANDLE hProcess
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsBadReadPtr( &
        lp, &
        ucb)
USE DFWINTY
  integer(BOOL) :: IsBadReadPtr ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsBadReadPtr' :: IsBadReadPtr
  integer(LPVOID)  lp ! void* lp
  integer(UINT_PTR) ucb ! UINT_PTR ucb
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsBadWritePtr( &
        lp, &
        ucb)
USE DFWINTY
  integer(BOOL) :: IsBadWritePtr ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsBadWritePtr' :: IsBadWritePtr
  integer(LPVOID) lp ! LPVOID lp
  integer(UINT_PTR) ucb ! UINT_PTR ucb
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsBadHugeReadPtr( &
        lp, &
        ucb)
USE DFWINTY
  integer(BOOL) :: IsBadHugeReadPtr ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsBadHugeReadPtr' :: IsBadHugeReadPtr
  integer(LPVOID)  lp ! void* lp
  integer(UINT_PTR) ucb ! UINT_PTR ucb
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsBadHugeWritePtr( &
        lp, &
        ucb)
USE DFWINTY
  integer(BOOL) :: IsBadHugeWritePtr ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsBadHugeWritePtr' :: IsBadHugeWritePtr
  integer(LPVOID) lp ! LPVOID lp
  integer(UINT_PTR) ucb ! UINT_PTR ucb
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsBadCodePtr( &
        lpfn)
USE DFWINTY
  integer(BOOL) :: IsBadCodePtr ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsBadCodePtr' :: IsBadCodePtr
  integer(LPVOID) lpfn ! FARPROC lpfn
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsBadStringPtr( &
        lpsz, &
        ucchMax)
USE DFWINTY
  integer(BOOL) :: IsBadStringPtr ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsBadStringPtrA' :: IsBadStringPtr
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpsz
  character*(*) lpsz ! LPCSTR lpsz
  integer(UINT_PTR) ucchMax ! UINT_PTR ucchMax
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION BuildCommDCB( &
        lpDef, &
        lpDCB)
USE DFWINTY
  integer(BOOL) :: BuildCommDCB ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'BuildCommDCBA' :: BuildCommDCB
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDef
  character*(*) lpDef ! LPCSTR lpDef
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDCB
  TYPE (T_DCB) lpDCB ! LPDCB lpDCB
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION BuildCommDCBAndTimeouts( &
        lpDef, &
        lpDCB, &
        lpCommTimeouts)
USE DFWINTY
  integer(BOOL) :: BuildCommDCBAndTimeouts ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'BuildCommDCBAndTimeoutsA' :: BuildCommDCBAndTimeouts
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDef
  character*(*) lpDef ! LPCSTR lpDef
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDCB
  TYPE (T_DCB) lpDCB ! LPDCB lpDCB
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCommTimeouts
  TYPE (T_COMMTIMEOUTS) lpCommTimeouts ! LPCOMMTIMEOUTS lpCommTimeouts
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CommConfigDialog( &
        lpszName, &
        hWnd, &
        lpCC)
USE DFWINTY
  integer(BOOL) :: CommConfigDialog ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CommConfigDialogA' :: CommConfigDialog
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpszName
  character*(*) lpszName ! LPCSTR lpszName
  integer(HANDLE) hWnd ! HWND hWnd
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCC
  TYPE (T_COMMCONFIG) lpCC ! LPCOMMCONFIG lpCC
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetDefaultCommConfig( &
        lpszName, &
        lpCC, &
        lpdwSize)
USE DFWINTY
  integer(BOOL) :: GetDefaultCommConfig ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetDefaultCommConfigA' :: GetDefaultCommConfig
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpszName
  character*(*) lpszName ! LPCSTR lpszName
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCC
  TYPE (T_COMMCONFIG) lpCC ! LPCOMMCONFIG lpCC
  integer(LPDWORD) lpdwSize ! LPDWORD lpdwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetDefaultCommConfig( &
        lpszName, &
        lpCC, &
        dwSize)
USE DFWINTY
  integer(BOOL) :: SetDefaultCommConfig ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetDefaultCommConfigA' :: SetDefaultCommConfig
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpszName
  character*(*) lpszName ! LPCSTR lpszName
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpCC
  TYPE (T_COMMCONFIG) lpCC ! LPCOMMCONFIG lpCC
  integer(DWORD) dwSize ! DWORD dwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetComputerName( &
        lpBuffer, &
        nSize)
USE DFWINTY
  integer(BOOL) :: GetComputerName ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetComputerNameA' :: GetComputerName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  character*(*) lpBuffer ! LPSTR lpBuffer
  integer(LPDWORD) nSize ! LPDWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetComputerName( &
        lpComputerName)
USE DFWINTY
  integer(BOOL) :: SetComputerName ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetComputerNameA' :: SetComputerName
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpComputerName
  character*(*) lpComputerName ! LPCSTR lpComputerName
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION QueryPerformanceCounter( &
        lpPerformanceCount)
USE DFWINTY
  integer(BOOL) :: QueryPerformanceCounter ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'QueryPerformanceCounter' :: QueryPerformanceCounter
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpPerformanceCount
  TYPE (T_LARGE_INTEGER) lpPerformanceCount ! LARGE_INTEGER* lpPerformanceCount
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION QueryPerformanceFrequency( &
        lpFrequency)
USE DFWINTY
  integer(BOOL) :: QueryPerformanceFrequency ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'QueryPerformanceFrequency' :: QueryPerformanceFrequency
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpFrequency
  TYPE (T_LARGE_INTEGER) lpFrequency ! LARGE_INTEGER* lpFrequency
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetVersionEx( &
        lpVersionInformation)
USE DFWINTY
  integer(BOOL) :: GetVersionEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetVersionExA' :: GetVersionEx
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpVersionInformation
  TYPE (T_OSVERSIONINFO) lpVersionInformation ! LPOSVERSIONINFOA lpVersionInformation
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VerifyVersionInfo( &
        lpVersionInformation, &
        dwTypeMask, &
        dwlConditionMask)
USE DFWINTY
  integer(BOOL) :: VerifyVersionInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VerifyVersionInfoA' :: VerifyVersionInfo
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpVersionInformation
  TYPE (T_OSVERSIONINFOEX) lpVersionInformation ! LPOSVERSIONINFOEXA lpVersionInformation
  integer(DWORD) dwTypeMask ! DWORD dwTypeMask
!DEC$ IF DEFINED( _M_IA64)
  integer(DWORDLONG) dwlConditionMask ! DWORDLONG dwlConditionMask
!DEC$ ELSE
  TYPE(T_LARGE_INTEGERX) dwlConditionMask ! DWORDLONG dwlConditionMask
!DEC$ ENDIF
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetSystemPowerStatus( &
        lpSystemPowerStatus)
USE DFWINTY
  integer(BOOL) :: GetSystemPowerStatus ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemPowerStatus' :: GetSystemPowerStatus
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSystemPowerStatus
  TYPE (T_SYSTEM_POWER_STATUS) lpSystemPowerStatus ! LPSYSTEM_POWER_STATUS lpSystemPowerStatus
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetSystemPowerState( &
        fSuspend, &
        fForce)
USE DFWINTY
  integer(BOOL) :: SetSystemPowerState ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetSystemPowerState' :: SetSystemPowerState
  integer(BOOL) fSuspend ! BOOL fSuspend
  integer(BOOL) fForce ! BOOL fForce
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ProcessIdToSessionId( &
        dwProcessId, &
        pSessionId)
USE DFWINTY
  integer(BOOL) :: ProcessIdToSessionId ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ProcessIdToSessionId' :: ProcessIdToSessionId
  integer(DWORD) dwProcessId ! DWORD dwProcessId
  integer(LPDWORD) pSessionId ! DWORD* pSessionId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsValidCodePage( &
        CodePage)
USE DFWINTY
  integer(BOOL) :: IsValidCodePage ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsValidCodePage' :: IsValidCodePage
  integer(UINT) CodePage ! UINT CodePage
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetACP( &
             )
USE DFWINTY
  integer(UINT) :: GetACP ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetACP' :: GetACP
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetOEMCP( &
             )
USE DFWINTY
  integer(UINT) :: GetOEMCP ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetOEMCP' :: GetOEMCP
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCPInfo( &
        CodePage, &
        lpCPInfo)
USE DFWINTY
  integer(BOOL) :: GetCPInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCPInfo' :: GetCPInfo
  integer(UINT) CodePage ! UINT CodePage
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCPInfo
  TYPE (T_CPINFO) lpCPInfo ! LPCPINFO lpCPInfo
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCPInfoEx( &
        CodePage, &
        dwFlags, &
        lpCPInfoEx)
USE DFWINTY
  integer(BOOL) :: GetCPInfoEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCPInfoExA' :: GetCPInfoEx
  integer(UINT) CodePage ! UINT CodePage
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCPInfoEx
  TYPE (T_CPINFOEX) lpCPInfoEx ! LPCPINFOEXA lpCPInfoEx
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsDBCSLeadByte( &
        TestChar)
USE DFWINTY
  integer(BOOL) :: IsDBCSLeadByte ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsDBCSLeadByte' :: IsDBCSLeadByte
  integer(BYTE) TestChar ! BYTE TestChar
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsDBCSLeadByteEx( &
        CodePage, &
        TestChar)
USE DFWINTY
  integer(BOOL) :: IsDBCSLeadByteEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsDBCSLeadByteEx' :: IsDBCSLeadByteEx
  integer(UINT) CodePage ! UINT CodePage
  integer(BYTE) TestChar ! BYTE TestChar
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION MultiByteToWideChar( &
        CodePage, &
        dwFlags, &
        lpMultiByteStr, &
        cbMultiByte, &
        lpWideCharStr, &
        cchWideChar)
USE DFWINTY
  integer(SINT) :: MultiByteToWideChar ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'MultiByteToWideChar' :: MultiByteToWideChar
  integer(UINT) CodePage ! UINT CodePage
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpMultiByteStr
  character*(*) lpMultiByteStr ! LPCSTR lpMultiByteStr
  integer(SINT) cbMultiByte ! int cbMultiByte
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpWideCharStr
  integer(WCHAR) lpWideCharStr(*) ! LPWSTR lpWideCharStr
  integer(SINT) cchWideChar ! int cchWideChar
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WideCharToMultiByte( &
        CodePage, &
        dwFlags, &
        lpWideCharStr, &
        cchWideChar, &
        lpMultiByteStr, &
        cbMultiByte, &
        lpDefaultChar, &
        lpUsedDefaultChar)
USE DFWINTY
  integer(SINT) :: WideCharToMultiByte ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WideCharToMultiByte' :: WideCharToMultiByte
  integer(UINT) CodePage ! UINT CodePage
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpWideCharStr
  integer(WCHAR) lpWideCharStr(*) ! LPCWSTR lpWideCharStr
  integer(SINT) cchWideChar ! int cchWideChar
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpMultiByteStr
  character*(*) lpMultiByteStr ! LPSTR lpMultiByteStr
  integer(SINT) cbMultiByte ! int cbMultiByte
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDefaultChar
  character*(*) lpDefaultChar ! LPCSTR lpDefaultChar
!DEC$ ATTRIBUTES REFERENCE :: lpUsedDefaultChar
  integer(BOOL) lpUsedDefaultChar ! LPBOOL lpUsedDefaultChar
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CompareString( &
        Locale, &
        dwCmpFlags, &
        lpString1, &
        cchCount1, &
        lpString2, &
        cchCount2)
USE DFWINTY
  integer(SINT) :: CompareString ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CompareStringA' :: CompareString
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwCmpFlags ! DWORD dwCmpFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString1
  character*(*) lpString1 ! LPCSTR lpString1
  integer(SINT) cchCount1 ! int cchCount1
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpString2
  character*(*) lpString2 ! LPCSTR lpString2
  integer(SINT) cchCount2 ! int cchCount2
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION LCMapString( &
        Locale, &
        dwMapFlags, &
        lpSrcStr, &
        cchSrc, &
        lpDestStr, &
        cchDest)
USE DFWINTY
  integer(SINT) :: LCMapString ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'LCMapStringA' :: LCMapString
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwMapFlags ! DWORD dwMapFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSrcStr
  character*(*) lpSrcStr ! LPCSTR lpSrcStr
  integer(SINT) cchSrc ! int cchSrc
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDestStr
  character*(*) lpDestStr ! LPSTR lpDestStr
  integer(SINT) cchDest ! int cchDest
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetLocaleInfo( &
        Locale, &
        LCType, &
        lpLCData, &
        cchData)
USE DFWINTY
  integer(SINT) :: GetLocaleInfo ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLocaleInfoA' :: GetLocaleInfo
  integer(ULONG) Locale ! LCID Locale
  integer(ULONG) LCType ! LCTYPE LCType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLCData
  character*(*) lpLCData ! LPSTR lpLCData
  integer(SINT) cchData ! int cchData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetLocaleInfo( &
        Locale, &
        LCType, &
        lpLCData)
USE DFWINTY
  integer(BOOL) :: SetLocaleInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetLocaleInfoA' :: SetLocaleInfo
  integer(ULONG) Locale ! LCID Locale
  integer(ULONG) LCType ! LCTYPE LCType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpLCData
  character*(*) lpLCData ! LPCSTR lpLCData
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IA64)
FUNCTION GetCalendarInfo( &
        Locale, &
        Calendar, &
        CalType, &
        lpCalData, &
        cchData, &
        lpValue)
USE DFWINTY
  integer(SINT) :: GetCalendarInfo ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCalendarInfoA' :: GetCalendarInfo
  integer(ULONG) Locale ! LCID Locale
  integer(ULONG) Calendar ! CALID Calendar
  integer(ULONG) CalType ! CALTYPE CalType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCalData
  character*(*) lpCalData ! LPSTR lpCalData
  integer(SINT) cchData ! int cchData
  integer(LPDWORD) lpValue ! LPDWORD lpValue
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetCalendarInfo( &
        Locale, &
        Calendar, &
        CalType, &
        lpCalData)
USE DFWINTY
  integer(BOOL) :: SetCalendarInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetCalendarInfoA' :: SetCalendarInfo
  integer(ULONG) Locale ! LCID Locale
  integer(ULONG) Calendar ! CALID Calendar
  integer(ULONG) CalType ! CALTYPE CalType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCalData
  character*(*) lpCalData ! LPCSTR lpCalData
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION GetTimeFormat( &
        Locale, &
        dwFlags, &
        lpTime, &
        lpFormat, &
        lpTimeStr, &
        cchTime)
USE DFWINTY
  integer(SINT) :: GetTimeFormat ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetTimeFormatA' :: GetTimeFormat
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTime
  TYPE (T_SYSTEMTIME) lpTime ! SYSTEMTIME* lpTime
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFormat
  character*(*) lpFormat ! LPCSTR lpFormat
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpTimeStr
  character*(*) lpTimeStr ! LPSTR lpTimeStr
  integer(SINT) cchTime ! int cchTime
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetDateFormat( &
        Locale, &
        dwFlags, &
        lpDate, &
        lpFormat, &
        lpDateStr, &
        cchDate)
USE DFWINTY
  integer(SINT) :: GetDateFormat ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetDateFormatA' :: GetDateFormat
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDate
  TYPE (T_SYSTEMTIME) lpDate ! SYSTEMTIME* lpDate
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFormat
  character*(*) lpFormat ! LPCSTR lpFormat
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDateStr
  character*(*) lpDateStr ! LPSTR lpDateStr
  integer(SINT) cchDate ! int cchDate
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetNumberFormat( &
        Locale, &
        dwFlags, &
        lpValue, &
        lpFormat, &
        lpNumberStr, &
        cchNumber)
USE DFWINTY
  integer(SINT) :: GetNumberFormat ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetNumberFormatA' :: GetNumberFormat
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpValue
  character*(*) lpValue ! LPCSTR lpValue
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFormat
  TYPE (T_NUMBERFMT) lpFormat ! NUMBERFMTA* lpFormat
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpNumberStr
  character*(*) lpNumberStr ! LPSTR lpNumberStr
  integer(SINT) cchNumber ! int cchNumber
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetCurrencyFormat( &
        Locale, &
        dwFlags, &
        lpValue, &
        lpFormat, &
        lpCurrencyStr, &
        cchCurrency)
USE DFWINTY
  integer(SINT) :: GetCurrencyFormat ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetCurrencyFormatA' :: GetCurrencyFormat
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpValue
  character*(*) lpValue ! LPCSTR lpValue
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFormat
  TYPE (T_CURRENCYFMT) lpFormat ! CURRENCYFMTA* lpFormat
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCurrencyStr
  character*(*) lpCurrencyStr ! LPSTR lpCurrencyStr
  integer(SINT) cchCurrency ! int cchCurrency
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EnumCalendarInfo( &
        lpCalInfoEnumProc, &
        Locale, &
        Calendar, &
        CalType)
USE DFWINTY
  integer(BOOL) :: EnumCalendarInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumCalendarInfoA' :: EnumCalendarInfo
  integer(LPVOID) lpCalInfoEnumProc ! CALINFO_ENUMPROCA lpCalInfoEnumProc
  integer(ULONG) Locale ! LCID Locale
  integer(ULONG) Calendar ! CALID Calendar
  integer(ULONG) CalType ! CALTYPE CalType
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IA64)
FUNCTION EnumCalendarInfoEx( &
        lpCalInfoEnumProcEx, &
        Locale, &
        Calendar, &
        CalType)
USE DFWINTY
  integer(BOOL) :: EnumCalendarInfoEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumCalendarInfoExA' :: EnumCalendarInfoEx
  integer(LPVOID) lpCalInfoEnumProcEx ! CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx
  integer(ULONG) Locale ! LCID Locale
  integer(ULONG) Calendar ! CALID Calendar
  integer(ULONG) CalType ! CALTYPE CalType
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION EnumTimeFormats( &
        lpTimeFmtEnumProc, &
        Locale, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: EnumTimeFormats ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumTimeFormatsA' :: EnumTimeFormats
  integer(LPVOID) lpTimeFmtEnumProc ! TIMEFMT_ENUMPROCA lpTimeFmtEnumProc
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EnumDateFormats( &
        lpDateFmtEnumProc, &
        Locale, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: EnumDateFormats ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumDateFormatsA' :: EnumDateFormats
  integer(LPVOID) lpDateFmtEnumProc ! DATEFMT_ENUMPROCA lpDateFmtEnumProc
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IA64)
FUNCTION EnumDateFormatsEx( &
        lpDateFmtEnumProcEx, &
        Locale, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: EnumDateFormatsEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumDateFormatsExA' :: EnumDateFormatsEx
  integer(LPVOID) lpDateFmtEnumProcEx ! DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION IsValidLanguageGroup( &
        LanguageGroup, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: IsValidLanguageGroup ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsValidLanguageGroup' :: IsValidLanguageGroup
  integer(ULONG) LanguageGroup ! LGRPID LanguageGroup
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION IsValidLocale( &
        Locale, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: IsValidLocale ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'IsValidLocale' :: IsValidLocale
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ConvertDefaultLocale( &
        Locale)
USE DFWINTY
  integer(ULONG) :: ConvertDefaultLocale ! LCID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ConvertDefaultLocale' :: ConvertDefaultLocale
  integer(ULONG) Locale ! LCID Locale
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetThreadLocale( &
             )
USE DFWINTY
  integer(ULONG) :: GetThreadLocale ! LCID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetThreadLocale' :: GetThreadLocale
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetThreadLocale( &
        Locale)
USE DFWINTY
  integer(BOOL) :: SetThreadLocale ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetThreadLocale' :: SetThreadLocale
  integer(ULONG) Locale ! LCID Locale
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IA64)
FUNCTION GetSystemDefaultUILanguage( &
             )
USE DFWINTY
  integer(USHORT) :: GetSystemDefaultUILanguage ! LANGID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemDefaultUILanguage' :: GetSystemDefaultUILanguage
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetUserDefaultUILanguage( &
             )
USE DFWINTY
  integer(USHORT) :: GetUserDefaultUILanguage ! LANGID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetUserDefaultUILanguage' :: GetUserDefaultUILanguage
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION GetSystemDefaultLangID( &
             )
USE DFWINTY
  integer(USHORT) :: GetSystemDefaultLangID ! LANGID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemDefaultLangID' :: GetSystemDefaultLangID
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetUserDefaultLangID( &
             )
USE DFWINTY
  integer(USHORT) :: GetUserDefaultLangID ! LANGID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetUserDefaultLangID' :: GetUserDefaultLangID
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetSystemDefaultLCID( &
             )
USE DFWINTY
  integer(ULONG) :: GetSystemDefaultLCID ! LCID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetSystemDefaultLCID' :: GetSystemDefaultLCID
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetUserDefaultLCID( &
             )
USE DFWINTY
  integer(ULONG) :: GetUserDefaultLCID ! LCID
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetUserDefaultLCID' :: GetUserDefaultLCID
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetStringTypeEx( &
        Locale, &
        dwInfoType, &
        lpSrcStr, &
        cchSrc, &
        lpCharType)
USE DFWINTY
  integer(BOOL) :: GetStringTypeEx ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetStringTypeExA' :: GetStringTypeEx
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwInfoType ! DWORD dwInfoType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSrcStr
  character*(*) lpSrcStr ! LPCSTR lpSrcStr
  integer(SINT) cchSrc ! int cchSrc
  integer(LPWORD) lpCharType ! LPWORD lpCharType
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetStringType( &
        Locale, &
        dwInfoType, &
        lpSrcStr, &
        cchSrc, &
        lpCharType)
USE DFWINTY
  integer(BOOL) :: GetStringType ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetStringTypeA' :: GetStringType
  integer(ULONG) Locale ! LCID Locale
  integer(DWORD) dwInfoType ! DWORD dwInfoType
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSrcStr
  character*(*) lpSrcStr ! LPCSTR lpSrcStr
  integer(SINT) cchSrc ! int cchSrc
  integer(LPWORD) lpCharType ! LPWORD lpCharType
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FoldString( &
        dwMapFlags, &
        lpSrcStr, &
        cchSrc, &
        lpDestStr, &
        cchDest)
USE DFWINTY
  integer(SINT) :: FoldString ! int
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FoldStringA' :: FoldString
  integer(DWORD) dwMapFlags ! DWORD dwMapFlags
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSrcStr
  character*(*) lpSrcStr ! LPCSTR lpSrcStr
  integer(SINT) cchSrc ! int cchSrc
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpDestStr
  character*(*) lpDestStr ! LPSTR lpDestStr
  integer(SINT) cchDest ! int cchDest
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ IF DEFINED( _M_IA64)
FUNCTION EnumSystemLanguageGroups( &
        lpLanguageGroupEnumProc, &
        dwFlags, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumSystemLanguageGroups ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumSystemLanguageGroupsA' :: EnumSystemLanguageGroups
  integer(LPVOID) lpLanguageGroupEnumProc ! LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EnumLanguageGroupLocales( &
        lpLangGroupLocaleEnumProc, &
        LanguageGroup, &
        dwFlags, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumLanguageGroupLocales ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumLanguageGroupLocalesA' :: EnumLanguageGroupLocales
  integer(LPVOID) lpLangGroupLocaleEnumProc ! LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc
  integer(ULONG) LanguageGroup ! LGRPID LanguageGroup
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EnumUILanguages( &
        lpUILanguageEnumProc, &
        dwFlags, &
        lParam)
USE DFWINTY
  integer(BOOL) :: EnumUILanguages ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumUILanguagesA' :: EnumUILanguages
  integer(LPVOID) lpUILanguageEnumProc ! UILANGUAGE_ENUMPROCA lpUILanguageEnumProc
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LONG_PTR) lParam ! LONG_PTR lParam
 END FUNCTION
END INTERFACE
INTERFACE 
!DEC$ ENDIF
FUNCTION EnumSystemLocales( &
        lpLocaleEnumProc, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: EnumSystemLocales ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumSystemLocalesA' :: EnumSystemLocales
  integer(LPVOID) lpLocaleEnumProc ! LOCALE_ENUMPROCA lpLocaleEnumProc
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION EnumSystemCodePages( &
        lpCodePageEnumProc, &
        dwFlags)
USE DFWINTY
  integer(BOOL) :: EnumSystemCodePages ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'EnumSystemCodePagesA' :: EnumSystemCodePages
  integer(LPVOID) lpCodePageEnumProc ! CODEPAGE_ENUMPROCA lpCodePageEnumProc
  integer(DWORD) dwFlags ! DWORD dwFlags
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION PeekConsoleInput( &
        hConsoleInput, &
        lpBuffer, &
        nLength, &
        lpNumberOfEventsRead)
USE DFWINTY
  integer(BOOL) :: PeekConsoleInput ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'PeekConsoleInputA' :: PeekConsoleInput
  integer(HANDLE) hConsoleInput ! HANDLE hConsoleInput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  TYPE (T_INPUT_RECORD) lpBuffer ! PINPUT_RECORD lpBuffer
  integer(DWORD) nLength ! DWORD nLength
  integer(LPDWORD) lpNumberOfEventsRead ! LPDWORD lpNumberOfEventsRead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadConsoleInput( &
        hConsoleInput, &
        lpBuffer, &
        nLength, &
        lpNumberOfEventsRead)
USE DFWINTY
  integer(BOOL) :: ReadConsoleInput ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadConsoleInputA' :: ReadConsoleInput
  integer(HANDLE) hConsoleInput ! HANDLE hConsoleInput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  TYPE (T_INPUT_RECORD) lpBuffer ! PINPUT_RECORD lpBuffer
  integer(DWORD) nLength ! DWORD nLength
  integer(LPDWORD) lpNumberOfEventsRead ! LPDWORD lpNumberOfEventsRead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteConsoleInput( &
        hConsoleInput, &
        lpBuffer, &
        nLength, &
        lpNumberOfEventsWritten)
USE DFWINTY
  integer(BOOL) :: WriteConsoleInput ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteConsoleInputA' :: WriteConsoleInput
  integer(HANDLE) hConsoleInput ! HANDLE hConsoleInput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpBuffer
  TYPE (T_INPUT_RECORD) lpBuffer ! INPUT_RECORD* lpBuffer
  integer(DWORD) nLength ! DWORD nLength
  integer(LPDWORD) lpNumberOfEventsWritten ! LPDWORD lpNumberOfEventsWritten
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadConsoleOutput( &
        hConsoleOutput, &
        lpBuffer, &
        dwBufferSize, &
        dwBufferCoord, &
        lpReadRegion)
USE DFWINTY
  integer(BOOL) :: ReadConsoleOutput ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadConsoleOutputA' :: ReadConsoleOutput
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpBuffer
  TYPE (T_CHAR_INFO) lpBuffer ! PCHAR_INFO lpBuffer
  TYPE (T_COORD) dwBufferSize ! COORD dwBufferSize
  TYPE (T_COORD) dwBufferCoord ! COORD dwBufferCoord
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpReadRegion
  TYPE (T_SMALL_RECT) lpReadRegion ! PSMALL_RECT lpReadRegion
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteConsoleOutput( &
        hConsoleOutput, &
        lpBuffer, &
        dwBufferSize, &
        dwBufferCoord, &
        lpWriteRegion)
USE DFWINTY
  integer(BOOL) :: WriteConsoleOutput ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteConsoleOutputA' :: WriteConsoleOutput
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpBuffer
  TYPE (T_CHAR_INFO) lpBuffer ! CHAR_INFO* lpBuffer
  TYPE (T_COORD) dwBufferSize ! COORD dwBufferSize
  TYPE (T_COORD) dwBufferCoord ! COORD dwBufferCoord
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpWriteRegion
  TYPE (T_SMALL_RECT) lpWriteRegion ! PSMALL_RECT lpWriteRegion
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadConsoleOutputCharacter( &
        hConsoleOutput, &
        lpCharacter, &
        nLength, &
        dwReadCoord, &
        lpNumberOfCharsRead)
USE DFWINTY
  integer(BOOL) :: ReadConsoleOutputCharacter ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadConsoleOutputCharacterA' :: ReadConsoleOutputCharacter
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCharacter
  character*(*) lpCharacter ! LPSTR lpCharacter
  integer(DWORD) nLength ! DWORD nLength
  TYPE (T_COORD) dwReadCoord ! COORD dwReadCoord
  integer(LPDWORD) lpNumberOfCharsRead ! LPDWORD lpNumberOfCharsRead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadConsoleOutputAttribute( &
        hConsoleOutput, &
        lpAttribute, &
        nLength, &
        dwReadCoord, &
        lpNumberOfAttrsRead)
USE DFWINTY
  integer(BOOL) :: ReadConsoleOutputAttribute ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadConsoleOutputAttribute' :: ReadConsoleOutputAttribute
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  integer(LPWORD) lpAttribute ! LPWORD lpAttribute
  integer(DWORD) nLength ! DWORD nLength
  TYPE (T_COORD) dwReadCoord ! COORD dwReadCoord
  integer(LPDWORD) lpNumberOfAttrsRead ! LPDWORD lpNumberOfAttrsRead
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteConsoleOutputCharacter( &
        hConsoleOutput, &
        lpCharacter, &
        nLength, &
        dwWriteCoord, &
        lpNumberOfCharsWritten)
USE DFWINTY
  integer(BOOL) :: WriteConsoleOutputCharacter ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteConsoleOutputCharacterA' :: WriteConsoleOutputCharacter
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpCharacter
  character*(*) lpCharacter ! LPCSTR lpCharacter
  integer(DWORD) nLength ! DWORD nLength
  TYPE (T_COORD) dwWriteCoord ! COORD dwWriteCoord
  integer(LPDWORD) lpNumberOfCharsWritten ! LPDWORD lpNumberOfCharsWritten
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteConsoleOutputAttribute( &
        hConsoleOutput, &
        lpAttribute, &
        nLength, &
        dwWriteCoord, &
        lpNumberOfAttrsWritten)
USE DFWINTY
  integer(BOOL) :: WriteConsoleOutputAttribute ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteConsoleOutputAttribute' :: WriteConsoleOutputAttribute
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  integer(LPWORD) lpAttribute ! WORD* lpAttribute
  integer(DWORD) nLength ! DWORD nLength
  TYPE (T_COORD) dwWriteCoord ! COORD dwWriteCoord
  integer(LPDWORD) lpNumberOfAttrsWritten ! LPDWORD lpNumberOfAttrsWritten
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FillConsoleOutputCharacter( &
        hConsoleOutput, &
        cCharacter, &
        nLength, &
        dwWriteCoord, &
        lpNumberOfCharsWritten)
USE DFWINTY
  integer(BOOL) :: FillConsoleOutputCharacter ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FillConsoleOutputCharacterA' :: FillConsoleOutputCharacter
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  character(SCHAR) cCharacter ! CHAR cCharacter
  integer(DWORD) nLength ! DWORD nLength
  TYPE (T_COORD) dwWriteCoord ! COORD dwWriteCoord
  integer(LPDWORD) lpNumberOfCharsWritten ! LPDWORD lpNumberOfCharsWritten
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FillConsoleOutputAttribute( &
        hConsoleOutput, &
        wAttribute, &
        nLength, &
        dwWriteCoord, &
        lpNumberOfAttrsWritten)
USE DFWINTY
  integer(BOOL) :: FillConsoleOutputAttribute ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FillConsoleOutputAttribute' :: FillConsoleOutputAttribute
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  integer(WORD) wAttribute ! WORD wAttribute
  integer(DWORD) nLength ! DWORD nLength
  TYPE (T_COORD) dwWriteCoord ! COORD dwWriteCoord
  integer(LPDWORD) lpNumberOfAttrsWritten ! LPDWORD lpNumberOfAttrsWritten
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetConsoleMode( &
        hConsoleHandle, &
        lpMode)
USE DFWINTY
  integer(BOOL) :: GetConsoleMode ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetConsoleMode' :: GetConsoleMode
  integer(HANDLE) hConsoleHandle ! HANDLE hConsoleHandle
  integer(LPDWORD) lpMode ! LPDWORD lpMode
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetNumberOfConsoleInputEvents( &
        hConsoleInput, &
        lpNumberOfEvents)
USE DFWINTY
  integer(BOOL) :: GetNumberOfConsoleInputEvents ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetNumberOfConsoleInputEvents' :: GetNumberOfConsoleInputEvents
  integer(HANDLE) hConsoleInput ! HANDLE hConsoleInput
  integer(LPDWORD) lpNumberOfEvents ! LPDWORD lpNumberOfEvents
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetConsoleScreenBufferInfo( &
        hConsoleOutput, &
        lpConsoleScreenBufferInfo)
USE DFWINTY
  integer(BOOL) :: GetConsoleScreenBufferInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetConsoleScreenBufferInfo' :: GetConsoleScreenBufferInfo
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpConsoleScreenBufferInfo
  TYPE (T_CONSOLE_SCREEN_BUFFER_INFO) lpConsoleScreenBufferInfo ! PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetLargestConsoleWindowSize( &
        hConsoleOutput)
USE DFWINTY
  TYPE (T_COORD) :: GetLargestConsoleWindowSize ! COORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetLargestConsoleWindowSize' :: GetLargestConsoleWindowSize
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetConsoleCursorInfo( &
        hConsoleOutput, &
        lpConsoleCursorInfo)
USE DFWINTY
  integer(BOOL) :: GetConsoleCursorInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetConsoleCursorInfo' :: GetConsoleCursorInfo
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpConsoleCursorInfo
  TYPE (T_CONSOLE_CURSOR_INFO) lpConsoleCursorInfo ! PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetNumberOfConsoleMouseButtons( &
        lpNumberOfMouseButtons)
USE DFWINTY
  integer(BOOL) :: GetNumberOfConsoleMouseButtons ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetNumberOfConsoleMouseButtons' :: GetNumberOfConsoleMouseButtons
  integer(LPDWORD) lpNumberOfMouseButtons ! LPDWORD lpNumberOfMouseButtons
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleMode( &
        hConsoleHandle, &
        dwMode)
USE DFWINTY
  integer(BOOL) :: SetConsoleMode ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleMode' :: SetConsoleMode
  integer(HANDLE) hConsoleHandle ! HANDLE hConsoleHandle
  integer(DWORD) dwMode ! DWORD dwMode
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleActiveScreenBuffer( &
        hConsoleOutput)
USE DFWINTY
  integer(BOOL) :: SetConsoleActiveScreenBuffer ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleActiveScreenBuffer' :: SetConsoleActiveScreenBuffer
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FlushConsoleInputBuffer( &
        hConsoleInput)
USE DFWINTY
  integer(BOOL) :: FlushConsoleInputBuffer ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FlushConsoleInputBuffer' :: FlushConsoleInputBuffer
  integer(HANDLE) hConsoleInput ! HANDLE hConsoleInput
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleScreenBufferSize( &
        hConsoleOutput, &
        dwSize)
USE DFWINTY
  integer(BOOL) :: SetConsoleScreenBufferSize ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleScreenBufferSize' :: SetConsoleScreenBufferSize
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  TYPE (T_COORD) dwSize ! COORD dwSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleCursorPosition( &
        hConsoleOutput, &
        dwCursorPosition)
USE DFWINTY
  integer(BOOL) :: SetConsoleCursorPosition ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleCursorPosition' :: SetConsoleCursorPosition
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  TYPE (T_COORD) dwCursorPosition ! COORD dwCursorPosition
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleCursorInfo( &
        hConsoleOutput, &
        lpConsoleCursorInfo)
USE DFWINTY
  integer(BOOL) :: SetConsoleCursorInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleCursorInfo' :: SetConsoleCursorInfo
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpConsoleCursorInfo
  TYPE (T_CONSOLE_CURSOR_INFO) lpConsoleCursorInfo ! CONSOLE_CURSOR_INFO* lpConsoleCursorInfo
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ScrollConsoleScreenBuffer( &
        hConsoleOutput, &
        lpScrollRectangle, &
        lpClipRectangle, &
        dwDestinationOrigin, &
        lpFill)
USE DFWINTY
  integer(BOOL) :: ScrollConsoleScreenBuffer ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ScrollConsoleScreenBufferA' :: ScrollConsoleScreenBuffer
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpScrollRectangle
  TYPE (T_SMALL_RECT) lpScrollRectangle ! SMALL_RECT* lpScrollRectangle
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpClipRectangle
  TYPE (T_SMALL_RECT) lpClipRectangle ! SMALL_RECT* lpClipRectangle
  TYPE (T_COORD) dwDestinationOrigin ! COORD dwDestinationOrigin
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpFill
  TYPE (T_CHAR_INFO) lpFill ! CHAR_INFO* lpFill
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleWindowInfo( &
        hConsoleOutput, &
        bAbsolute, &
        lpConsoleWindow)
USE DFWINTY
  integer(BOOL) :: SetConsoleWindowInfo ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleWindowInfo' :: SetConsoleWindowInfo
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  integer(BOOL) bAbsolute ! BOOL bAbsolute
!DEC$ ATTRIBUTES REFERENCE, IGNORE_LOC, ALLOW_NULL :: lpConsoleWindow
  TYPE (T_SMALL_RECT) lpConsoleWindow ! SMALL_RECT* lpConsoleWindow
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleTextAttribute( &
        hConsoleOutput, &
        wAttributes)
USE DFWINTY
  integer(BOOL) :: SetConsoleTextAttribute ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleTextAttribute' :: SetConsoleTextAttribute
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  integer(WORD) wAttributes ! WORD wAttributes
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleCtrlHandler( &
        HandlerRoutine, &
        Add)
USE DFWINTY
  integer(BOOL) :: SetConsoleCtrlHandler ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleCtrlHandler' :: SetConsoleCtrlHandler
  integer(LPVOID) HandlerRoutine ! PHANDLER_ROUTINE HandlerRoutine
  integer(BOOL) Add ! BOOL Add
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GenerateConsoleCtrlEvent( &
        dwCtrlEvent, &
        dwProcessGroupId)
USE DFWINTY
  integer(BOOL) :: GenerateConsoleCtrlEvent ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GenerateConsoleCtrlEvent' :: GenerateConsoleCtrlEvent
  integer(DWORD) dwCtrlEvent ! DWORD dwCtrlEvent
  integer(DWORD) dwProcessGroupId ! DWORD dwProcessGroupId
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION AllocConsole( &
             )
USE DFWINTY
  integer(BOOL) :: AllocConsole ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'AllocConsole' :: AllocConsole
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION FreeConsole( &
             )
USE DFWINTY
  integer(BOOL) :: FreeConsole ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'FreeConsole' :: FreeConsole
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetConsoleTitle( &
        lpConsoleTitle, &
        nSize)
USE DFWINTY
  integer(DWORD) :: GetConsoleTitle ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetConsoleTitleA' :: GetConsoleTitle
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpConsoleTitle
  character*(*) lpConsoleTitle ! LPSTR lpConsoleTitle
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleTitle( &
        lpConsoleTitle)
USE DFWINTY
  integer(BOOL) :: SetConsoleTitle ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleTitleA' :: SetConsoleTitle
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpConsoleTitle
  character*(*) lpConsoleTitle ! LPCSTR lpConsoleTitle
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION ReadConsole( &
        hConsoleInput, &
        lpBuffer, &
        nNumberOfCharsToRead, &
        lpNumberOfCharsRead, &
        lpReserved)
USE DFWINTY
  integer(BOOL) :: ReadConsole ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'ReadConsoleA' :: ReadConsole
  integer(HANDLE) hConsoleInput ! HANDLE hConsoleInput
  integer(LPVOID) lpBuffer ! LPVOID lpBuffer
  integer(DWORD) nNumberOfCharsToRead ! DWORD nNumberOfCharsToRead
  integer(LPDWORD) lpNumberOfCharsRead ! LPDWORD lpNumberOfCharsRead
  integer(LPVOID) lpReserved ! LPVOID lpReserved
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION WriteConsole( &
        hConsoleOutput, &
        lpBuffer, &
        nNumberOfCharsToWrite, &
        lpNumberOfCharsWritten, &
        lpReserved)
USE DFWINTY
  integer(BOOL) :: WriteConsole ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'WriteConsoleA' :: WriteConsole
  integer(HANDLE) hConsoleOutput ! HANDLE hConsoleOutput
  integer(LPVOID)  lpBuffer ! void* lpBuffer
  integer(DWORD) nNumberOfCharsToWrite ! DWORD nNumberOfCharsToWrite
  integer(LPDWORD) lpNumberOfCharsWritten ! LPDWORD lpNumberOfCharsWritten
  integer(LPVOID) lpReserved ! LPVOID lpReserved
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION CreateConsoleScreenBuffer( &
        dwDesiredAccess, &
        dwShareMode, &
        lpSecurityAttributes, &
        dwFlags, &
        lpScreenBufferData)
USE DFWINTY
  integer(HANDLE) :: CreateConsoleScreenBuffer ! HANDLE
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'CreateConsoleScreenBuffer' :: CreateConsoleScreenBuffer
  integer(DWORD) dwDesiredAccess ! DWORD dwDesiredAccess
  integer(DWORD) dwShareMode ! DWORD dwShareMode
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: lpSecurityAttributes
  TYPE (T_SECURITY_ATTRIBUTES) lpSecurityAttributes ! SECURITY_ATTRIBUTES* lpSecurityAttributes
  integer(DWORD) dwFlags ! DWORD dwFlags
  integer(LPVOID) lpScreenBufferData ! LPVOID lpScreenBufferData
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetConsoleCP( &
             )
USE DFWINTY
  integer(UINT) :: GetConsoleCP ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetConsoleCP' :: GetConsoleCP
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleCP( &
        wCodePageID)
USE DFWINTY
  integer(BOOL) :: SetConsoleCP ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleCP' :: SetConsoleCP
  integer(UINT) wCodePageID ! UINT wCodePageID
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION GetConsoleOutputCP( &
             )
USE DFWINTY
  integer(UINT) :: GetConsoleOutputCP ! UINT
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'GetConsoleOutputCP' :: GetConsoleOutputCP
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION SetConsoleOutputCP( &
        wCodePageID)
USE DFWINTY
  integer(BOOL) :: SetConsoleOutputCP ! BOOL
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'SetConsoleOutputCP' :: SetConsoleOutputCP
  integer(UINT) wCodePageID ! UINT wCodePageID
 END FUNCTION
END INTERFACE
INTERFACE 
FUNCTION VerLanguageName( &
        wLang, &
        szLang, &
        nSize)
USE DFWINTY
  integer(DWORD) :: VerLanguageName ! DWORD
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'VerLanguageNameA' :: VerLanguageName
  integer(DWORD) wLang ! DWORD wLang
!DEC$ ATTRIBUTES REFERENCE, ALLOW_NULL :: szLang
  character*(*) szLang ! LPSTR szLang
  integer(DWORD) nSize ! DWORD nSize
 END FUNCTION
END INTERFACE
!DEC$ IF DEFINED( _M_IA64)
!moved front of file to get better windiff results
INTERFACE 
   SUBROUTINE RtlMoveMemory( &
        Destination, &
        Source, &
        Length)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RtlMoveMemory' :: RtlMoveMemory
  integer(LPVOID)  Destination ! void __unaligned* Destination
  integer(LPVOID)  Source ! void __unaligned* Source
  integer(SIZE_T) Length ! SIZE_T Length
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE RtlFillMemory( &
        Destination, &
        Length, &
        Fill)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RtlFillMemory' :: RtlFillMemory
  integer(LPVOID) Destination ! void __unaligned* Destination
  integer(SIZE_T) Length ! SIZE_T Length
  integer(BYTE) Fill ! BYTE Fill
 END SUBROUTINE
END INTERFACE
INTERFACE 
   SUBROUTINE RtlZeroMemory( &
        Destination, &
        Length)
USE DFWINTY
    !DEC$ ATTRIBUTES DEFAULT, STDCALL, DECORATE, ALIAS:'RtlZeroMemory' :: RtlZeroMemory
  integer(LPVOID) Destination ! void __unaligned* Destination
  integer(SIZE_T) Length ! SIZE_T Length
 END SUBROUTINE
END INTERFACE
!DEC$ ENDIF
!
end module kernel32
!
!DEC$ ENDIF ! /* KERNEL32_ */
