AddrInfo = object
  ai_flags*: cint            ## Input flags.
  ai_family*: cint           ## Address family of socket.
  ai_socktype*: cint         ## Socket type.
  ai_protocol*: cint         ## Protocol of socket.
  ai_addrlen*: csize_t       ## Length of socket address.
  ai_canonname*: cstring     ## Canonical name of service location.
  ai_addr*: ptr SockAddr     ## Socket address of socket.
  ai_next*: ptr AddrInfo     ## Pointer to next in list.
  

BY_HANDLE_FILE_INFORMATION {.final, pure.} = object
  dwFileAttributes*: DWORD
  ftCreationTime*: FILETIME
  ftLastAccessTime*: FILETIME
  ftLastWriteTime*: FILETIME
  dwVolumeSerialNumber*: DWORD
  nFileSizeHigh*: DWORD
  nFileSizeLow*: DWORD
  nNumberOfLinks*: DWORD
  nFileIndexHigh*: DWORD
  nFileIndexLow*: DWORD

BYTE = uint8

DWORD = int32

FILETIME {.final, pure.} = object
  dwLowDateTime*: DWORD
  dwHighDateTime*: DWORD

GUID {.final, pure.} = object
  D1*: int32
  D2*: int16
  D3*: int16
  D4*: array[0 .. 7, int8]

Handle = int

HDC = Handle

HGLRC = Handle

Hostent = object
  h_name*: cstring
  h_aliases*: cstringArray
  h_addrtype*: int16
  h_length*: int16
  h_addr_list*: cstringArray

In6_addr {.importc: "IN6_ADDR", header: "winsock2.h".} = object
  bytes* {.importc: "u.Byte".}: array[0 .. 15, char]

InAddr {.importc: "IN_ADDR", header: "winsock2.h".} = object
  s_addr*: uint32

KEY_EVENT_RECORD {.final, pure.} = object
  eventType*: int16
  bKeyDown*: WINBOOL
  wRepeatCount*: int16
  wVirtualKeyCode*: int16
  wVirtualScanCode*: int16
  uChar*: int16
  dwControlKeyState*: DWORD

LONG = int32

LPFIBER_START_ROUTINE = proc (param: pointer) {.stdcall.}

LPFILETIME = ptr FILETIME

LPINT = ptr int32

OSVERSIONINFO {.final, pure.} = object
  dwOSVersionInfoSize*: DWORD
  dwMajorVersion*: DWORD
  dwMinorVersion*: DWORD
  dwBuildNumber*: DWORD
  dwPlatformId*: DWORD
  szCSDVersion*: array[0 .. 127, WinChar]

OVERLAPPED {.pure, inheritable.} = object
  internal*: PULONG
  internalHigh*: PULONG
  offset*: DWORD
  offsetHigh*: DWORD
  hEvent*: Handle

PBOOL = ptr WINBOOL

PDWORD = ptr DWORD

POVERLAPPED = ptr OVERLAPPED

POVERLAPPED_COMPLETION_ROUTINE = proc (para1: DWORD; para2: DWORD;
                                       para3: POVERLAPPED) {.stdcall.}

PROCESS_INFORMATION {.final, pure.} = object
  hProcess*: Handle
  hThread*: Handle
  dwProcessId*: int32
  dwThreadId*: int32

Protoent = object
  p_name*: cstring
  p_aliases*: cstringArray
  p_proto*: cshort

PSID = ptr SID

PULONG = ptr int

PULONG_PTR = ptr uint

PWOHandleArray = ptr WOHandleArray

SECURITY_ATTRIBUTES {.final, pure.} = object
  nLength*: int32
  lpSecurityDescriptor*: pointer
  bInheritHandle*: WINBOOL

Servent = object
  s_name*: cstring
  s_aliases*: cstringArray
  when defined(cpu64):
      s_proto*: cstring
      s_port*: int16

  else:
      s_port*: int16
      s_proto*: cstring

  

SID {.importc, header: "<windows.h>".} = object
  Revision: BYTE
  SubAuthorityCount: BYTE
  IdentifierAuthority: SID_IDENTIFIER_AUTHORITY
  SubAuthority: ptr ptr DWORD

SID_IDENTIFIER_AUTHORITY {.importc, header: "<windows.h>".} = object
  value* {.importc: "Value".}: array[6, BYTE]

SockAddr {.importc: "SOCKADDR", header: "winsock2.h".} = object
  sa_family*: uint16
  sa_data*: array[0 .. 13, char]

Sockaddr_in {.importc: "SOCKADDR_IN", header: "winsock2.h".} = object
  sin_family*: uint16
  sin_port*: uint16
  sin_addr*: InAddr
  sin_zero*: array[0 .. 7, char]

Sockaddr_in6 {.importc: "SOCKADDR_IN6", header: "ws2tcpip.h".} = object
  sin6_family*: uint16
  sin6_port*: uint16
  sin6_flowinfo*: int32
  sin6_addr*: In6_addr
  sin6_scope_id*: int32

Sockaddr_storage {.importc: "SOCKADDR_STORAGE", header: "winsock2.h".} = object
  ss_family*: uint16
  ss_pad1: array[6, byte]
  ss_align: int64
  ss_pad2: array[112, byte]

SocketHandle = distinct int

SockLen = cuint

STARTUPINFO {.final, pure.} = object
  cb*: int32
  lpReserved*: cstring
  lpDesktop*: cstring
  lpTitle*: cstring
  dwX*: int32
  dwY*: int32
  dwXSize*: int32
  dwYSize*: int32
  dwXCountChars*: int32
  dwYCountChars*: int32
  dwFillAttribute*: int32
  dwFlags*: int32
  wShowWindow*: int16
  cbReserved2*: int16
  lpReserved2*: pointer
  hStdInput*: Handle
  hStdOutput*: Handle
  hStdError*: Handle

TFdSet = object
  fd_count*: cint
  fd_array*: array[0 .. 64 - 1, SocketHandle]

Timeval = object
  tv_sec*, tv_usec*: int32

TWSABuf {.importc: "WSABUF", header: "winsock2.h".} = object
  len*: ULONG
  buf*: cstring

ULONG = int32

ULONG_PTR = uint

WAITORTIMERCALLBACK = proc (para1: pointer; para2: int32) {.stdcall.}

WIN32_FIND_DATA {.pure.} = object
  dwFileAttributes*: int32
  ftCreationTime*: FILETIME
  ftLastAccessTime*: FILETIME
  ftLastWriteTime*: FILETIME
  nFileSizeHigh*: int32
  nFileSizeLow*: int32
  dwReserved0: int32
  dwReserved1: int32
  cFileName*: array[0 .. 260 - 1, WinChar]
  cAlternateFileName*: array[0 .. 13, WinChar]

WINBOOL = int32

WinChar = Utf16Char

WinSizeT = uint64

WOHandleArray = array[0 .. 0x00000040 - 1, Handle]

WSAData {.importc: "WSADATA", header: "winsock2.h".} = object
  wVersion, wHighVersion: int16
  szDescription: array[0 .. WSADESCRIPTION_LEN, char]
  szSystemStatus: array[0 .. WSASYS_STATUS_LEN, char]
  iMaxSockets, iMaxUdpDg: int16
  lpVendorInfo: cstring

WSAPROC_ACCEPTEX = proc (sListenSocket: SocketHandle;
                         sAcceptSocket: SocketHandle; lpOutputBuffer: pointer;
                         dwReceiveDataLength: DWORD;
                         dwLocalAddressLength: DWORD;
                         dwRemoteAddressLength: DWORD;
                         lpdwBytesReceived: ptr DWORD; lpOverlapped: POVERLAPPED): bool {.
    stdcall, ...gcsafe, raises: [].}

WSAPROC_CONNECTEX = proc (s: SocketHandle; name: ptr SockAddr; namelen: cint;
                          lpSendBuffer: pointer; dwSendDataLength: DWORD;
                          lpdwBytesSent: ptr DWORD; lpOverlapped: POVERLAPPED): bool {.
    stdcall, ...gcsafe, raises: [].}

WSAPROC_GETACCEPTEXSOCKADDRS = proc (lpOutputBuffer: pointer;
                                     dwReceiveDataLength: DWORD;
                                     dwLocalAddressLength: DWORD;
                                     dwRemoteAddressLength: DWORD;
                                     LocalSockaddr: ptr PSockAddr;
                                     LocalSockaddrLength: ptr cint;
                                     RemoteSockaddr: ptr PSockAddr;
                                     RemoteSockaddrLength: ptr cint) {.stdcall,
    ...gcsafe, raises: [].}

INVALID_SOCKET: SocketHandle

SO_ACCEPTCONN: cint

SO_BROADCAST: cint

SO_DEBUG: cint

SO_DONTLINGER: cint

SO_DONTROUTE: cint

SO_ERROR: cint

SO_EXCLUSIVEADDRUSE: cint

SO_KEEPALIVE: cint

SO_LINGER: cint

SO_OOBINLINE: cint

SO_REUSEADDR: cint

SO_REUSEPORT: cint

SO_USELOOPBACK: cint

SOL_SOCKET: cint

SOMAXCONN: cint

TCP_NODELAY: cint

WSAID_ACCEPTEX: GUID = GUID(D1: 0xB5367DF1'i32, D2: 0xCBAC'i16, D3: 0x000011CF, D4: [
    0x95'i8, 0xCA'i8, 0x00'i8, 0x80'i8, 0x5F'i8, 0x48'i8, 0xA1'i8, 0x92'i8])

WSAID_CONNECTEX: GUID = GUID(D1: 0x25A207B9, D2: 0xDDF3'i16, D3: 0x00004660, D4: [
    0x8E'i8, 0xE9'i8, 0x76'i8, 0xE5'i8, 0x8C'i8, 0x74'i8, 0x06'i8, 0x3E'i8])

WSAID_GETACCEPTEXSOCKADDRS: GUID = GUID(D1: 0xB5367DF2'i32, D2: 0xCBAC'i16,
                                        D3: 0x000011CF, D4: [0x95'i8, 0xCA'i8,
    0x00'i8, 0x80'i8, 0x5F'i8, 0x48'i8, 0xA1'i8, 0x92'i8])

AF_INET = 2

AF_INET6 = 23

AF_UNSPEC = 0

AI_V4MAPPED = 0x00000008

CREATE_ALWAYS = 2'i32

CREATE_NEW = 1'i32

CREATE_NO_WINDOW = 0x08000000'i32

CREATE_UNICODE_ENVIRONMENT = 1024'i32

DETACHED_PROCESS = 8'i32

DOMAIN_ALIAS_RID_ADMINS = 544

DUPLICATE_SAME_ACCESS = 2

ERROR_ACCESS_DENIED = 5

ERROR_BAD_ARGUMENTS = 165

ERROR_FILE_EXISTS = 80

ERROR_FILE_NOT_FOUND = 2

ERROR_HANDLE_EOF = 38

ERROR_IO_PENDING = 997

ERROR_LOCK_VIOLATION = 33

ERROR_NETNAME_DELETED = 64

ERROR_NO_MORE_FILES = 18

ERROR_PATH_NOT_FOUND = 3

FD_ACCEPT = 0x00000008'i32

FD_ADDRESS_LIST_CHANGE = 0x00000200'i32

FD_ALL_EVENTS = 0x000003FF'i32

FD_CLOSE = 0x00000020'i32

FD_CONNECT = 0x00000010'i32

FD_GROUP_QQS = 0x00000080'i32

FD_OOB = 0x00000004'i32

FD_QQS = 0x00000040'i32

FD_READ = 0x00000001'i32

FD_ROUTING_INTERFACE_CHANGE = 0x00000100'i32

FD_SETSIZE = 64

FD_WRITE = 0x00000002'i32

FIBER_FLAG_FLOAT_SWITCH = 0x00000001

FILE_ATTRIBUTE_ARCHIVE = 0x00000020'i32

FILE_ATTRIBUTE_COMPRESSED = 0x00000800'i32

FILE_ATTRIBUTE_DEVICE = 0x00000040'i32

FILE_ATTRIBUTE_DIRECTORY = 0x00000010'i32

FILE_ATTRIBUTE_HIDDEN = 0x00000002'i32

FILE_ATTRIBUTE_NORMAL = 0x00000080'i32

FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000'i32

FILE_ATTRIBUTE_OFFLINE = 0x00001000'i32

FILE_ATTRIBUTE_READONLY = 0x00000001'i32

FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400'i32

FILE_ATTRIBUTE_SPARSE_FILE = 0x00000200'i32

FILE_ATTRIBUTE_SYSTEM = 0x00000004'i32

FILE_ATTRIBUTE_TEMPORARY = 0x00000100'i32

FILE_BEGIN = 0'i32

FILE_FLAG_BACKUP_SEMANTICS = 0x02000000'i32

FILE_FLAG_DELETE_ON_CLOSE = 0x04000000'i32

FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000'i32

FILE_FLAG_NO_BUFFERING = 0x20000000'i32

FILE_FLAG_OPEN_NO_RECALL = 0x00100000'i32

FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000'i32

FILE_FLAG_OVERLAPPED = 0x40000000'i32

FILE_FLAG_POSIX_SEMANTICS = 0x01000000'i32

FILE_FLAG_RANDOM_ACCESS = 0x10000000'i32

FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000'i32

FILE_FLAG_WRITE_THROUGH = 0x80000000'i32

FILE_MAP_READ = 4'i32

FILE_MAP_WRITE = 2'i32

FILE_READ_DATA = 0x00000001

FILE_SHARE_DELETE = 4'i32

FILE_SHARE_READ = 1'i32

FILE_SHARE_WRITE = 2'i32

FILE_WRITE_DATA = 0x00000002

GENERIC_ALL = 0x10000000'i32

GENERIC_READ = 0x80000000'i32

GENERIC_WRITE = 0x40000000'i32

HANDLE_FLAG_INHERIT = 0x00000001'i32

HIGH_PRIORITY_CLASS = 128'i32

IDLE_PRIORITY_CLASS = 64'i32

INADDR_ANY = 0'u32

INADDR_BROADCAST = -1

INADDR_LOOPBACK = 0x7F000001

INADDR_NONE = -1

INFINITE = -1'i32

INVALID_FILE_SIZE = -1'i32

INVALID_HANDLE_VALUE = -1

INVALID_SET_FILE_POINTER = -1'i32

IOC_IN = 0x80000000'i32

IOC_INOUT = -1073741824'i32

IOC_OUT = 0x40000000'i32

IOC_WS2 = 0x08000000'i32

MAX_PATH = 260

MAXIMUM_WAIT_OBJECTS = 0x00000040

MOVEFILE_COPY_ALLOWED = 0x00000002'i32

MOVEFILE_CREATE_HARDLINK = 0x00000010'i32

MOVEFILE_DELAY_UNTIL_REBOOT = 0x00000004'i32

MOVEFILE_FAIL_IF_NOT_TRACKABLE = 0x00000020'i32

MOVEFILE_REPLACE_EXISTING = 0x00000001'i32

MOVEFILE_WRITE_THROUGH = 0x00000008'i32

MSG_PEEK = 2

NO_ERROR = 0'i32

NORMAL_PRIORITY_CLASS = 32'i32

OPEN_ALWAYS = 4'i32

OPEN_EXISTING = 3'i32

PAGE_EXECUTE = 0x00000010'i32

PAGE_EXECUTE_READ = 0x00000020'i32

PAGE_EXECUTE_READWRITE = 0x00000040'i32

PAGE_NOACCESS = 0x00000001'i32

PAGE_READONLY = 2'i32

PAGE_READWRITE = 4'i32

PIPE_ACCESS_DUPLEX = 0x00000003'i32

PIPE_ACCESS_INBOUND = 1'i32

PIPE_ACCESS_OUTBOUND = 2'i32

PIPE_NOWAIT = 0x00000001'i32

PROCESS_CREATE_PROCESS = 0x00000080'i32

PROCESS_CREATE_THREAD = 0x00000002'i32

PROCESS_DUP_HANDLE = 0x00000040'i32

PROCESS_QUERY_INFORMATION = 0x00000400'i32

PROCESS_QUERY_LIMITED_INFORMATION = 0x00001000'i32

PROCESS_SET_INFORMATION = 0x00000200'i32

PROCESS_SET_LIMITED_INFORMATION = 0x00002000'i32

PROCESS_SET_QUOTA = 0x00000100'i32

PROCESS_SET_SESSIONID = 0x00000004'i32

PROCESS_SUSPEND_RESUME = 0x00000800'i32

PROCESS_TERMINATE = 0x00000001'i32

PROCESS_VM_OPERATION = 0x00000008'i32

PROCESS_VM_READ = 0x00000010'i32

PROCESS_VM_WRITE = 0x00000020'i32

REALTIME_PRIORITY_CLASS = 256'i32

SECURITY_BUILTIN_DOMAIN_RID = 32

SECURITY_NT_AUTHORITY = [0'u, 0'u, 0'u, 0'u, 0'u, 5'u]

SIO_GET_EXTENSION_FUNCTION_POINTER = -939524090'i32

SO_UPDATE_ACCEPT_CONTEXT = 0x0000700B

STARTF_USESHOWWINDOW = 1'i32

STARTF_USESTDHANDLES = 256'i32

STATUS_PENDING = 0x00000103

STD_ERROR_HANDLE = -12'i32

STD_INPUT_HANDLE = -10'i32

STD_OUTPUT_HANDLE = -11'i32

STILL_ACTIVE = 0x00000103'i32

SW_SHOWNORMAL = 1'i32

SYNCHRONIZE = 0x00100000'i32

useWinUnicode = true

WAIT_FAILED = 0xFFFFFFFF'i32

WAIT_OBJECT_0 = 0'i32

WAIT_TIMEOUT = 0x00000102'i32

WSADESCRIPTION_LEN = 256

WSAEADDRINUSE = 10048

WSAECONNABORTED = 10053

WSAECONNRESET = 10054

WSAEDISCON = 10101

WSAEINPROGRESS = 10036

WSAEINTR = 10004

WSAENETRESET = 10052

WSAENOTSOCK = 10038

WSAESHUTDOWN = 10058

WSAETIMEDOUT = 10060

WSAEWOULDBLOCK = 10035

WSANOTINITIALISED = 10093

WSASYS_STATUS_LEN = 128

WT_EXECUTEDEFAULT = 0x00000000'i32

WT_EXECUTEINIOTHREAD = 0x00000001'i32

WT_EXECUTEINPERSISTENTIOTHREAD = 0x00000040'i32

WT_EXECUTEINPERSISTENTTHREAD = 0x00000080'i32

WT_EXECUTEINTIMERTHREAD = 0x00000020'i32

WT_EXECUTEINUITHREAD = 0x00000002'i32

WT_EXECUTEINWAITTHREAD = 0x00000004'i32

WT_EXECUTELONGFUNCTION = 0x00000010'i32

WT_EXECUTEONLYONCE = 0x00000008'i32

WT_TRANSFER_IMPERSONATION = 0x00000100'i32

proc `==`(x, y: SocketHandle): bool {.borrow, ...raises: [], tags: [].}

proc accept(s: SocketHandle; a: ptr SockAddr; addrlen: ptr SockLen): SocketHandle {.
    stdcall, importc: "accept", dynlib: ws2dll, ...raises: [], tags: [].}

proc allocateAndInitializeSid(pIdentifierAuthority: ptr SID_IDENTIFIER_AUTHORITY;
                              nSubAuthorityCount: BYTE; nSubAuthority0: DWORD;
                              nSubAuthority1: DWORD; nSubAuthority2: DWORD;
                              nSubAuthority3: DWORD; nSubAuthority4: DWORD;
                              nSubAuthority5: DWORD; nSubAuthority6: DWORD;
                              nSubAuthority7: DWORD; pSid: ptr PSID): WINBOOL {.
    stdcall, dynlib: "Advapi32", importc: "AllocateAndInitializeSid",
    ...raises: [], tags: [].}

proc bindSocket(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint {.
    stdcall, importc: "bind", dynlib: ws2dll, ...raises: [], tags: [].}

proc checkTokenMembership(tokenHandle: Handle; sidToCheck: PSID; isMember: PBOOL): WINBOOL {.
    stdcall, dynlib: "Advapi32", importc: "CheckTokenMembership", ...raises: [],
    tags: [].}

proc closeHandle(hObject: Handle): WINBOOL {.stdcall, dynlib: "kernel32",
    importc: "CloseHandle", ...raises: [], tags: [].}

proc closesocket(s: SocketHandle): cint {.stdcall, importc: "closesocket",
    dynlib: ws2dll, ...raises: [], tags: [].}

proc connect(s: SocketHandle; name: ptr SockAddr; namelen: SockLen): cint {.
    stdcall, importc: "connect", dynlib: ws2dll, ...raises: [], tags: [].}

proc ConvertThreadToFiber(param: pointer): pointer {.stdcall, discardable,
    dynlib: "kernel32", importc, ...raises: [], tags: [].}

proc ConvertThreadToFiberEx(param: pointer; flags: int32): pointer {.stdcall,
    discardable, dynlib: "kernel32", importc, ...raises: [], tags: [].}

proc copyFileW(lpExistingFileName, lpNewFileName: WideCString;
               bFailIfExists: WINBOOL): WINBOOL {.importc: "CopyFileW", stdcall,
    dynlib: "kernel32", sideEffect, ...raises: [], tags: [].}

proc createDirectoryW(pathName: WideCString; security: pointer = nil): int32 {.
    importc: "CreateDirectoryW", dynlib: "kernel32", stdcall, sideEffect,
    ...raises: [], tags: [].}

proc createEvent(lpEventAttributes: ptr SECURITY_ATTRIBUTES;
                 bManualReset: DWORD; bInitialState: DWORD;
                 lpName: ptr Utf16Char): Handle {.stdcall, dynlib: "kernel32",
    importc: "CreateEventW", ...raises: [], tags: [].}

proc CreateFiber(stackSize: int; fn: LPFIBER_START_ROUTINE; param: pointer): pointer {.
    stdcall, discardable, dynlib: "kernel32", importc, ...raises: [], tags: [].}

proc CreateFiberEx(stkCommit: int; stkReserve: int; flags: int32;
                   fn: LPFIBER_START_ROUTINE; param: pointer): pointer {.
    stdcall, discardable, dynlib: "kernel32", importc, ...raises: [], tags: [].}

proc createFileA(lpFileName: cstring; dwDesiredAccess, dwShareMode: DWORD;
                 lpSecurityAttributes: pointer;
                 dwCreationDisposition, dwFlagsAndAttributes: DWORD;
                 hTemplateFile: Handle): Handle {.stdcall, dynlib: "kernel32",
    importc: "CreateFileA", ...raises: [], tags: [].}

proc createFileMappingW(hFile: Handle; lpFileMappingAttributes: pointer;
                        flProtect, dwMaximumSizeHigh: DWORD;
                        dwMaximumSizeLow: DWORD; lpName: pointer): Handle {.
    stdcall, dynlib: "kernel32", importc: "CreateFileMappingW", ...raises: [],
    tags: [].}

proc createFileW(lpFileName: WideCString; dwDesiredAccess, dwShareMode: DWORD;
                 lpSecurityAttributes: pointer;
                 dwCreationDisposition, dwFlagsAndAttributes: DWORD;
                 hTemplateFile: Handle): Handle {.stdcall, dynlib: "kernel32",
    importc: "CreateFileW", ...raises: [], tags: [].}

proc createHardLinkW(lpFileName, lpExistingFileName: WideCString;
                     security: pointer = nil): int32 {.
    importc: "CreateHardLinkW", dynlib: "kernel32", stdcall, sideEffect,
    ...raises: [], tags: [].}

proc createIoCompletionPort(FileHandle: Handle; ExistingCompletionPort: Handle;
                            CompletionKey: ULONG_PTR;
                            NumberOfConcurrentThreads: DWORD): Handle {.stdcall,
    dynlib: "kernel32", importc: "CreateIoCompletionPort", ...raises: [], tags: [].}

proc createNamedPipe(lpName: WideCString; dwOpenMode, dwPipeMode, nMaxInstances,
    nOutBufferSize, nInBufferSize, nDefaultTimeOut: int32;
                     lpSecurityAttributes: ptr SECURITY_ATTRIBUTES): Handle {.
    stdcall, dynlib: "kernel32", importc: "CreateNamedPipeW", sideEffect,
    ...raises: [], tags: [].}

proc createPipe(hReadPipe, hWritePipe: var Handle;
                lpPipeAttributes: var SECURITY_ATTRIBUTES; nSize: int32): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "CreatePipe", sideEffect, ...raises: [],
    tags: [].}

proc createProcessW(lpApplicationName, lpCommandLine: WideCString;
                    lpProcessAttributes: ptr SECURITY_ATTRIBUTES;
                    lpThreadAttributes: ptr SECURITY_ATTRIBUTES;
                    bInheritHandles: WINBOOL; dwCreationFlags: int32;
                    lpEnvironment, lpCurrentDirectory: WideCString;
                    lpStartupInfo: var STARTUPINFO;
                    lpProcessInformation: var PROCESS_INFORMATION): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "CreateProcessW", sideEffect,
    ...raises: [], tags: [].}

proc createSymbolicLinkW(lpSymlinkFileName, lpTargetFileName: WideCString;
                         flags: DWORD): int32 {.importc: "CreateSymbolicLinkW",
    dynlib: "kernel32", stdcall, sideEffect, ...raises: [], tags: [].}

proc DeleteFiber(fiber: pointer) {.stdcall, discardable, dynlib: "kernel32",
                                   importc, ...raises: [], tags: [].}

proc deleteFileA(pathName: cstring): int32 {.importc: "DeleteFileA",
    dynlib: "kernel32", stdcall, ...raises: [], tags: [].}

proc deleteFileW(pathName: WideCString): int32 {.importc: "DeleteFileW",
    dynlib: "kernel32", stdcall, ...raises: [], tags: [].}

proc duplicateHandle(hSourceProcessHandle: Handle; hSourceHandle: Handle;
                     hTargetProcessHandle: Handle; lpTargetHandle: ptr Handle;
                     dwDesiredAccess: DWORD; bInheritHandle: WINBOOL;
                     dwOptions: DWORD): WINBOOL {.stdcall, dynlib: "kernel32",
    importc: "DuplicateHandle", ...raises: [], tags: [].}

proc FD_ISSET(socket: SocketHandle; set: var TFdSet): cint {....raises: [],
    tags: [].}

proc FD_SET(socket: SocketHandle; s: var TFdSet) {....raises: [], tags: [].}

proc FD_ZERO(s: var TFdSet) {....raises: [], tags: [].}

proc findClose(hFindFile: Handle) {.stdcall, dynlib: "kernel32",
                                    importc: "FindClose", ...raises: [], tags: [].}

proc findFirstFileW(lpFileName: WideCString; lpFindFileData: var WIN32_FIND_DATA): Handle {.
    stdcall, dynlib: "kernel32", importc: "FindFirstFileW", sideEffect,
    ...raises: [], tags: [].}

proc findNextFileW(hFindFile: Handle; lpFindFileData: var WIN32_FIND_DATA): int32 {.
    stdcall, dynlib: "kernel32", importc: "FindNextFileW", sideEffect,
    ...raises: [], tags: [].}

proc flushFileBuffers(hFile: Handle): WINBOOL {.stdcall, dynlib: "kernel32",
    importc: "FlushFileBuffers", sideEffect, ...raises: [], tags: [].}

proc flushViewOfFile(lpBaseAddress: pointer; dwNumberOfBytesToFlush: DWORD): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "FlushViewOfFile", ...raises: [],
    tags: [].}

proc formatMessageW(dwFlags: int32; lpSource: pointer;
                    dwMessageId, dwLanguageId: int32; lpBuffer: pointer;
                    nSize: int32; arguments: pointer): int32 {.
    importc: "FormatMessageW", stdcall, dynlib: "kernel32", ...raises: [], tags: [].}

proc freeaddrinfo(ai: ptr AddrInfo) {.stdcall, importc: "freeaddrinfo",
                                      dynlib: ws2dll, ...raises: [], tags: [].}

proc freeEnvironmentStringsW(para1: WideCString): int32 {.stdcall,
    dynlib: "kernel32", importc: "FreeEnvironmentStringsW", sideEffect,
    ...raises: [], tags: [].}

proc freeSid(pSid: PSID): PSID {.stdcall, dynlib: "Advapi32",
                                 importc: "FreeSid", ...raises: [], tags: [].}

proc get_osfhandle(fd: FileHandle): Handle {.importc: "_get_osfhandle",
    header: "<io.h>", ...raises: [], tags: [].}

proc getaddrinfo(nodename, servname: cstring; hints: ptr AddrInfo;
                 res: var ptr AddrInfo): cint {.stdcall, importc: "getaddrinfo",
    dynlib: ws2dll, ...raises: [], tags: [].}

proc getCommandLineW(): WideCString {.importc: "GetCommandLineW", stdcall,
                                      dynlib: "kernel32", sideEffect,
                                      ...raises: [], tags: [].}

proc getCurrentDirectoryW(nBufferLength: int32; lpBuffer: WideCString): int32 {.
    importc: "GetCurrentDirectoryW", dynlib: "kernel32", stdcall, sideEffect,
    ...raises: [], tags: [].}

proc GetCurrentFiber(): pointer {.stdcall, importc, header: "windows.h",
                                  ...raises: [], tags: [].}

proc getCurrentProcess(): Handle {.stdcall, dynlib: "kernel32",
                                   importc: "GetCurrentProcess", ...raises: [],
                                   tags: [].}

proc getEnvironmentStringsW(): WideCString {.stdcall, dynlib: "kernel32",
    importc: "GetEnvironmentStringsW", sideEffect, ...raises: [], tags: [].}

proc getExitCodeProcess(hProcess: Handle; lpExitCode: var int32): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "GetExitCodeProcess", ...raises: [],
    tags: [].}

proc getFileAttributesW(lpFileName: WideCString): int32 {.stdcall,
    dynlib: "kernel32", importc: "GetFileAttributesW", sideEffect, ...raises: [],
    tags: [].}

proc getFileInformationByHandle(hFile: Handle; lpFileInformation: ptr BY_HANDLE_FILE_INFORMATION): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "GetFileInformationByHandle",
    sideEffect, ...raises: [], tags: [].}

proc getFileSize(hFile: Handle; lpFileSizeHigh: ptr DWORD): DWORD {.stdcall,
    dynlib: "kernel32", importc: "GetFileSize", ...raises: [], tags: [].}

proc getFullPathNameW(lpFileName: WideCString; nBufferLength: int32;
                      lpBuffer: WideCString; lpFilePart: var WideCString): int32 {.
    stdcall, dynlib: "kernel32", importc: "GetFullPathNameW", sideEffect,
    ...raises: [], tags: [].}

proc getHandleInformation(hObject: Handle; lpdwFlags: ptr DWORD): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "GetHandleInformation", ...raises: [],
    tags: [].}

proc gethostbyaddr(ip: ptr InAddr; len: cuint; theType: cint): ptr Hostent {.
    stdcall, importc: "gethostbyaddr", dynlib: ws2dll, sideEffect, ...raises: [],
    tags: [].}

proc gethostbyname(name: cstring): ptr Hostent {.stdcall,
    importc: "gethostbyname", dynlib: ws2dll, sideEffect, ...raises: [], tags: [].}

proc gethostname(hostname: cstring; len: cint): cint {.stdcall,
    importc: "gethostname", dynlib: ws2dll, sideEffect, ...raises: [], tags: [].}

proc getLastError(): int32 {.importc: "GetLastError", stdcall,
                             dynlib: "kernel32", sideEffect, ...raises: [],
                             tags: [].}

proc getModuleFileNameW(handle: Handle; buf: WideCString; size: int32): int32 {.
    importc: "GetModuleFileNameW", dynlib: "kernel32", stdcall, ...raises: [],
    tags: [].}

proc getnameinfo(a1: ptr SockAddr; a2: SockLen; a3: cstring; a4: SockLen;
                 a5: cstring; a6: SockLen; a7: cint): cint {.stdcall,
    importc: "getnameinfo", dynlib: ws2dll, ...raises: [], tags: [].}

proc getOverlappedResult(hFile: Handle; lpOverlapped: POVERLAPPED;
                         lpNumberOfBytesTransferred: var DWORD; bWait: WINBOOL): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "GetOverlappedResult", ...raises: [],
    tags: [].}

proc getpeername(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint {.
    stdcall, importc, dynlib: ws2dll, ...raises: [], tags: [].}

proc getProcessTimes(hProcess: Handle; lpCreationTime, lpExitTime, lpKernelTime,
                                       lpUserTime: var FILETIME): WINBOOL {.
    stdcall, dynlib: "kernel32", importc: "GetProcessTimes", ...raises: [],
    tags: [].}

proc getprotobyname(name: cstring): ptr Protoent {.stdcall,
    importc: "getprotobyname", dynlib: ws2dll, sideEffect, ...raises: [], tags: [].}

proc getprotobynumber(proto: cint): ptr Protoent {.stdcall,
    importc: "getprotobynumber", dynlib: ws2dll, sideEffect, ...raises: [],
    tags: [].}

proc getQueuedCompletionStatus(CompletionPort: Handle;
                               lpNumberOfBytesTransferred: PDWORD;
                               lpCompletionKey: PULONG_PTR;
                               lpOverlapped: ptr POVERLAPPED;
                               dwMilliseconds: DWORD): WINBOOL {.stdcall,
    dynlib: "kernel32", importc: "GetQueuedCompletionStatus", ...raises: [],
    tags: [].}

proc getservbyname(name, proto: cstring): ptr Servent {.stdcall,
    importc: "getservbyname", dynlib: ws2dll, sideEffect, ...raises: [], tags: [].}

proc getservbyport(port: cint; proto: cstring): ptr Servent {.stdcall,
    importc: "getservbyport", dynlib: ws2dll, sideEffect, ...raises: [], tags: [].}

proc getsockname(s: SocketHandle; name: ptr SockAddr; namelen: ptr SockLen): cint {.
    stdcall, importc: "getsockname", dynlib: ws2dll, ...raises: [], tags: [].}

proc getsockopt(s: SocketHandle; level, optname: cint; optval: pointer;
                optlen: ptr SockLen): cint {.stdcall, importc: "getsockopt",
    dynlib: ws2dll, ...raises: [], tags: [].}

proc getStdHandle(nStdHandle: int32): Handle {.stdcall, dynlib: "kernel32",
    importc: "GetStdHandle", ...raises: [], tags: [].}

proc getSystemTimeAsFileTime(lpSystemTimeAsFileTime: var FILETIME) {.
    importc: "GetSystemTimeAsFileTime", dynlib: "kernel32", stdcall, sideEffect,
    ...raises: [], tags: [].}