snapshot before regression test

Test/TestProject2/temp/0035c95a18d4f8e8.pyi

@@ -0,0 +1,81 @@
+"""
+Auto-generated Python stub file from w32.fileio.py
+Module: w32.fileio
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import w32.win32base
+import w32.win32file
+
+class MODE(t.CEnum):
+    R = 0
+    W = 1
+    A = 2
+    RP = 3
+    WP = 4
+    AP = 5
+    X = 6
+    XP = 7
+class FRESULT(t.CEnum):
+    OK = 0
+    ERR = -1
+    ERR_CLOSED = -2
+    ERR_PERM = -3
+    ERR_IO = -4
+    ERR_NOTFOUND = -5
+
+SEEK_SET: t.CDefine = 0
+SEEK_CUR: t.CDefine = 1
+SEEK_END: t.CDefine = 2
+INVALID_SET_FILE_POINTER: t.CDefine = -1
+SHARE_READ: t.CDefine = 0x00000001
+SHARE_WRITE: t.CDefine = 0x00000002
+SHARE_DELETE: t.CDefine = 0x00000004
+
+class File:
+    handle: w32.win32base.HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: File, filename: str, mode: ULONG, share: ULONG) -> t.CInt: pass
+    def __enter__(self: File) -> 'File' | t.CPtr: pass
+    def __exit__(self: File) -> t.CInt: pass
+    def read(self: File, buf: bytes, count: ULONG) -> LONG: pass
+    def write(self: File, buf: bytes, count: ULONG) -> LONG: pass
+    def write_str(self: File, s: str) -> LONG: pass
+    def seek(self: File, offset: LONG, origin: ULONG) -> LONG: pass
+    def tell(self: File) -> LONG: pass
+    def close(self: File) -> LONG: pass
+    def flush(self: File) -> LONG: pass
+    def size(self: File) -> LONGLONG: pass
+    def readline(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
+    def read_all(self: File, buf: bytes, max_count: ULONG) -> LONG: pass
+class FileW:
+    handle: w32.win32base.HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: FileW, filename: w32.win32base.LPCWSTR, mode: ULONG, share: ULONG) -> t.CInt: pass
+    def __enter__(self: FileW) -> 'FileW' | t.CPtr: pass
+    def __exit__(self: FileW) -> t.CInt: pass
+    def read(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
+    def write(self: FileW, buf: bytes, count: ULONG) -> LONG: pass
+    def write_str(self: FileW, s: str) -> LONG: pass
+    def seek(self: FileW, offset: LONG, origin: ULONG) -> LONG: pass
+    def tell(self: FileW) -> LONG: pass
+    def close(self: FileW) -> LONG: pass
+    def flush(self: FileW) -> LONG: pass
+    def size(self: FileW) -> LONGLONG: pass
+    def readline(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
+    def read_all(self: FileW, buf: bytes, max_count: ULONG) -> LONG: pass
+
+def open(filename: str, mode: ULONG, share: ULONG) -> File | t.CPtr: pass
+
+def openw(filename: LPCWSTR, mode: ULONG, share: ULONG) -> FileW | t.CPtr: pass

Test/TestProject2/temp/067c78e9f121dce3.pyi

@@ -0,0 +1,136 @@
+"""
+Auto-generated Python stub file from w32.win32process.py
+Module: w32.win32process
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+PROCESS_TERMINATE: t.CDefine = 0x0001
+PROCESS_CREATE_THREAD: t.CDefine = 0x0002
+PROCESS_VM_OPERATION: t.CDefine = 0x0008
+PROCESS_VM_READ: t.CDefine = 0x0010
+PROCESS_VM_WRITE: t.CDefine = 0x0020
+PROCESS_QUERY_INFORMATION: t.CDefine = 0x0400
+PROCESS_ALL_ACCESS: t.CDefine = 0x001FFFFF
+THREAD_TERMINATE: t.CDefine = 0x0001
+THREAD_SUSPEND_RESUME: t.CDefine = 0x0002
+THREAD_GET_CONTEXT: t.CDefine = 0x0008
+THREAD_SET_CONTEXT: t.CDefine = 0x0010
+THREAD_QUERY_INFORMATION: t.CDefine = 0x0040
+THREAD_ALL_ACCESS: t.CDefine = 0x001FFFFF
+CREATE_SUSPENDED: t.CDefine = 0x00000004
+CREATE_NEW_CONSOLE: t.CDefine = 0x00000010
+CREATE_NEW_PROCESS_GROUP: t.CDefine = 0x00000200
+CREATE_NO_WINDOW: t.CDefine = 0x08000000
+DETACHED_PROCESS: t.CDefine = 0x00000008
+STARTF_USESHOWWINDOW: t.CDefine = 0x00000001
+STARTF_USESTDHANDLES: t.CDefine = 0x00000100
+SW_HIDE: t.CDefine = 0
+SW_SHOW: t.CDefine = 5
+SW_MINIMIZE: t.CDefine = 6
+NORMAL_PRIORITY_CLASS: t.CDefine = 0x00000020
+IDLE_PRIORITY_CLASS: t.CDefine = 0x00000040
+HIGH_PRIORITY_CLASS: t.CDefine = 0x00000080
+REALTIME_PRIORITY_CLASS: t.CDefine = 0x00000100
+BELOW_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00004000
+ABOVE_NORMAL_PRIORITY_CLASS: t.CDefine = 0x00008000
+STILL_ACTIVE: t.CDefine = 259
+
+class STARTUPINFOA:
+    cb: ULONG
+    lpReserved: CHARPTR
+    lpDesktop: CHARPTR
+    lpTitle: CHARPTR
+    dwX: ULONG
+    dwY: ULONG
+    dwXSize: ULONG
+    dwYSize: ULONG
+    dwXCountChars: ULONG
+    dwYCountChars: ULONG
+    dwFillAttribute: ULONG
+    dwFlags: ULONG
+    wShowWindow: WORD
+    cbReserved2: WORD
+    lpReserved2: VOIDPTR
+    hStdInput: HANDLE
+    hStdOutput: HANDLE
+    hStdError: HANDLE
+class STARTUPINFOW:
+    cb: ULONG
+    lpReserved: WCHARPTR
+    lpDesktop: WCHARPTR
+    lpTitle: WCHARPTR
+    dwX: ULONG
+    dwY: ULONG
+    dwXSize: ULONG
+    dwYSize: ULONG
+    dwXCountChars: ULONG
+    dwYCountChars: ULONG
+    dwFillAttribute: ULONG
+    dwFlags: ULONG
+    wShowWindow: WORD
+    cbReserved2: WORD
+    lpReserved2: VOIDPTR
+    hStdInput: HANDLE
+    hStdOutput: HANDLE
+    hStdError: HANDLE
+class PROCESS_INFORMATION:
+    hProcess: HANDLE
+    hThread: HANDLE
+    dwProcessId: ULONG
+    dwThreadId: ULONG
+
+def CreateProcessA(lpApplicationName: LPCSTR, lpCommandLine: CHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCSTR, lpStartupInfo: STARTUPINFOA | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def CreateProcessW(lpApplicationName: LPCWSTR, lpCommandLine: WCHARPTR, lpProcessAttributes: SECURITY_ATTRIBUTES | t.CPtr, lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInheritHandles: BOOL, dwCreationFlags: ULONG, lpEnvironment: VOIDPTR, lpCurrentDirectory: LPCWSTR, lpStartupInfo: STARTUPINFOW | t.CPtr, lpProcessInformation: PROCESS_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL | t.State: pass
+
+def GetExitCodeProcess(hProcess: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def GetExitCodeThread(hThread: HANDLE, lpExitCode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def OpenProcess(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwProcessId: ULONG) -> HANDLE | t.State: pass
+
+def GetCurrentProcess() -> HANDLE | t.State: pass
+
+def GetCurrentProcessId() -> ULONG | t.State: pass
+
+def CreateThread(lpThreadAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwStackSize: t.CSizeT, lpStartAddress: VOIDPTR, lpParameter: VOIDPTR, dwCreationFlags: ULONG, lpThreadId: ULONG | t.CPtr) -> HANDLE | t.State: pass
+
+def OpenThread(dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwThreadId: ULONG) -> HANDLE | t.State: pass
+
+def SuspendThread(hThread: HANDLE) -> ULONG | t.State: pass
+
+def ResumeThread(hThread: HANDLE) -> ULONG | t.State: pass
+
+def TerminateThread(hThread: HANDLE, dwExitCode: ULONG) -> BOOL | t.State: pass
+
+def GetCurrentThread() -> HANDLE | t.State: pass
+
+def GetCurrentThreadId() -> ULONG | t.State: pass
+
+def GetThreadId(hThread: HANDLE) -> ULONG | t.State: pass
+
+def GetProcessId(hProcess: HANDLE) -> ULONG | t.State: pass
+
+def SetThreadPriority(hThread: HANDLE, nPriority: INT) -> BOOL | t.State: pass
+
+def GetThreadPriority(hThread: HANDLE) -> INT | t.State: pass
+
+def ExitProcess(uExitCode: UINT) -> VOID | t.State: pass
+
+def ExitThread(dwExitCode: ULONG) -> VOID | t.State: pass
+
+def TlsAlloc() -> ULONG | t.State: pass
+
+def TlsFree(dwTlsIndex: ULONG) -> BOOL | t.State: pass
+
+def TlsGetValue(dwTlsIndex: ULONG) -> VOIDPTR | t.State: pass
+
+def TlsSetValue(dwTlsIndex: ULONG, lpTlsValue: VOIDPTR) -> BOOL | t.State: pass

Test/TestProject2/temp/06f53cc594b4ac6c.pyi

@@ -0,0 +1,109 @@
+"""
+Auto-generated Python stub file from w32.win32sync.py
+Module: w32.win32sync
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+class CRITICAL_SECTION:
+    DebugInfo: VOIDPTR
+    LockCount: LONG
+    RecursionCount: LONG
+    OwningThread: HANDLE
+    LockSemaphore: HANDLE
+    SpinCount: QWORD
+
+def InitializeCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def EnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def LeaveCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def DeleteCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> VOID | t.State: pass
+
+def TryEnterCriticalSection(lpCriticalSection: CRITICAL_SECTION | t.CPtr) -> BOOL | t.State: pass
+
+def SetCriticalSectionSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> ULONG | t.State: pass
+
+def InitializeCriticalSectionAndSpinCount(lpCriticalSection: CRITICAL_SECTION | t.CPtr, dwSpinCount: ULONG) -> BOOL | t.State: pass
+
+def CreateMutexA(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateMutexW(lpMutexAttributes: SECURITY_ATTRIBUTES | t.CPtr, bInitialOwner: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenMutexA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenMutexW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def ReleaseMutex(hMutex: HANDLE) -> BOOL | t.State: pass
+
+def CreateEventA(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateEventW(lpEventAttributes: SECURITY_ATTRIBUTES | t.CPtr, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenEventA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenEventW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def SetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def ResetEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def PulseEvent(hEvent: HANDLE) -> BOOL | t.State: pass
+
+def CreateSemaphoreA(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def CreateSemaphoreW(lpSemaphoreAttributes: SECURITY_ATTRIBUTES | t.CPtr, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def OpenSemaphoreA(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE | t.State: pass
+
+def OpenSemaphoreW(dwDesiredAccess: ULONG, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE | t.State: pass
+
+def ReleaseSemaphore(hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LONG | t.CPtr) -> BOOL | t.State: pass
+
+def WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: ULONG) -> ULONG | t.State: pass
+
+def WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def WaitForMultipleObjects(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG) -> ULONG | t.State: pass
+
+def WaitForMultipleObjectsEx(nCount: ULONG, lpHandles: VOIDPTR, bWaitAll: BOOL, dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def InitializeSRWLock(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def AcquireSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def AcquireSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def ReleaseSRWLockExclusive(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+def ReleaseSRWLockShared(SRWLock: VOIDPTR) -> VOID | t.State: pass
+
+
+CONDITION_VARIABLE_LOCKMODE_SHARED: t.CDefine = 0x1
+
+def InitializeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
+
+def SleepConditionVariableCS(ConditionVariable: VOIDPTR, CriticalSection: CRITICAL_SECTION | t.CPtr, dwMilliseconds: ULONG) -> BOOL | t.State: pass
+
+def SleepConditionVariableSRW(ConditionVariable: VOIDPTR, SRWLock: VOIDPTR, dwMilliseconds: ULONG, Flags: ULONG) -> BOOL | t.State: pass
+
+def WakeConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
+
+def WakeAllConditionVariable(ConditionVariable: VOIDPTR) -> VOID | t.State: pass
+
+
+INIT_ONCE_STATIC_INIT: t.CDefine = 0x00000001
+INIT_ONCE_CHECK_ONLY:  t.CDefine = 0x00000002
+INIT_ONCE_ASYNC:       t.CDefine = 0x00000004
+INIT_ONCE_INIT_FAILED: t.CDefine = 0x00000008
+
+class INIT_ONCE:
+    Ptr: t.CPtr
+
+def InitOnceExecuteOnce(InitOnce: INIT_ONCE | t.CPtr, InitFn: VOIDPTR, Parameter: VOIDPTR, Context: VOIDPTR | t.CPtr) -> BOOL | t.State: pass

Test/TestProject2/temp/0df65b8ed15664b0.pyi

@@ -0,0 +1,30 @@
+"""
+Auto-generated Python stub file from hashlib.__sha1.py
+Module: hashlib.__sha1
+"""
+
+
+import string
+import t, c
+
+SHA1_BLOCK_LEN:  t.CDefine = 64
+SHA1_DIGEST_LEN: t.CDefine = 20
+
+def sha1_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
+
+def sha1_f1(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+def sha1_f2(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+def sha1_f3(b: t.CUInt32T, c: t.CUInt32T, d: t.CUInt32T) -> t.CUInt32T: pass
+
+
+@t.Object
+class sha1:
+    state: t.CArray[t.CUInt32T, 5]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA1_BLOCK_LEN]
+    def __init__(self: sha1) -> t.CInt: pass
+    def transform(self: sha1, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha1, s: str) -> t.CInt: pass
+    def final(self: sha1, out: t.CArray[t.CUInt8T, SHA1_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/19f8024d10c828e8.pyi

@@ -0,0 +1,35 @@
+"""
+Auto-generated Python stub file from hashlib.__md5.py
+Module: hashlib.__md5
+"""
+
+
+import string
+import t, c
+
+MD5_BLOCK_LEN:  t.CDefine = 64    # 分组块大小
+MD5_DIGEST_LEN: t.CDefine = 16    # 摘要输出长度
+
+def md5_F(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_G(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_H(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_I(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def md5_rotl(x: t.CUInt32T, n: t.CInt) -> t.CUInt32T: pass
+
+
+md5_T: t.CExtern | t.CArray[t.CUInt32T, 64]
+md5_S: t.CExtern | t.CArray[t.CInt, 64]
+
+@t.Object
+class md5:
+    state: t.CArray[t.CUInt32T, 4]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, MD5_BLOCK_LEN]
+    def __init__(self: md5) -> t.CInt: pass
+    def transform(self: md5, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: md5, s: str) -> t.CInt: pass
+    def final(self: md5, out: t.CArray[t.CUInt8T, MD5_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/1c46d554b3a3f9f3.pyi

@@ -0,0 +1,125 @@
+"""
+Auto-generated Python stub file from zlib.pyzlib.py
+Module: zlib.pyzlib
+"""
+
+
+from stdint import *
+import zlib.zdeflate as zdeflate
+import zlib.zinflate as zinflate
+import zlib.zchecksum as zchecksum
+import zlib.zdef as zdef
+import zlib.zhuff as zhuff
+import stdlib
+import string
+import memhub
+import t, c
+
+Z_NO_COMPRESSION:      t.CDefine = 0
+Z_BEST_SPEED:          t.CDefine = 1
+Z_BEST_COMPRESSION:    t.CDefine = 9
+Z_DEFAULT_COMPRESSION: t.CDefine = (-1)
+DEFLATED:              t.CDefine = 8
+Z_NO_FLUSH:            t.CDefine = 0
+Z_PARTIAL_FLUSH:       t.CDefine = 1
+Z_SYNC_FLUSH:          t.CDefine = 2
+Z_FULL_FLUSH:          t.CDefine = 3
+Z_FINISH:              t.CDefine = 4
+Z_BLOCK:               t.CDefine = 5
+Z_TREES:               t.CDefine = 6
+Z_DEFAULT_STRATEGY: t.CDefine = 0
+Z_FILTERED:         t.CDefine = 1
+Z_HUFFMAN_ONLY:     t.CDefine = 2
+Z_RLE:              t.CDefine = 3
+Z_FIXED:            t.CDefine = 4
+Z_OK:            t.CDefine = 0
+Z_STREAM_END:    t.CDefine = 1
+Z_NEED_DICT:     t.CDefine = 2
+Z_ERRNO:         t.CDefine = (-1)
+Z_STREAM_ERROR:  t.CDefine = (-2)
+Z_DATA_ERROR:    t.CDefine = (-3)
+Z_MEM_ERROR:     t.CDefine = (-4)
+Z_BUF_ERROR:     t.CDefine = (-5)
+Z_VERSION_ERROR: t.CDefine = (-6)
+MAX_WBITS:       t.CDefine = 15
+DEF_BUF_SIZE:    t.CDefine = 16384
+DEF_MEM_LEVEL:   t.CDefine = 8
+ZLIB_VERSION:    t.CDefine = "1.3.2"
+pyzlib_error_msg: t.CExtern | t.CArray[t.CChar, 512]
+pyzlib_error_code_val: t.CExtern | t.CInt
+
+@t.Object
+class Compress:
+    pool: memhub.MemManager | t.CPtr
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    is_finished: t.CInt
+    level: t.CInt
+    method: t.CInt
+    wbits: t.CInt
+    memLevel: t.CInt
+    strategy: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    last_pos: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    header_written: t.CInt
+    def compress(self: Compress, data: BYTEPTR, data_len: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Compress, mode: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Compress) -> Compress | t.CPtr: pass
+    def delete(self: Compress) -> t.CInt: pass
+    def __del__(self: Compress) -> t.CInt: pass
+@t.Object
+class Decompress:
+    pool: memhub.MemManager | t.CPtr
+    stream: VOIDPTR
+    is_initialized: t.CInt
+    eof: t.CInt
+    wbits: t.CInt
+    zdict: BYTEPTR
+    zdict_len: t.CSizeT
+    _unused_data: BYTEPTR
+    _unused_data_len: t.CSizeT
+    _unused_data_cap: t.CSizeT
+    _unconsumed_tail: BYTEPTR
+    _unconsumed_tail_len: t.CSizeT
+    _unconsumed_tail_cap: t.CSizeT
+    input_buf: BYTEPTR
+    input_buf_len: t.CSizeT
+    input_buf_cap: t.CSizeT
+    def decompress(self: Decompress, data: BYTEPTR, data_len: t.CSizeT, max_length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def flush(self: Decompress, length: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def copy(self: Decompress) -> Decompress | t.CPtr: pass
+    def delete(self: Decompress) -> t.CInt: pass
+    def unused_data(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+    def unconsumed_tail(self: Decompress, length: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def set_error(code: int, msg: str) -> t.CInt: pass
+
+def clone_bytes(pool: memhub.MemManager | t.CPtr, src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def append_bytes(pool: memhub.MemManager | t.CPtr, buf: BYTE | t.CPtr[t.CPtr], length: t.CSizeT | t.CPtr, cap: t.CSizeT | t.CPtr, data: BYTEPTR, data_len: t.CSizeT) -> t.CInt: pass
+
+def shrink_to_fit(pool: memhub.MemManager | t.CPtr, buf: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def runtime_version() -> str: pass
+
+def get_error() -> str: pass
+
+def get_error_code() -> t.CInt: pass
+
+def clear_error() -> t.CInt: pass
+
+def compress(pool: memhub.MemManager | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def decompress(pool: memhub.MemManager | t.CPtr, data: BYTEPTR, data_len: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def compressobj(pool: memhub.MemManager | t.CPtr, level: t.CInt, method: t.CInt, wbits: t.CInt, memLevel: t.CInt, strategy: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Compress | t.CPtr: pass
+
+def decompressobj(pool: memhub.MemManager | t.CPtr, wbits: t.CInt, zdict: BYTEPTR, zdict_len: t.CSizeT) -> Decompress | t.CPtr: pass
+
+def zlib_adler32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass
+
+def zlib_crc32(data: BYTEPTR, length: t.CSizeT, value: t.CUnsignedLong) -> t.CUnsignedLong: pass

Test/TestProject2/temp/213348433fb01cc6.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from zlib.zdef.py
+Module: zlib.zdef
+"""
+
+
+from stdint import *
+import stddef
+import string
+import stdlib
+import memhub
+import t, c
+
+ZDEFLATE_WINDOW_BITS: t.CDefine = 15
+ZDEFLATE_WINDOW_SIZE: t.CDefine =    (1 << ZDEFLATE_WINDOW_BITS)
+ZDEFLATE_WINDOW_MASK: t.CDefine =    (ZDEFLATE_WINDOW_SIZE - 1)
+ZDEFLATE_MIN_MATCH: t.CDefine =      3
+ZDEFLATE_MAX_MATCH: t.CDefine =      258
+ZDEFLATE_HASH_BITS: t.CDefine =      15
+ZDEFLATE_HASH_SIZE: t.CDefine =      (1 << ZDEFLATE_HASH_BITS)
+ZDEFLATE_HASH_MASK: t.CDefine =      (ZDEFLATE_HASH_SIZE - 1)
+ZDEFLATE_MAX_CODES:         t.CDefine =      288
+ZDEFLATE_MAX_DIST_CODES:    t.CDefine = 32
+ZDEFLATE_MAX_BITS:          t.CDefine =       15
+ZDEFLATE_MAX_CODELEN_CODES: t.CDefine = 19
+ZDEFLATE_LIT_COUNT:  t.CDefine =      286
+ZDEFLATE_DIST_COUNT: t.CDefine =     30
+ZDEFLATE_LEN_SYMBOLS_BASE: t.CDefine = 257
+ZDEFLATE_END_OF_BLOCK:     t.CDefine =     256
+zdeflate_len_extra_bits: t.CExtern | t.CArray[t.CInt, 29]
+zdeflate_len_base: t.CExtern | t.CArray[t.CInt, 29]
+zdeflate_dist_extra_bits: t.CExtern | t.CArray[t.CInt, 30]
+zdeflate_dist_base: t.CExtern | t.CArray[t.CInt, 30]
+zdeflate_codelen_order: t.CExtern | t.CArray[int, 19]
+
+@t.Object
+class zbit_writer:
+    pool: memhub.MemManager | t.CPtr
+    buf: BYTE | t.CPtr
+    cap: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def __init__(self: zbit_writer, pool: memhub.MemManager | t.CPtr) -> t.CInt: pass
+    def ensure(self: zbit_writer, need: t.CSizeT) -> t.CInt: pass
+    def write_bits(self: zbit_writer, value: UINT, nbits: t.CInt) -> t.CInt: pass
+    def write_bits_rev(self: zbit_writer, code: UINT, nbits: t.CInt) -> t.CInt: pass
+    def stored_block(self: zbit_writer, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def write_zlib_header(self: zbit_writer, wbits: t.CInt, level: t.CInt) -> t.CInt: pass
+    def write_gzip_header(self: zbit_writer) -> t.CInt: pass
+    def align(self: zbit_writer) -> t.CInt: pass
+    def total(self: zbit_writer) -> t.CSizeT: pass
+    def free(self: zbit_writer) -> t.CInt: pass
+    def __del__(self: zbit_writer) -> t.CInt: pass
+@t.Object
+class zbit_reader:
+    buf: BYTE | t.CPtr
+    length: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def init(self: zbit_reader, buf: BYTE | t.CPtr, length: t.CSizeT) -> t.CInt: pass
+    def read_bits(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def read_bits_rev(self: zbit_reader, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def align(self: zbit_reader) -> t.CInt: pass
+
+def zdef_alloc(pool: memhub.MemManager | t.CPtr, n: t.CSizeT) -> VOIDPTR: pass
+
+def zdef_free(pool: memhub.MemManager | t.CPtr, p: VOIDPTR) -> t.CInt: pass

Test/TestProject2/temp/257e074b935c33b4.pyi

@@ -0,0 +1,45 @@
+"""
+Auto-generated Python stub file from binascii.py
+Module: binascii
+"""
+
+
+import t, c
+
+HEX_CHARS: t.CExtern | t.CArray[t.CChar, None]
+HEX_VALS: t.CExtern | t.CArray[t.CInt, 256]
+B64_CHARS: t.CExtern | t.CArray[t.CChar, None]
+B64_VALS: t.CExtern | t.CArray[t.CInt, 256]
+HQX_CHARS: t.CExtern | t.CArray[t.CChar, 64]
+HQX_VALS: t.CExtern | t.CArray[t.CInt, 256]
+UU_CHARS: t.CExtern | t.CArray[t.CChar, None]
+CRC32_TABLE: t.CExtern | t.CArray[t.CUnsignedInt, 256]
+CRC_HQX_TABLE: t.CExtern | t.CArray[t.CUnsignedShort, 256]
+
+def init_binascii() -> t.CInt: pass
+
+def crc32(data: str, length: t.CInt, crc: t.CUnsignedInt) -> t.CUnsignedInt: pass
+
+def crc_hqx(data: str, length: t.CInt, crc: t.CUnsignedShort) -> t.CUnsignedShort: pass
+
+def hexlify(data: str, length: t.CInt) -> str: pass
+
+def b2a_hex(data: str, length: t.CInt) -> str: pass
+
+def a2b_hex(hexstr: str, length: t.CInt) -> str: pass
+
+def unhexlify(data: str, length: t.CInt) -> t.CInt: pass
+
+def b2a_base64(data: str, length: t.CInt) -> str: pass
+
+def a2b_base64(data: str, length: t.CInt) -> str: pass
+
+def b2a_uu(data: str, length: t.CInt) -> str: pass
+
+def a2b_uu(data: str) -> str: pass
+
+def b2a_hqx(data: str, length: t.CInt, crc: t.CUnsignedShort) -> tuple[str, t.CUnsignedShort]: pass
+
+def a2b_hqx(data: str, crc: t.CUnsignedShort) -> tuple[str, t.CUnsignedShort]: pass
+
+def adler32(data: str, length: t.CInt, adler: t.CUnsignedInt) -> t.CUnsignedInt: pass

Test/TestProject2/temp/271ea3decb810db2.pyi

@@ -0,0 +1,26 @@
+"""
+Auto-generated Python stub file from atom.py
+Module: atom
+"""
+
+
+import t, c
+
+ATOMIC_RELAXED: t.CDefine = 0
+ATOMIC_CONSUME: t.CDefine = 1
+ATOMIC_ACQUIRE: t.CDefine = 2
+ATOMIC_RELEASE: t.CDefine = 3
+ATOMIC_ACQ_REL: t.CDefine = 4
+ATOMIC_SEQ_CST: t.CDefine = 5
+
+def __atomic_test_and_set(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CBool: pass
+
+def __atomic_clear(ptr: t.CUInt64T | t.CPtr, order: t.CInt) -> t.CVoid: pass
+
+def __atomic_thread_fence(order: t.CInt) -> t.CVoid: pass
+
+def __atomic_signal_fence(order: t.CInt) -> t.CVoid: pass
+
+def __atomic_always_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass
+
+def __atomic_is_lock_free(size: t.CSizeT, ptr: t.CVoid | t.CPtr) -> t.CBool: pass

Test/TestProject2/temp/451745df21e598af.pyi

@@ -0,0 +1,52 @@
+"""
+Auto-generated Python stub file from zlib.zinflate.py
+Module: zlib.zinflate
+"""
+
+
+from stdint import *
+import zlib.zchecksum as zchecksum
+import zlib.zdef as zdef
+import zlib.zhuff as zhuff
+import string
+import memhub
+import t, c
+
+@t.Object
+class zinflate_stream:
+    pool: memhub.MemManager | t.CPtr
+    reader: zdef.zbit_reader
+    window: BYTEPTR
+    window_pos: t.CInt
+    window_size: t.CInt
+    wbits: t.CInt
+    is_finished: t.CInt
+    is_initialized: t.CInt
+    header_parsed: t.CInt
+    is_gzip: t.CInt
+    adler: t.CUInt32T
+    crc: t.CUInt32T
+    output: BYTEPTR
+    output_len: t.CSizeT
+    output_cap: t.CSizeT
+    input_data: t.CConst | BYTEPTR
+    input_len: t.CSizeT
+    input_pos: t.CSizeT
+    max_length: t.CSizeT
+    def __init__(self: zinflate_stream) -> t.CInt: pass
+    def output_byte(self: zinflate_stream, byte: BYTE) -> t.CInt: pass
+    def parse_header(self: zinflate_stream) -> t.CInt: pass
+    def read_bits_from_input(self: zinflate_stream, nbits: t.CInt, out: UINTPTR) -> t.CInt: pass
+    def read_huffman(self: zinflate_stream, dt: zhuff.zhuff_decode_tree | t.CPtr) -> t.CInt: pass
+    def inflate_block_stored(self: zinflate_stream) -> t.CInt: pass
+    def inflate_block_fixed(self: zinflate_stream) -> t.CInt: pass
+    def inflate_block_dynamic(self: zinflate_stream) -> t.CInt: pass
+    def inflate_stream(self: zinflate_stream) -> t.CInt: pass
+    def decompress(self: zinflate_stream, data: UINT8PTR, length: t.CSizeT, max_length: t.CSizeT, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
+    def set_dictionary(self: zinflate_stream, dict: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
+    def copy(self: zinflate_stream) -> zinflate_stream | t.CPtr: pass
+    def destroy(self: zinflate_stream) -> t.CInt: pass
+
+def zinflate_one_shot(pool: memhub.MemManager | t.CPtr, data: UINT8PTR, length: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr: pass
+
+def zinflate_create(pool: memhub.MemManager | t.CPtr, wbits: t.CInt) -> zinflate_stream | t.CPtr: pass

Test/TestProject2/temp/541a1ed9b8be53c8.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject2/temp/541a1ed9b8be53c8.pyi

@@ -0,0 +1,16 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+from stdint import *
+import w32.win32console
+import config
+import hashlib
+import binascii
+import zlib.pyzlib as zp
+import t, c
+import testcheck
+
+def main() -> t.CInt | t.CExport: pass

Test/TestProject2/temp/6446627d4f07a1b5.pyi

@@ -0,0 +1,86 @@
+"""
+Auto-generated Python stub file from w32.winsock2.py
+Module: w32.winsock2
+"""
+
+
+import t, c
+from stdint import *
+from w32.win32base import *
+
+WINSOCK_VERSION: t.CDefine = 0x0202  # 2.2
+AF_INET: t.CDefine = 2
+AF_INET6: t.CDefine = 23
+SOCK_STREAM: t.CDefine = 1     # TCP
+SOCK_DGRAM: t.CDefine = 2      # UDP
+SOCK_RAW: t.CDefine = 3        # 原始套接字
+IPPROTO_TCP: t.CDefine = 6
+IPPROTO_UDP: t.CDefine = 17
+SOL_SOCKET: t.CDefine = 0xFFFF      # WinSock2 值
+SO_RCVTIMEO: t.CDefine = 0x1006     # WinSock2 值
+SO_SNDTIMEO: t.CDefine = 0x1005     # WinSock2 值
+SO_REUSEADDR: t.CDefine = 0x0004    # WinSock2 值
+INADDR_ANY: t.CDefine = 0
+SOCKET_ERROR: t.CDefine = -1
+INVALID_SOCKET: t.CDefine = 0xFFFFFFFF  # WinSock2: ~0
+MSG_NOSIGNAL: t.CDefine = 0  # Windows 不支持，设为 0
+SD_SEND: t.CDefine = 1
+SD_RECV: t.CDefine = 0
+SD_BOTH: t.CDefine = 2
+
+class WSASocketAddr:
+    family: u16
+    port: u16
+    addr: u32
+    zero: u64
+class WSAData:
+    wVersion: WORD
+    wHighVersion: WORD
+    szDescription: BYTE
+    szSystemStatus: BYTE
+    iMaxSockets: u16
+    iMaxUdpDg: u16
+    lpVendorInfo: CHARPTR
+class WSAHostEnt:
+    h_name: CHARPTR
+    h_aliases: CHARPTR
+    h_addrtype: SHORT
+    h_length: SHORT
+    h_addr_list: CHARPTR
+class WinTimeVal:
+    tv_sec: LONG
+    tv_usec: LONG
+
+def WSAStartup(wVersionRequested: WORD, lpWSAData: WSAData | t.CPtr) -> INT | t.State: pass
+
+def WSACleanup() -> INT | t.State: pass
+
+def WSAGetLastError() -> INT | t.State: pass
+
+def socket(family: INT, type: INT, protocol: INT) -> u64 | t.State: pass
+
+def closesocket(s: u64) -> INT | t.State: pass
+
+def connect(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
+
+def send(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
+
+def recv(s: u64, buf: t.CVoid | t.CPtr, len: INT, flags: INT) -> INT | t.State: pass
+
+def bind(s: u64, name: WSASocketAddr | t.CPtr, namelen: INT) -> INT | t.State: pass
+
+def listen(s: u64, backlog: INT) -> INT | t.State: pass
+
+def accept(s: u64, addr: WSASocketAddr | t.CPtr, addrlen: INT | t.CPtr) -> u64 | t.State: pass
+
+def setsockopt(s: u64, level: INT, optname: INT, optval: t.CVoid | t.CPtr, optlen: INT) -> INT | t.State: pass
+
+def shutdown(s: u64, how: INT) -> INT | t.State: pass
+
+def gethostbyname(name: t.CChar | t.CConst | t.CPtr) -> WSAHostEnt | t.CPtr | t.State: pass
+
+def ntohs(netshort: u16) -> u16 | t.State: pass
+
+def htons(hostshort: u16) -> u16 | t.State: pass
+
+def inet_addr(cp: t.CChar | t.CConst | t.CPtr) -> u32 | t.State: pass

Test/TestProject2/temp/6f62fe05c5ea1ceb.pyi

@@ -0,0 +1,28 @@
+"""
+Auto-generated Python stub file from stdio.py
+Module: stdio
+"""
+
+
+import t, c
+
+def printf(fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def snprintf(buf: bytes, size: t.CSizeT, fmt: t.CConst | str, *args) -> t.CInt | t.State: pass
+
+def puts(s: t.CConst | str) -> t.CInt | t.State: pass
+
+def fputs(s: t.CConst | str, stream: bytes) -> t.CInt | t.State: pass
+
+def fgets(buf: bytes, size: t.CInt, stream: bytes) -> bytes | t.State: pass
+
+def fflush(stream: bytes) -> t.CInt | t.State: pass
+
+
+stdin: t.CExtern | bytes
+stdout: t.CExtern | bytes
+stderr: t.CExtern | bytes

Test/TestProject2/temp/6ff26590374ae6fc.pyi

@@ -0,0 +1,39 @@
+"""
+Auto-generated Python stub file from hashlib.__sha512.py
+Module: hashlib.__sha512
+"""
+
+
+import t, c
+
+SHA512_BLOCK_LEN:  t.CDefine = 128
+SHA512_DIGEST_LEN: t.CDefine =  64
+
+def sha512_ror(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
+
+def sha512_shr(x: t.CUInt64T, n: int) -> t.CUInt64T: pass
+
+def sha512_Ch(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Maj(x: t.CUInt64T, y: t.CUInt64T, z: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_BigSigma0(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_BigSigma1(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Sigma0(x: t.CUInt64T) -> t.CUInt64T: pass
+
+def sha512_Sigma1(x: t.CUInt64T) -> t.CUInt64T: pass
+
+
+sha512_K: t.CExtern | t.CArray[t.CUInt64T, 80]
+
+@t.Object
+class sha512:
+    state: t.CArray[t.CUInt64T, 8]
+    count: t.CArray[t.CUInt64T, 2]
+    buf: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]
+    def __init__(self: sha512) -> t.CInt: pass
+    def transform(self: sha512, block: t.CArray[t.CUInt8T, SHA512_BLOCK_LEN]) -> t.CInt: pass
+    def update(self: sha512, s: str) -> t.CInt: pass
+    def final(self: sha512, out: t.CArray[t.CUInt8T, SHA512_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/72e2d5ccb7cedcf1.pyi

@@ -0,0 +1,91 @@
+"""
+Auto-generated Python stub file from w32.win32memory.py
+Module: w32.win32memory
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+MEM_COMMIT: t.CDefine = 0x00001000
+MEM_RESERVE: t.CDefine = 0x00002000
+MEM_DECOMMIT: t.CDefine = 0x00004000
+MEM_RELEASE: t.CDefine = 0x00008000
+MEM_FREE: t.CDefine = 0x00010000
+MEM_RESET: t.CDefine = 0x00080000
+MEM_TOP_DOWN: t.CDefine = 0x00100000
+MEM_WRITE_WATCH: t.CDefine = 0x00200000
+MEM_PHYSICAL: t.CDefine = 0x00400000
+MEM_LARGE_PAGES: t.CDefine = 0x20000000
+PAGE_NOACCESS: t.CDefine = 0x01
+PAGE_READONLY: t.CDefine = 0x02
+PAGE_READWRITE: t.CDefine = 0x04
+PAGE_WRITECOPY: t.CDefine = 0x08
+PAGE_EXECUTE: t.CDefine = 0x10
+PAGE_EXECUTE_READ: t.CDefine = 0x20
+PAGE_EXECUTE_READWRITE: t.CDefine = 0x40
+PAGE_EXECUTE_WRITECOPY: t.CDefine = 0x80
+PAGE_GUARD: t.CDefine = 0x100
+PAGE_NOCACHE: t.CDefine = 0x200
+PAGE_WRITECOMBINE: t.CDefine = 0x400
+HEAP_NO_SERIALIZE: t.CDefine = 0x00000001
+HEAP_GROWABLE: t.CDefine = 0x00000002
+HEAP_GENERATE_EXCEPTIONS: t.CDefine = 0x00000004
+HEAP_ZERO_MEMORY: t.CDefine = 0x00000008
+HEAP_REALLOC_IN_PLACE_ONLY: t.CDefine = 0x00000010
+
+class MEMORY_BASIC_INFORMATION:
+    BaseAddress: VOIDPTR
+    AllocationBase: VOIDPTR
+    AllocationProtect: ULONG
+    RegionSize: t.CSizeT
+    State: ULONG
+    Protect: ULONG
+    Type: ULONG
+
+def VirtualAlloc(lpAddress: VOIDPTR, dwSize: t.CSizeT, flAllocationType: ULONG, flProtect: ULONG) -> VOIDPTR | t.State: pass
+
+def VirtualFree(lpAddress: VOIDPTR, dwSize: t.CSizeT, dwFreeType: ULONG) -> BOOL | t.State: pass
+
+def VirtualProtect(lpAddress: VOIDPTR, dwSize: t.CSizeT, flNewProtect: ULONG, lpflOldProtect: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def VirtualQuery(lpAddress: t.CConst | VOIDPTR, lpBuffer: MEMORY_BASIC_INFORMATION | t.CPtr, dwLength: t.CSizeT) -> t.CSizeT | t.State: pass
+
+def VirtualLock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
+
+def VirtualUnlock(lpAddress: VOIDPTR, dwSize: t.CSizeT) -> BOOL | t.State: pass
+
+def GetProcessHeap() -> HANDLE | t.State: pass
+
+def HeapCreate(flOptions: ULONG, dwInitialSize: t.CSizeT, dwMaximumSize: t.CSizeT) -> HANDLE | t.State: pass
+
+def HeapDestroy(hHeap: HANDLE) -> BOOL | t.State: pass
+
+def HeapAlloc(hHeap: HANDLE, dwFlags: ULONG, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def HeapReAlloc(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def HeapFree(hHeap: HANDLE, dwFlags: ULONG, lpMem: VOIDPTR) -> BOOL | t.State: pass
+
+def HeapSize(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> t.CSizeT | t.State: pass
+
+def HeapValidate(hHeap: HANDLE, dwFlags: ULONG, lpMem: t.CConst | VOIDPTR) -> BOOL | t.State: pass
+
+def HeapCompact(hHeap: HANDLE, dwFlags: ULONG) -> t.CSizeT | t.State: pass
+
+def GlobalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def GlobalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
+
+def GlobalLock(hMem: VOIDPTR) -> VOIDPTR | t.State: pass
+
+def GlobalUnlock(hMem: VOIDPTR) -> BOOL | t.State: pass
+
+def GlobalSize(hMem: VOIDPTR) -> t.CSizeT | t.State: pass
+
+def LocalAlloc(uFlags: UINT, dwBytes: t.CSizeT) -> VOIDPTR | t.State: pass
+
+def LocalFree(hMem: VOIDPTR) -> VOIDPTR | t.State: pass

Test/TestProject2/temp/7e529fe7a078cfef.pyi

@@ -0,0 +1,100 @@
+"""
+Auto-generated Python stub file from w32.win32base.py
+Module: w32.win32base
+"""
+
+import c
+
+
+import t
+from stdint import *
+
+HANDLE: t.CTypedef = VOIDPTR
+LPCSTR: t.CTypedef = t.CConst | t.CChar | t.CPtr
+LPCWSTR: t.CTypedef = t.CConst | t.CUnsignedShort | t.CPtr
+INVALID_HANDLE_VALUE: t.CDefine = t.CVoid(-1)
+NULL: t.CDefine = 0
+TRUE: t.CDefine = 1
+FALSE: t.CDefine = 0
+INFINITE: t.CDefine = 0xFFFFFFFF
+WAIT_FAILED: t.CDefine = 0xFFFFFFFF
+WAIT_OBJECT_0: t.CDefine = 0
+WAIT_TIMEOUT: t.CDefine = 258
+WAIT_ABANDONED: t.CDefine = 0x80
+MAX_PATH: t.CDefine = 260
+ERROR_SUCCESS: t.CDefine = 0
+ERROR_FILE_NOT_FOUND: t.CDefine = 2
+ERROR_ACCESS_DENIED: t.CDefine = 5
+ERROR_INSUFFICIENT_BUFFER: t.CDefine = 122
+
+class SECURITY_ATTRIBUTES:
+    nLength: ULONG
+    lpSecurityDescriptor: VOIDPTR
+    bInheritHandle: BOOL
+class OVERLAPPED:
+    Internal: ULONGLONG
+    InternalHigh: ULONGLONG
+    Offset: ULONG
+    OffsetHigh: ULONG
+    hEvent: HANDLE
+class FILETIME:
+    dwLowDateTime: DWORD
+    dwHighDateTime: DWORD
+class SYSTEMTIME:
+    wYear: WORD
+    wMonth: WORD
+    wDayOfWeek: WORD
+    wDay: WORD
+    wHour: WORD
+    wMinute: WORD
+    wSecond: WORD
+    wMilliseconds: WORD
+class GUID:
+    Data1: DWORD
+    Data2: WORD
+    Data3: WORD
+    Data4: BYTEPTR
+class LARGE_INTEGER:
+    QuadPart: LONGLONG
+class ULARGE_INTEGER:
+    QuadPart: ULONGLONG
+
+def GetLastError() -> ULONG | t.State: pass
+
+def SetLastError(dwErrCode: ULONG) -> t.State: pass
+
+def CloseHandle(hObject: HANDLE) -> BOOL | t.State: pass
+
+def GetProcAddress(hModule: HANDLE, lpProcName: LPCSTR) -> VOIDPTR | t.State: pass
+
+def GetModuleHandleA(lpModuleName: LPCSTR) -> HANDLE | t.State: pass
+
+def GetModuleHandleW(lpModuleName: LPCWSTR) -> HANDLE | t.State: pass
+
+def LoadLibraryA(lpLibFileName: LPCSTR) -> HANDLE | t.State: pass
+
+def LoadLibraryW(lpLibFileName: LPCWSTR) -> HANDLE | t.State: pass
+
+def FreeLibrary(hLibModule: HANDLE) -> BOOL | t.State: pass
+
+def GetSystemTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
+
+def GetLocalTime(lpSystemTime: SYSTEMTIME | t.CPtr) -> t.State: pass
+
+def FileTimeToSystemTime(lpFileTime: FILETIME | t.CPtr, lpSystemTime: SYSTEMTIME | t.CPtr) -> BOOL | t.State: pass
+
+def SystemTimeToFileTime(lpSystemTime: SYSTEMTIME | t.CPtr, lpFileTime: FILETIME | t.CPtr) -> BOOL | t.State: pass
+
+def QueryPerformanceCounter(lpPerformanceCount: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def QueryPerformanceFrequency(lpFrequency: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def Sleep(dwMilliseconds: ULONG) -> t.State: pass
+
+def SleepEx(dwMilliseconds: ULONG, bAlertable: BOOL) -> ULONG | t.State: pass
+
+def GetTickCount() -> ULONG | t.State: pass
+
+def GetTickCount64() -> ULONGLONG | t.State: pass
+
+def GetCommandLineA() -> CHARPTR | t.State: pass

Test/TestProject2/temp/8ebed83a7817fa0c.pyi

@@ -0,0 +1,15 @@
+"""
+Auto-generated Python stub file from zlib.zchecksum.py
+Module: zlib.zchecksum
+"""
+
+
+from stdint import *
+import t, c
+
+def zchecksum_adler32(data: UINT8PTR, length: t.CSizeT, init: UINT32) -> t.CUInt32T: pass
+
+
+crc32_table: t.CExtern | t.CArray[t.CUInt32T, 256]
+
+def zchecksum_crc32(data: UINT8PTR, length: t.CSizeT, init: t.CUInt32T) -> t.CUInt32T: pass

Test/TestProject2/temp/90921d009fdd674c.pyi

@@ -0,0 +1,56 @@
+"""
+Auto-generated Python stub file from zlib.zdeflate.py
+Module: zlib.zdeflate
+"""
+
+
+from stdint import *
+import zlib.zchecksum as zchecksum
+import zlib.zhuff as zhuff
+import zlib.zdef as zdef
+import string
+import memhub
+import t, c
+
+@t.Object
+class zdeflate_stream:
+    pool: memhub.MemManager | t.CPtr
+    writer: zdef.zbit_writer
+    window: BYTE | t.CPtr
+    window_pos: t.CInt
+    window_size: t.CInt
+    hash_head: t.CInt | t.CPtr
+    hash_prev: t.CInt | t.CPtr
+    level: t.CInt
+    strategy: t.CInt
+    wbits: t.CInt
+    is_finished: t.CInt
+    adler: t.CUInt32T
+    def find_match(self: zdeflate_stream, data: BYTE | t.CPtr, data_len: t.CSizeT, pos: t.CSizeT, best_dist: t.CInt | t.CPtr) -> t.CInt: pass
+    def update_hash(self: zdeflate_stream, data: BYTE | t.CPtr, pos: t.CSizeT) -> t.CInt: pass
+    def write_fixed_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def encode_block_data(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, lit_tree: zhuff.zhuff_tree | t.CPtr, dist_tree: zhuff.zhuff_tree | t.CPtr) -> t.CInt: pass
+    def write_dynamic_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def compress_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def write_stored_block(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, final: t.CInt) -> t.CInt: pass
+    def compress(self: zdeflate_stream, data: UINT8PTR, length: t.CSizeT, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
+    def flush(self: zdeflate_stream, mode: t.CInt, out: t.CUInt8T | t.CPtr[t.CPtr], out_len: t.CSizeT | t.CPtr) -> t.CInt: pass
+    def set_dictionary(self: zdeflate_stream, dict: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
+    def copy(self: zdeflate_stream) -> zdeflate_stream | t.CPtr: pass
+    def destroy(self: zdeflate_stream) -> t.CInt: pass
+
+def zdeflate_count_freqs(lit_freqs: INTPTR, dist_freqs: INTPTR, s: zdeflate_stream | t.CPtr, data: UINT8PTR, length: t.CSizeT) -> t.CInt: pass
+
+def zdeflate_hash(p: BYTE | t.CPtr) -> t.CUnsignedInt: pass
+
+def zdeflate_len_to_symbol(length: t.CInt) -> t.CInt: pass
+
+def zdeflate_dist_to_symbol(dist: t.CInt) -> t.CInt: pass
+
+def zdeflate_count_cl_freqs(all_lengths: INTPTR, total: t.CInt, cl_freqs: INTPTR) -> t.CInt: pass
+
+def zdeflate_write_cl_encoded(all_lengths: INTPTR, total: t.CInt, w: zdef.zbit_writer | t.CPtr, cl_tree: zhuff.zhuff_tree | t.CPtr) -> t.CInt: pass
+
+def zdeflate_create(pool: memhub.MemManager | t.CPtr, level: t.CInt, wbits: t.CInt, mem_level: t.CInt, strategy: t.CInt) -> zdeflate_stream | t.CPtr: pass
+
+def zdeflate_one_shot(pool: memhub.MemManager | t.CPtr, data: UINT8PTR, length: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr: pass

Test/TestProject2/temp/90c53dd6db8d41cf.pyi

@@ -0,0 +1,20 @@
+"""
+Auto-generated Python stub file from stdlib.py
+Module: stdlib
+"""
+
+import c
+
+
+from stdint import *
+import t
+
+def malloc(size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def calloc(nmemb: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def realloc(p: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr | t.State: pass
+
+def free(p: t.CVoid | t.CPtr) -> t.State: pass
+
+def system(cmd: t.CConst | t.CChar | t.CPtr) -> INT | t.State: pass

Test/TestProject2/temp/96837bcc64032444.pyi

@@ -0,0 +1,13 @@
+"""
+Auto-generated Python stub file from hashlib.__init__.py
+Module: hashlib.__init__
+"""
+
+import t
+import c
+
+
+from .__md5 import md5, MD5_DIGEST_LEN
+from .__sha1 import sha1, SHA1_DIGEST_LEN
+from .__sha256 import sha256, SHA256_DIGEST_LEN
+from .__sha512 import sha512, SHA512_DIGEST_LEN

Test/TestProject2/temp/_phase1_manifest.json

@@ -0,0 +1 @@
+{"D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject2\\App\\main.py": {"sha1": "541a1ed9b8be53c8", "mtime": 1782266206.092594, "size": 881}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\Test\\TestProject2\\App\\zc\\config.py": {"sha1": "cfc83b830141b00e", "mtime": 1778402243.1661563, "size": 531}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\atom.py": {"sha1": "271ea3decb810db2", "mtime": 1782226548.693161, "size": 1290}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\binascii.py": {"sha1": "257e074b935c33b4", "mtime": 1782266199.8074288, "size": 14937}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__init__.py": {"sha1": "96837bcc64032444", "mtime": 1777902641.540433, "size": 186}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__md5.py": {"sha1": "19f8024d10c828e8", "mtime": 1784356818.7075372, "size": 5847}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__sha1.py": {"sha1": "0df65b8ed15664b0", "mtime": 1784356827.656474, "size": 4516}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__sha256.py": {"sha1": "c9d54a4158f7f5a8", "mtime": 1782266203.9352357, "size": 5332}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__sha512.py": {"sha1": "6ff26590374ae6fc", "mtime": 1782266223.3380039, "size": 7162}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\memhub.py": {"sha1": "ee084e9fc6ee413a", "mtime": 1784214242.4485993, "size": 17765}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdint.py": {"sha1": "f5522571bcce7bcb", "mtime": 1782383975.8824987, "size": 4356}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdio.py": {"sha1": "6f62fe05c5ea1ceb", "mtime": 1783239556.0959673, "size": 714}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdlib.py": {"sha1": "90c53dd6db8d41cf", "mtime": 1783874975.3597875, "size": 375}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\string.py": {"sha1": "ab6e54ba9a669f76", "mtime": 1783933178.7264287, "size": 9922}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\testcheck.py": {"sha1": "dd3002730623424b", "mtime": 1783927513.1159866, "size": 1818}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperio.py": {"sha1": "c9f4be41ca1cc2b4", "mtime": 1782812279.506002, "size": 1556}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32base.py": {"sha1": "7e529fe7a078cfef", "mtime": 1782488356.7736557, "size": 2662}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\w32\\win32console.py": {"sha1": "bbdf3bbd4c3bc28c", "mtime": 1781200703.5338137, "size": 5604}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\zlib\\pyzlib.py": {"sha1": "1c46d554b3a3f9f3", "mtime": 1783538216.7783763, "size": 26101}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\zlib\\zchecksum.py": {"sha1": "8ebed83a7817fa0c", "mtime": 1782266235.9510274, "size": 4067}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\zlib\\zdef.py": {"sha1": "213348433fb01cc6", "mtime": 1782827035.812386, "size": 8591}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\zlib\\zdeflate.py": {"sha1": "90921d009fdd674c", "mtime": 1783538197.82992, "size": 19061}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\zlib\\zhuff.py": {"sha1": "d541ade6afb689a5", "mtime": 1782827037.897873, "size": 13495}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\zlib\\zinflate.py": {"sha1": "451745df21e598af", "mtime": 1782827035.992862, "size": 18078}}

Test/TestProject2/temp/_sha1_map.txt

@@ -0,0 +1,24 @@
+0df65b8ed15664b0:includes/hashlib\__sha1.py
+19f8024d10c828e8:includes/hashlib\__md5.py
+1c46d554b3a3f9f3:includes/zlib\pyzlib.py
+213348433fb01cc6:includes/zlib\zdef.py
+257e074b935c33b4:includes/binascii.py
+271ea3decb810db2:includes/atom.py
+451745df21e598af:includes/zlib\zinflate.py
+541a1ed9b8be53c8:main.py
+6f62fe05c5ea1ceb:includes/stdio.py
+6ff26590374ae6fc:includes/hashlib\__sha512.py
+7e529fe7a078cfef:includes/w32\win32base.py
+8ebed83a7817fa0c:includes/zlib\zchecksum.py
+90921d009fdd674c:includes/zlib\zdeflate.py
+90c53dd6db8d41cf:includes/stdlib.py
+96837bcc64032444:includes/hashlib\__init__.py
+ab6e54ba9a669f76:includes/string.py
+bbdf3bbd4c3bc28c:includes/w32\win32console.py
+c9d54a4158f7f5a8:includes/hashlib\__sha256.py
+c9f4be41ca1cc2b4:includes/viperio.py
+cfc83b830141b00e:zc\config.py
+d541ade6afb689a5:includes/zlib\zhuff.py
+dd3002730623424b:includes/testcheck.py
+ee084e9fc6ee413a:includes/memhub.py
+f5522571bcce7bcb:includes/stdint.py

Test/TestProject2/temp/ab6e54ba9a669f76.pyi

@@ -0,0 +1,48 @@
+"""
+Auto-generated Python stub file from string.py
+Module: string
+"""
+
+
+from stdint import *
+import t, c
+
+def strcpy(dest: str, src: str) -> str: pass
+
+def strcat(dest: str, src: str) -> str: pass
+
+def strncpy(dest: str, src: str, n: t.CSizeT) -> str: pass
+
+def strlen(src: str) -> t.CSizeT | t.CExport: pass
+
+def strcmp(str1: str, str2: str) -> t.CInt: pass
+
+def samestr(str1: str, str2: str) -> bool: pass
+
+def strncmp(str1: str, str2: str, n: t.CSizeT) -> t.CInt: pass
+
+def memcmp(ptr1: t.CVoid | t.CPtr, ptr2: t.CVoid | t.CPtr, n: t.CSizeT) -> t.CInt: pass
+
+def strchr(s: str, cr: t.CInt) -> str: pass
+
+def strrchr(s: str, cr: t.CInt) -> str: pass
+
+def strstr(s: str, needle: str) -> str: pass
+
+def strspn(s: str, skip: str) -> int: pass
+
+def memset(ptr: t.CVoid | t.CPtr, value: t.CInt, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memset32(ptr: t.CVoid | t.CPtr, value: t.CUInt32T, count: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def memcpy(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memmove(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def atoi(src: str) -> t.CInt: pass
+
+def atoll(src: str) -> t.CInt64T: pass
+
+def atof(src: str) -> t.CDouble: pass
+
+def split(s: str, delim: str, result: t.CArray[str]) -> int: pass

Test/TestProject2/temp/bbdf3bbd4c3bc28c.pyi

@@ -0,0 +1,138 @@
+"""
+Auto-generated Python stub file from w32.win32console.py
+Module: w32.win32console
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+ENABLE_PROCESSED_INPUT: t.CDefine = 0x0001
+ENABLE_LINE_INPUT: t.CDefine = 0x0002
+ENABLE_ECHO_INPUT: t.CDefine = 0x0004
+ENABLE_WINDOW_INPUT: t.CDefine = 0x0008
+ENABLE_MOUSE_INPUT: t.CDefine = 0x0010
+ENABLE_INSERT_MODE: t.CDefine = 0x0020
+ENABLE_QUICK_EDIT_MODE: t.CDefine = 0x0040
+ENABLE_EXTENDED_FLAGS: t.CDefine = 0x0080
+ENABLE_PROCESSED_OUTPUT: t.CDefine = 0x0001
+ENABLE_WRAP_AT_EOL_OUTPUT: t.CDefine = 0x0002
+ENABLE_VIRTUAL_TERMINAL_PROCESSING: t.CDefine = 0x0004
+DISABLE_NEWLINE_AUTO_RETURN: t.CDefine = 0x0008
+ENABLE_LVB_GRID_WORLDWIDE: t.CDefine = 0x0010
+FOREGROUND_BLUE: t.CDefine = 0x0001
+FOREGROUND_GREEN: t.CDefine = 0x0002
+FOREGROUND_RED: t.CDefine = 0x0004
+FOREGROUND_INTENSITY: t.CDefine = 0x0008
+BACKGROUND_BLUE: t.CDefine = 0x0010
+BACKGROUND_GREEN: t.CDefine = 0x0020
+BACKGROUND_RED: t.CDefine = 0x0040
+BACKGROUND_INTENSITY: t.CDefine = 0x0080
+KEY_EVENT: t.CDefine = 0x0001
+MOUSE_EVENT: t.CDefine = 0x0002
+WINDOW_BUFFER_SIZE_EVENT: t.CDefine = 0x0004
+MENU_EVENT: t.CDefine = 0x0008
+FOCUS_EVENT: t.CDefine = 0x0010
+
+class COORD:
+    X: SHORT
+    Y: SHORT
+class SMALL_RECT:
+    Left: SHORT
+    Top: SHORT
+    Right: SHORT
+    Bottom: SHORT
+class CONSOLE_SCREEN_BUFFER_INFO:
+    dwSize: COORD
+    dwCursorPosition: COORD
+    wAttributes: WORD
+    srWindow: SMALL_RECT
+    dwMaximumWindowSize: COORD
+class CONSOLE_CURSOR_INFO:
+    dwSize: ULONG
+    bVisible: BOOL
+class CHAR_INFO:
+    UnicodeChar: WCHAR
+    Attributes: WORD
+class KEY_EVENT_RECORD:
+    bKeyDown: BOOL
+    wRepeatCount: WORD
+    wVirtualKeyCode: WORD
+    wVirtualScanCode: WORD
+    uChar: WCHAR
+    dwControlKeyState: ULONG
+class MOUSE_EVENT_RECORD:
+    dwMousePosition: COORD
+    dwButtonState: ULONG
+    dwControlKeyState: ULONG
+    dwEventFlags: ULONG
+class WINDOW_BUFFER_SIZE_RECORD:
+    dwSize: COORD
+class INPUT_RECORD:
+    EventType: WORD
+    Event: KEY_EVENT_RECORD
+
+def SetConsoleOutputCP(codepage: UINT) -> BOOL | t.State: pass
+
+def SetConsoleCP(codepage: UINT) -> BOOL | t.State: pass
+
+def GetConsoleCP() -> UINT | t.State: pass
+
+def GetConsoleOutputCP() -> UINT | t.State: pass
+
+def GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleScreenBufferSize(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL | t.State: pass
+
+def SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) -> BOOL | t.State: pass
+
+def GetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleCursorInfo(hConsoleOutput: HANDLE, lpConsoleCursorInfo: CONSOLE_CURSOR_INFO | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL | t.State: pass
+
+def FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: t.CChar, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FillConsoleOutputCharacterW(hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfCharsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: ULONG, dwWriteCoord: COORD, lpNumberOfAttrsWritten: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def WriteConsoleA(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
+
+def WriteConsoleW(hConsoleOutput: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfCharsToWrite: ULONG, lpNumberOfCharsWritten: ULONG | t.CPtr, lpReserved: VOIDPTR) -> BOOL | t.State: pass
+
+def ReadConsoleA(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
+
+def ReadConsoleW(hConsoleInput: HANDLE, lpBuffer: VOIDPTR, nNumberOfCharsToRead: ULONG, lpNumberOfCharsRead: ULONG | t.CPtr, pInputControl: VOIDPTR) -> BOOL | t.State: pass
+
+def GetConsoleMode(hConsoleHandle: HANDLE, lpMode: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def SetConsoleMode(hConsoleHandle: HANDLE, dwMode: ULONG) -> BOOL | t.State: pass
+
+def ReadConsoleInputA(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def ReadConsoleInputW(hConsoleInput: HANDLE, lpBuffer: INPUT_RECORD | t.CPtr, nLength: ULONG, lpNumberOfEventsRead: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE, lpNumberOfEvents: ULONG | t.CPtr) -> BOOL | t.State: pass
+
+def FlushConsoleInputBuffer(hConsoleInput: HANDLE) -> BOOL | t.State: pass
+
+def SetConsoleTitleA(lpConsoleTitle: LPCSTR) -> BOOL | t.State: pass
+
+def SetConsoleTitleW(lpConsoleTitle: LPCWSTR) -> BOOL | t.State: pass
+
+def GetConsoleTitleA(lpConsoleTitle: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def GetConsoleTitleW(lpConsoleTitle: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def AllocConsole() -> BOOL | t.State: pass
+
+def FreeConsole() -> BOOL | t.State: pass
+
+def SetConsoleWindowInfo(hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: SMALL_RECT | t.CPtr) -> BOOL | t.State: pass
+
+def ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE, lpScrollRectangle: SMALL_RECT | t.CPtr, lpClipRectangle: SMALL_RECT | t.CPtr, dwDestinationOrigin: COORD, lpFill: CHAR_INFO | t.CPtr) -> BOOL | t.State: pass

Test/TestProject2/temp/c9d54a4158f7f5a8.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from hashlib.__sha256.py
+Module: hashlib.__sha256
+"""
+
+
+import t, c
+
+SHA256_BLOCK_LEN:  t.CDefine = 64
+SHA256_DIGEST_LEN: t.CDefine = 32
+sha256_K: t.CExtern | t.CArray[t.CUInt32T, 64]
+
+def s0(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def s1(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def S0(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def S1(x: t.CUInt32T) -> t.CUInt32T: pass
+
+def Ch(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+def Maj(x: t.CUInt32T, y: t.CUInt32T, z: t.CUInt32T) -> t.CUInt32T: pass
+
+
+@t.Object
+class sha256:
+    state: t.CArray[t.CUInt32T, 8]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA256_BLOCK_LEN]
+    def __init__(self: sha256) -> t.CInt: pass
+    def transform(self: sha256, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha256, s: str) -> t.CInt: pass
+    def final(self: sha256, out: t.CArray[t.CUInt8T, SHA256_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject2/temp/c9f4be41ca1cc2b4.pyi

@@ -0,0 +1,22 @@
+"""
+Auto-generated Python stub file from viperio.py
+Module: viperio
+"""
+
+
+import t, c
+from stdint import *
+
+class Buf:
+    data: t.CChar | t.CPtr
+    length: t.CSizeT
+    capacity: t.CSizeT
+    owned: bool
+    def __init__(self: Buf, data: t.CChar | t.CPtr, capacity: t.CSizeT, length: t.CSizeT, owned: bool) -> t.CInt: pass
+    def clear(self: Buf) -> t.CInt: pass
+    def write(self: Buf, src: t.CChar | t.CPtr, count: t.CSizeT) -> t.CSizeT: pass
+    def cstr(self: Buf) -> t.CChar | t.CPtr: pass
+    def reset(self: Buf) -> t.CInt: pass
+    def __enter__(self: Buf) -> 'Buf' | t.CPtr: pass
+    def __exit__(self: Buf) -> t.CInt: pass
+    def free(self: Buf) -> t.CInt: pass

Test/TestProject2/temp/cfc83b830141b00e.doc.json

@@ -0,0 +1 @@
+{}

Test/TestProject2/temp/cfc83b830141b00e.pyi

@@ -0,0 +1,27 @@
+"""
+Auto-generated Python stub file from zc.config.py
+Module: zc.config
+"""
+
+
+import t, c
+
+POSMAX: t.CDefine = 100
+MAX_RETRY: t.CDefine = 5
+BUFFER_SIZE: t.CDefine = 256
+PI: t.CDefine = 3.14159
+EULER: t.CDefine = 2.71828
+TRUE: t.CDefine = 1
+FALSE: t.CDefine = 0
+NULL: t.CDefine = 0
+MATH_OFFSET: t.CDefine = 10
+MATH_SCALE: t.CDefine = 2
+THRESHOLD: t.CDefine = 50
+LOOP_LIMIT: t.CDefine = 20
+SHIFT_AMOUNT: t.CDefine = 2
+MASK_VALUE: t.CDefine = 0xFF
+BIT_RANGE: t.CDefine = 4
+EXPONENT_BASE: t.CDefine = 3
+MODULO_DIVISOR: t.CDefine = 7
+SCALE_SHIFT: t.CDefine = 4
+HALF_SCALE: t.CDefine = 0.5

Test/TestProject2/temp/d541ade6afb689a5.pyi

@@ -0,0 +1,44 @@
+"""
+Auto-generated Python stub file from zlib.zhuff.py
+Module: zlib.zhuff
+"""
+
+
+from stdint import *
+import zlib.zdef as zdef
+import memhub
+import t, c
+
+ZHUFF_MAX_CODES: t.CDefine = 288
+ZHUFF_MAX_BITS:  t.CDefine = 15
+
+class zhuff_code:
+    code: UINT
+    bits: t.CInt
+@t.Object
+class zhuff_tree:
+    pool: memhub.MemManager | t.CPtr
+    codes: t.CArray[zhuff_code, ZHUFF_MAX_CODES]
+    count: t.CInt
+    max_bits: t.CInt
+    def __init__(self: zhuff_tree) -> t.CInt: pass
+    def build_codes(self: zhuff_tree, freqs: INTPTR, count: t.CInt, max_bits: t.CInt) -> t.CInt: pass
+    def build_fixed_lit_tree(self: zhuff_tree) -> t.CInt: pass
+    def build_fixed_dist_tree(self: zhuff_tree) -> t.CInt: pass
+    def encode_symbol(self: zhuff_tree, symbol: int, writer: zdef.zbit_writer | t.CPtr) -> t.CInt: pass
+    def build_code_lengths(self: zhuff_tree, lengths: t.CInt | t.CPtr, freqs: t.CInt | t.CPtr, count: t.CInt, max_bits: t.CInt) -> t.CInt: pass
+    def get_fixed_lit_lengths(self: zhuff_tree, lengths: INTPTR) -> t.CInt: pass
+    def get_fixed_dist_lengths(self: zhuff_tree, lengths: INTPTR) -> t.CInt: pass
+    def build_tree_from_lengths(self: zhuff_tree, lengths: INTPTR, count: t.CInt, max_bits: t.CInt) -> t.CInt: pass
+class zhuff_decode_node:
+    children: t.CArray[t.CInt, 2]
+    symbol: t.CInt
+@t.Object
+class zhuff_decode_tree:
+    pool: memhub.MemManager | t.CPtr
+    nodes: t.CArray[zhuff_decode_node, 2 * ZHUFF_MAX_CODES]
+    node_count: t.CInt
+    root: t.CInt
+    def __init__(self: zhuff_decode_tree) -> t.CInt: pass
+    def build_decode_tree(self: zhuff_decode_tree, ht: zhuff_tree | t.CPtr) -> t.CInt: pass
+    def decode_symbol(self: zhuff_decode_tree, reader: zdef.zbit_reader | t.CPtr) -> t.CInt: pass

Test/TestProject2/temp/d63d2c2a2bd9bd2a.pyi

@@ -0,0 +1,10 @@
+"""
+Auto-generated Python stub file from zlib.__init__.py
+Module: zlib.__init__
+"""
+
+import t
+import c
+
+
+from .pyzlib import *

Test/TestProject2/temp/dd3002730623424b.pyi

@@ -0,0 +1,31 @@
+"""
+Auto-generated Python stub file from testcheck.py
+Module: testcheck
+"""
+
+
+import t, c
+import stdio
+from w32.win32console import SetConsoleOutputCP, SetConsoleCP
+
+CP_UTF8: t.CDefine = 65001
+_pass_count: t.CExtern | t.CInt
+_fail_count: t.CExtern | t.CInt
+_total_pass: t.CExtern | t.CInt
+_total_fail: t.CExtern | t.CInt
+
+def begin(name: str) -> t.CInt: pass
+
+def section(name: str) -> t.CInt: pass
+
+def ok(msg: str) -> t.CInt: pass
+
+def fail(msg: str) -> t.CInt: pass
+
+def check(cond: t.CInt, ok_msg: str, fail_msg: str) -> t.CInt: pass
+
+def info(msg: str) -> t.CInt: pass
+
+def end() -> t.CInt: pass
+
+def summary() -> t.CInt: pass

Test/TestProject2/temp/ee084e9fc6ee413a.pyi

@@ -0,0 +1,81 @@
+"""
+Auto-generated Python stub file from memhub.py
+Module: memhub
+"""
+
+
+import t, c
+from stdint import *
+import string
+import atom
+import viperio
+
+MEMHUB_ALIGN: t.CDefine = 8
+MEMSLAB_MIN_BLOCK: t.CDefine = 16
+MEMSLAB_BITMAP_BYTES: t.CDefine = 256
+MEMBUDDY_MIN_BLOCK: t.CDefine = 32
+MEMBUDDY_MAX_ORDERS: t.CDefine = 32
+MEMBUDDY_HEADER_SIZE: t.CDefine = 8
+
+def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
+
+def _largest_pow2_le(val: t.CSizeT) -> t.CSizeT: pass
+
+def _block_size_at_order(order: t.CInt) -> t.CSizeT: pass
+
+
+@t.CVTable
+class MemManager:
+    __provides__: list[str] = ['__memmgr__']
+    base: t.CVoid | t.CPtr
+    size: t.CSizeT
+    def __init__(self: MemManager, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
+    def alloc(self: MemManager, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemManager, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemManager) -> t.CInt: pass
+    def calloc(self: MemManager, count: t.CSizeT, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def realloc(self: MemManager, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def __enter__(self: MemManager) -> 'MemManager' | t.CPtr: pass
+    def __exit__(self: MemManager) -> t.CInt: pass
+    def alloc_buf(self: MemManager, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
+class MemPool(MemManager):
+    offset: t.CSizeT
+    high_water: t.CSizeT
+    def __init__(self: MemPool, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
+    def alloc(self: MemPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemPool) -> t.CInt: pass
+class MemSlab(MemManager):
+    block_size: t.CSizeT
+    block_count: t.CSizeT
+    used_count: t.CSizeT
+    free_list: t.CVoid | t.CPtr
+    alloc_map: t.CUInt8T | t.CPtr
+    alloc_map_size: t.CSizeT
+    usable: t.CVoid | t.CPtr
+    usable_size: t.CSizeT
+    def __init__(self: MemSlab, base: t.CVoid | t.CPtr, size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
+    def alloc(self: MemSlab, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemSlab, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemSlab) -> t.CInt: pass
+class MemBuddy(MemManager):
+    max_order: t.CInt
+    free_lists: t.CUInt64T | t.CPtr
+    lock_val: t.CVolatile | t.CInt
+    usable: t.CVoid | t.CPtr
+    usable_size: t.CSizeT
+    def __init__(self: MemBuddy, base: t.CVoid | t.CPtr, size: t.CSizeT) -> t.CInt: pass
+    def _fl_push(self: MemBuddy, order: t.CInt, block: t.CVoid | t.CPtr) -> t.CInt: pass
+    def _fl_pop(self: MemBuddy, order: t.CInt) -> t.CVoid | t.CPtr: pass
+    def _fl_find_and_remove(self: MemBuddy, order: t.CInt, target: t.CVoid | t.CPtr) -> t.CInt: pass
+    def _buddy_of(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CVoid | t.CPtr: pass
+    def _order_for_size(self: MemBuddy, size: t.CSizeT) -> t.CInt: pass
+    def _split_to_order(self: MemBuddy, to_order: t.CInt) -> t.CVoid | t.CPtr: pass
+    def _coalesce(self: MemBuddy, block: t.CVoid | t.CPtr, order: t.CInt) -> t.CInt: pass
+    def _is_valid_ptr(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def _lock(self: MemBuddy) -> t.CInt: pass
+    def _unlock(self: MemBuddy) -> t.CInt: pass
+    def alloc(self: MemBuddy, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def free(self: MemBuddy, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def reset(self: MemBuddy) -> t.CInt: pass
+    def realloc(self: MemBuddy, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass

Test/TestProject2/temp/f5522571bcce7bcb.pyi

@@ -0,0 +1,100 @@
+"""
+Auto-generated Python stub file from stdint.py
+Module: stdint
+"""
+
+import c
+
+
+import t
+
+INT: t.CTypedef = t.CInt
+INTPTR: t.CTypedef = t.CInt | t.CPtr
+BOOL: t.CTypedef = t.CInt
+UINT: t.CTypedef = t.CUnsignedInt
+UINTPTR: t.CTypedef = UINT | t.CPtr
+BYTE: t.CTypedef = t.CUnsignedChar
+BYTEPTR: t.CTypedef = BYTE | t.CPtr
+WORD: t.CTypedef = t.CUInt16T
+DWORD: t.CTypedef = t.CUInt32T
+QWORD: t.CTypedef = t.CUInt64T
+TCHAR: t.CTypedef = t.CChar
+CHARLIST: t.CTypedef = str | t.CPtr
+VOID: t.CTypedef = t.CVoid
+SHORT: t.CTypedef = t.CShort
+SHORTPTR: t.CTypedef = t.CShort | t.CPtr
+USHORT: t.CTypedef = t.CUnsignedShort
+USHORTPTR: t.CTypedef = t.CUnsignedShort | t.CPtr
+LONGLONG: t.CTypedef = t.CLongLong
+ULONGLONG: t.CTypedef = t.CUnsignedLongLong
+LONG: t.CTypedef = t.CLong
+ULONG: t.CTypedef = t.CUnsignedLong
+WCHAR: t.CTypedef = WORD
+WCHARPTR: t.CTypedef = WORD | t.CPtr
+CHARPTR: t.CTypedef = t.CChar | t.CPtr
+FSIZE_t: t.CTypedef = DWORD
+LBA_t: t.CTypedef = DWORD
+VOIDPTR: t.CTypedef = t.CVoid | t.CPtr
+FLOAT: t.CTypedef = t.CFloat
+DOUBLE: t.CTypedef = t.CDouble
+FLOAT8: t.CTypedef = t.CFloat8T
+FLOAT16: t.CTypedef = t.CFloat16T
+FLOAT32: t.CTypedef = t.CFloat32T
+FLOAT64: t.CTypedef = t.CFloat64T
+FLOAT128: t.CTypedef = t.CFloat128T
+INT8: t.CTypedef = t.CInt8T
+INT16: t.CTypedef = t.CInt16T
+INT32: t.CTypedef = t.CInt32T
+INT64: t.CTypedef = t.CInt64T
+UINT8: t.CTypedef = t.CUInt8T
+UINT16: t.CTypedef = t.CUInt16T
+UINT32: t.CTypedef = t.CUInt32T
+UINT64: t.CTypedef = t.CUInt64T
+INT8PTR: t.CTypedef = t.CInt8T | t.CPtr
+INT16PTR: t.CTypedef = t.CInt16T | t.CPtr
+INT32PTR: t.CTypedef = t.CInt32T | t.CPtr
+INT64PTR: t.CTypedef = t.CInt64T | t.CPtr
+UINT8PTR: t.CTypedef = t.CUInt8T | t.CPtr
+UINT16PTR: t.CTypedef = t.CUInt16T | t.CPtr
+UINT32PTR: t.CTypedef = t.CUInt32T | t.CPtr
+UINT64PTR: t.CTypedef = t.CUInt64T | t.CPtr
+CHAR8: t.CTypedef = t.CChar8T
+CHAR16: t.CTypedef = t.CChar16T
+CHAR32: t.CTypedef = t.CChar32T
+CHAR8PTR: t.CTypedef = t.CChar8T | t.CPtr
+CHAR16PTR: t.CTypedef = t.CChar16T | t.CPtr
+CHAR32PTR: t.CTypedef = t.CChar32T | t.CPtr
+i8: t.CTypedef = t.CInt8T
+i16: t.CTypedef = t.CInt16T
+i32: t.CTypedef = t.CInt32T
+i64: t.CTypedef = t.CInt64T
+u8: t.CTypedef = t.CUInt8T
+u16: t.CTypedef = t.CUInt16T
+u32: t.CTypedef = t.CUInt32T
+u64: t.CTypedef = t.CUInt64T
+SIZE_T: t.CTypedef = t.CSizeT
+SSIZE_T: t.CTypedef = t.CPtrDiffT
+PTRDIFF_T: t.CTypedef = t.CPtrDiffT
+int8_t: t.CTypedef = t.CInt8T
+int16_t: t.CTypedef = t.CInt16T
+int32_t: t.CTypedef = t.CInt32T
+int64_t: t.CTypedef = t.CInt64T
+uint8_t: t.CTypedef = t.CUInt8T
+uint16_t: t.CTypedef = t.CUInt16T
+uint32_t: t.CTypedef = t.CUInt32T
+uint64_t: t.CTypedef = t.CUInt64T
+size_t: t.CTypedef = t.CSizeT
+ssize_t: t.CTypedef = t.CPtrDiffT
+ptrdiff_t: t.CTypedef = t.CPtrDiffT
+intptr_t: t.CTypedef = t.CIntPtrT
+uintptr_t: t.CTypedef = t.CUIntPtrT
+wchar_t: t.CTypedef = t.CWCharT
+char8_t: t.CTypedef = t.CChar8T
+char16_t: t.CTypedef = t.CChar16T
+char32_t: t.CTypedef = t.CChar32T
+float8_t: t.CTypedef = t.CFloat8T
+float16_t: t.CTypedef = t.CFloat16T
+float32_t: t.CTypedef = t.CFloat32T
+float64_t: t.CTypedef = t.CFloat64T
+float128_t: t.CTypedef = t.CFloat128T
+_Bool: t.CTypedef = t.CBool

Test/TestProject2/temp/f6b51804a0ba8ff0.pyi

@@ -0,0 +1,192 @@
+"""
+Auto-generated Python stub file from w32.win32file.py
+Module: w32.win32file
+"""
+
+import c
+
+
+import t
+from stdint import *
+from w32.win32base import *
+
+GENERIC_READ: t.CDefine = 0x80000000
+GENERIC_WRITE: t.CDefine = 0x40000000
+GENERIC_EXECUTE: t.CDefine = 0x20000000
+GENERIC_ALL: t.CDefine = 0x10000000
+FILE_SHARE_READ: t.CDefine = 0x00000001
+FILE_SHARE_WRITE: t.CDefine = 0x00000002
+FILE_SHARE_DELETE: t.CDefine = 0x00000004
+CREATE_NEW: t.CDefine = 1
+CREATE_ALWAYS: t.CDefine = 2
+OPEN_EXISTING: t.CDefine = 3
+OPEN_ALWAYS: t.CDefine = 4
+TRUNCATE_EXISTING: t.CDefine = 5
+FILE_ATTRIBUTE_READONLY: t.CDefine = 0x00000001
+FILE_ATTRIBUTE_HIDDEN: t.CDefine = 0x00000002
+FILE_ATTRIBUTE_SYSTEM: t.CDefine = 0x00000004
+FILE_ATTRIBUTE_DIRECTORY: t.CDefine = 0x00000010
+FILE_ATTRIBUTE_ARCHIVE: t.CDefine = 0x00000020
+FILE_ATTRIBUTE_NORMAL: t.CDefine = 0x00000080
+FILE_ATTRIBUTE_TEMPORARY: t.CDefine = 0x00000100
+FILE_ATTRIBUTE_COMPRESSED: t.CDefine = 0x00000800
+FILE_ATTRIBUTE_OFFLINE: t.CDefine = 0x00001000
+FILE_ATTRIBUTE_ENCRYPTED: t.CDefine = 0x00004000
+FILE_FLAG_WRITE_THROUGH: t.CDefine = 0x80000000
+FILE_FLAG_OVERLAPPED: t.CDefine = 0x40000000
+FILE_FLAG_NO_BUFFERING: t.CDefine = 0x20000000
+FILE_FLAG_RANDOM_ACCESS: t.CDefine = 0x10000000
+FILE_FLAG_SEQUENTIAL_SCAN: t.CDefine = 0x08000000
+FILE_FLAG_DELETE_ON_CLOSE: t.CDefine = 0x04000000
+FILE_FLAG_BACKUP_SEMANTICS: t.CDefine = 0x02000000
+FILE_FLAG_POSIX_SEMANTICS: t.CDefine = 0x01000000
+FILE_BEGIN: t.CDefine = 0
+FILE_CURRENT: t.CDefine = 1
+FILE_END: t.CDefine = 2
+STD_INPUT_HANDLE: t.CDefine = t.CUnsignedLong(-10)
+STD_OUTPUT_HANDLE: t.CDefine = t.CUnsignedLong(-11)
+STD_ERROR_HANDLE: t.CDefine = t.CUnsignedLong(-12)
+MOVEFILE_REPLACE_EXISTING: t.CDefine = 0x00000001
+MOVEFILE_COPY_ALLOWED: t.CDefine = 0x00000002
+MOVEFILE_WRITE_THROUGH: t.CDefine = 0x00000008
+
+class BY_HANDLE_FILE_INFORMATION:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    dwVolumeSerialNumber: ULONG
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    nNumberOfLinks: ULONG
+    nFileIndexHigh: ULONG
+    nFileIndexLow: ULONG
+class WIN32_FIND_DATAA:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    dwReserved0: ULONG
+    dwReserved1: ULONG
+    cFileName: t.CArray[t.CChar, 260]
+    cAlternateFileName: t.CArray[t.CChar, 14]
+class WIN32_FIND_DATAW:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    dwReserved0: ULONG
+    dwReserved1: ULONG
+    cFileName: t.CArray[t.CUInt16T, 260]
+    cAlternateFileName: t.CArray[t.CUInt16T, 14]
+
+def CreateFileA(lpFileName: LPCSTR, dwDesiredAccess: ULONG, dwShareMode: ULONG, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwCreationDisposition: ULONG, dwFlagsAndAttributes: ULONG, hTemplateFile: HANDLE) -> HANDLE | t.State: pass
+
+def CreateFileW(lpFileName: LPCWSTR, dwDesiredAccess: ULONG, dwShareMode: ULONG, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr, dwCreationDisposition: ULONG, dwFlagsAndAttributes: ULONG, hTemplateFile: HANDLE) -> HANDLE | t.State: pass
+
+def ReadFile(hFile: HANDLE, lpBuffer: VOIDPTR, nNumberOfBytesToRead: ULONG, lpNumberOfBytesRead: ULONG | t.CPtr, lpOverlapped: OVERLAPPED | t.CPtr) -> BOOL | t.State: pass
+
+def WriteFile(hFile: HANDLE, lpBuffer: t.CConst | VOIDPTR, nNumberOfBytesToWrite: ULONG, lpNumberOfBytesWritten: ULONG | t.CPtr, lpOverlapped: OVERLAPPED | t.CPtr) -> BOOL | t.State: pass
+
+def SetFilePointer(hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: LONG | t.CPtr, dwMoveMethod: ULONG) -> LONG | t.State: pass
+
+def SetFilePointerEx(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER | t.CPtr, lpNewFilePointer: LARGE_INTEGER | t.CPtr, dwMoveMethod: ULONG) -> BOOL | t.State: pass
+
+def GetFileSize(hFile: HANDLE, lpFileSizeHigh: ULONG | t.CPtr) -> ULONG | t.State: pass
+
+def GetFileSizeEx(hFile: HANDLE, lpFileSize: LARGE_INTEGER | t.CPtr) -> BOOL | t.State: pass
+
+def SetEndOfFile(hFile: HANDLE) -> BOOL | t.State: pass
+
+def FlushFileBuffers(hFile: HANDLE) -> BOOL | t.State: pass
+
+def GetFileType(hFile: HANDLE) -> ULONG | t.State: pass
+
+def GetFileAttributesA(lpFileName: LPCSTR) -> ULONG | t.State: pass
+
+def GetFileAttributesW(lpFileName: LPCWSTR) -> ULONG | t.State: pass
+
+def SetFileAttributesA(lpFileName: LPCSTR, dwFileAttributes: ULONG) -> BOOL | t.State: pass
+
+def SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: ULONG) -> BOOL | t.State: pass
+
+def DeleteFileA(lpFileName: LPCSTR) -> BOOL | t.State: pass
+
+def DeleteFileW(lpFileName: LPCWSTR) -> BOOL | t.State: pass
+
+def MoveFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR) -> BOOL | t.State: pass
+
+def MoveFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR) -> BOOL | t.State: pass
+
+def MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: ULONG) -> BOOL | t.State: pass
+
+def MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: ULONG) -> BOOL | t.State: pass
+
+def CopyFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL) -> BOOL | t.State: pass
+
+def CopyFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL) -> BOOL | t.State: pass
+
+def CreateDirectoryA(lpPathName: LPCSTR, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr) -> BOOL | t.State: pass
+
+def CreateDirectoryW(lpPathName: LPCWSTR, lpSecurityAttributes: SECURITY_ATTRIBUTES | t.CPtr) -> BOOL | t.State: pass
+
+def RemoveDirectoryA(lpPathName: LPCSTR) -> BOOL | t.State: pass
+
+def RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL | t.State: pass
+
+def FindFirstFileA(lpFileName: LPCSTR, lpFindFileData: WIN32_FIND_DATAA | t.CPtr) -> HANDLE | t.State: pass
+
+def FindFirstFileW(lpFileName: LPCWSTR, lpFindFileData: WIN32_FIND_DATAW | t.CPtr) -> HANDLE | t.State: pass
+
+def FindNextFileA(hFindFile: HANDLE, lpFindFileData: WIN32_FIND_DATAA | t.CPtr) -> BOOL | t.State: pass
+
+def FindNextFileW(hFindFile: HANDLE, lpFindFileData: WIN32_FIND_DATAW | t.CPtr) -> BOOL | t.State: pass
+
+def FindClose(hFindFile: HANDLE) -> BOOL | t.State: pass
+
+def GetStdHandle(nStdHandle: ULONG) -> HANDLE | t.State: pass
+
+def SetStdHandle(nStdHandle: ULONG, hHandle: HANDLE) -> BOOL | t.State: pass
+
+def GetFileInformationByHandle(hFile: HANDLE, lpFileInformation: BY_HANDLE_FILE_INFORMATION | t.CPtr) -> BOOL | t.State: pass
+
+def LockFile(hFile: HANDLE, dwFileOffsetLow: ULONG, dwFileOffsetHigh: ULONG, nNumberOfBytesToLockLow: ULONG, nNumberOfBytesToLockHigh: ULONG) -> BOOL | t.State: pass
+
+def UnlockFile(hFile: HANDLE, dwFileOffsetLow: ULONG, dwFileOffsetHigh: ULONG, nNumberOfBytesToUnlockLow: ULONG, nNumberOfBytesToUnlockHigh: ULONG) -> BOOL | t.State: pass
+
+def GetTempPathA(nBufferLength: ULONG, lpBuffer: CHARPTR) -> ULONG | t.State: pass
+
+def GetTempPathW(nBufferLength: ULONG, lpBuffer: WCHARPTR) -> ULONG | t.State: pass
+
+def GetTempFileNameA(lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: CHARPTR) -> UINT | t.State: pass
+
+def GetTempFileNameW(lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: WCHARPTR) -> UINT | t.State: pass
+
+def GetCurrentDirectoryA(nBufferLength: ULONG, lpBuffer: CHARPTR) -> ULONG | t.State: pass
+
+def GetCurrentDirectoryW(nBufferLength: ULONG, lpBuffer: WCHARPTR) -> ULONG | t.State: pass
+
+def SetCurrentDirectoryA(lpPathName: LPCSTR) -> BOOL | t.State: pass
+
+def SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL | t.State: pass
+
+def GetModuleFileNameA(hModule: HANDLE, lpFilename: CHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+def GetModuleFileNameW(hModule: HANDLE, lpFilename: WCHARPTR, nSize: ULONG) -> ULONG | t.State: pass
+
+
+HANDLE_FLAG_INHERIT: t.CDefine = 0x00000001
+HANDLE_FLAG_PROTECT_FROM_CLOSE: t.CDefine = 0x00000002
+
+def CreatePipe(hReadPipe: HANDLE | t.CPtr, hWritePipe: HANDLE | t.CPtr, lpPipeAttributes: SECURITY_ATTRIBUTES | t.CPtr, nSize: ULONG) -> BOOL | t.State: pass
+
+def SetHandleInformation(hObject: HANDLE, dwMask: ULONG, dwFlags: ULONG) -> BOOL | t.State: pass
+
+def DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: HANDLE | t.CPtr, dwDesiredAccess: ULONG, bInheritHandle: BOOL, dwOptions: ULONG) -> BOOL | t.State: pass
+
+
+DUPLICATE_SAME_ACCESS: t.CDefine = 0x00000002