补充

2026-06-16 16:09:42 +08:00
commit bffb0cb6b7
644 changed files with 86620 additions and 0 deletions
--- a/Test/ZlibTest/temp/024a3459d0f585ae.pyi
+++ b/Test/ZlibTest/temp/024a3459d0f585ae.pyi
@@ -0,0 +1,40 @@
+"""
+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 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 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 split(s: str, delim: str, result: list[str]) -> int: pass
--- a/Test/ZlibTest/temp/067c78e9f121dce3.pyi
+++ b/Test/ZlibTest/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
--- a/Test/ZlibTest/temp/0af305ed4e5f787d.pyi
+++ b/Test/ZlibTest/temp/0af305ed4e5f787d.pyi
@@ -0,0 +1,54 @@
+"""
+Auto-generated Python stub file from __zlib.zdeflate.py
+Module: __zlib.zdeflate
+"""
+
+
+from stdint import *
+import zchecksum
+import zhuff
+import zdef
+import string
+import t, c
+
+@t.Object
+class zdeflate_stream:
+    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(level: t.CInt, wbits: t.CInt, mem_level: t.CInt, strategy: t.CInt) -> zdeflate_stream | t.CPtr: pass
+
+def zdeflate_one_shot(data: UINT8PTR, length: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> t.CUInt8T | t.CPtr: pass
--- a/Test/ZlibTest/temp/29813d57621099a9.pyi
+++ b/Test/ZlibTest/temp/29813d57621099a9.pyi
@@ -0,0 +1,85 @@
+"""
+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
--- a/Test/ZlibTest/temp/56cdd754a8a09347.pyi
+++ b/Test/ZlibTest/temp/56cdd754a8a09347.pyi
@@ -0,0 +1,67 @@
+"""
+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.CLong | t.CLong
+ULONGLONG: t.CTypedef = t.CUnsignedLong | t.CLong
+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
+UINTPTR: t.CTypedef = t.CUnsignedInt | t.CPtr
+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
--- a/Test/ZlibTest/temp/5a6a2137958c28c5.pyi
+++ b/Test/ZlibTest/temp/5a6a2137958c28c5.pyi
@@ -0,0 +1,98 @@
+"""
+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
--- a/Test/ZlibTest/temp/72e2d5ccb7cedcf1.pyi
+++ b/Test/ZlibTest/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
--- a/Test/ZlibTest/temp/73edbcf76e32d00b.pyi
+++ b/Test/ZlibTest/temp/73edbcf76e32d00b.pyi
@@ -0,0 +1,28 @@
+"""
+Auto-generated Python stub file from stdio.py
+Module: stdio
+"""
+
+
+import t, c
+
+def printf(fmt: t.CChar | t.CConst | t.CPtr, *args) -> t.CInt | t.CExtern | t.CExport: pass
+
+def fprintf(stream: t.CVoid | t.CPtr, fmt: t.CChar | t.CConst | t.CPtr, *args) -> t.CInt | t.CExtern | t.CExport: pass
+
+def sprintf(buf: t.CChar | t.CPtr, fmt: t.CChar | t.CConst | t.CPtr, *args) -> t.CInt | t.CExtern | t.CExport: pass
+
+def snprintf(buf: t.CChar | t.CPtr, size: t.CSizeT, fmt: t.CChar | t.CConst | t.CPtr, *args) -> t.CInt | t.CExtern | t.CExport: pass
+
+def puts(s: t.CChar | t.CConst | t.CPtr) -> t.CInt | t.CExtern | t.CExport: pass
+
+def fputs(s: t.CChar | t.CConst | t.CPtr, stream: t.CVoid | t.CPtr) -> t.CInt | t.CExtern | t.CExport: pass
+
+def fgets(buf: t.CChar | t.CPtr, size: t.CInt, stream: t.CVoid | t.CPtr) -> t.CChar | t.CPtr | t.CExtern | t.CExport: pass
+
+def fflush(stream: t.CVoid | t.CPtr) -> t.CInt | t.CExtern | t.CExport: pass
+
+
+stdin: t.CExtern | t.CVoid | t.CPtr
+stdout: t.CExtern | t.CVoid | t.CPtr
+stderr: t.CExtern | t.CVoid | t.CPtr
--- a/Test/ZlibTest/temp/7e9fab9c7b47c4db.pyi
+++ b/Test/ZlibTest/temp/7e9fab9c7b47c4db.pyi
@@ -0,0 +1,122 @@
+"""
+Auto-generated Python stub file from __zlib.pyzlib.py
+Module: __zlib.pyzlib
+"""
+
+
+from stdint import *
+import zdeflate
+import zinflate
+import zchecksum
+import zdef
+import zhuff
+import stdlib
+import string
+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 | list[t.CChar, 512]
+pyzlib_error_code_val: t.CExtern | t.CInt
+
+@t.Object
+class Compress:
+    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:
+    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(src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def append_bytes(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(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(data: BYTEPTR, data_len: t.CSizeT, level: t.CInt, wbits: t.CInt, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def decompress(data: BYTEPTR, data_len: t.CSizeT, wbits: t.CInt, bufsize: t.CSizeT, out_len: t.CSizeT | t.CPtr) -> BYTEPTR: pass
+
+def compressobj(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(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
--- a/Test/ZlibTest/temp/95e27d852b773ae8.pyi
+++ b/Test/ZlibTest/temp/95e27d852b773ae8.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 | list[t.CUInt32T, 256]
+
+def zchecksum_crc32(data: UINT8PTR, length: t.CSizeT, init: t.CUInt32T) -> t.CUInt32T: pass
--- a/Test/ZlibTest/temp/_sha1_map.txt
+++ b/Test/ZlibTest/temp/_sha1_map.txt
@@ -0,0 +1,14 @@
+024a3459d0f585ae:includes/string.py
+0af305ed4e5f787d:__zlib\zdeflate.py
+56cdd754a8a09347:includes/stdint.py
+5a6a2137958c28c5:includes/w32\win32base.py
+72e2d5ccb7cedcf1:includes/w32\win32memory.py
+73edbcf76e32d00b:includes/stdio.py
+7e9fab9c7b47c4db:__zlib\pyzlib.py
+95e27d852b773ae8:__zlib\zchecksum.py
+a96738831f025829:includes/stdlib.py
+c9349bf1e8390dd5:__zlib\zhuff.py
+dca7ef1d57347738:main.py
+e00d9854a0d03f4f:__zlib\zinflate.py
+f9cd063200178785:__zlib\zdef.py
+ffaa1aaa1355e604:__zlib\test_pyzlib.py
--- a/Test/ZlibTest/temp/_shared_sym.pkl
+++ b/Test/ZlibTest/temp/_shared_sym.pkl
--- a/Test/ZlibTest/temp/a96738831f025829.pyi
+++ b/Test/ZlibTest/temp/a96738831f025829.pyi
@@ -0,0 +1,16 @@
+"""
+Auto-generated Python stub file from stdlib.py
+Module: stdlib
+"""
+
+import c
+
+
+from stdint import *
+import t
+
+def malloc(size: UINT) -> t.CVoid | t.CPtr | t.State | t.CExtern | t.CExport: pass
+
+def realloc(p: str, p2: t.CLong | t.CLong) -> t.CVoid | t.CPtr | t.State | t.CExtern | t.CExport: pass
+
+def free(p: t.CVoid | t.CPtr) -> None | t.State | t.CExtern | t.CExport: pass
--- a/Test/ZlibTest/temp/abf9ce3160c9279e.pyi
+++ b/Test/ZlibTest/temp/abf9ce3160c9279e.pyi
@@ -0,0 +1,179 @@
+"""
+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: CHARPTR
+    cAlternateFileName: CHARPTR
+class WIN32_FIND_DATAW:
+    dwFileAttributes: ULONG
+    ftCreationTime: FILETIME
+    ftLastAccessTime: FILETIME
+    ftLastWriteTime: FILETIME
+    nFileSizeHigh: ULONG
+    nFileSizeLow: ULONG
+    dwReserved0: ULONG
+    dwReserved1: ULONG
+    cFileName: WCHARPTR
+    cAlternateFileName: WCHARPTR
+
+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
--- a/Test/ZlibTest/temp/bbdf3bbd4c3bc28c.pyi
+++ b/Test/ZlibTest/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
--- a/Test/ZlibTest/temp/c9349bf1e8390dd5.pyi
+++ b/Test/ZlibTest/temp/c9349bf1e8390dd5.pyi
@@ -0,0 +1,41 @@
+"""
+Auto-generated Python stub file from __zlib.zhuff.py
+Module: __zlib.zhuff
+"""
+
+
+from stdint import *
+import zdef
+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:
+    codes: list[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: list[t.CInt, 2]
+    symbol: t.CInt
+@t.Object
+class zhuff_decode_tree:
+    nodes: list[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
--- a/Test/ZlibTest/temp/dca7ef1d57347738.pyi
+++ b/Test/ZlibTest/temp/dca7ef1d57347738.pyi
@@ -0,0 +1,20 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t
+import stdio
+import string
+import __zlib.pyzlib as pyzlib
+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 __zlib.test_pyzlib as tpz
+import w32.win32memory
+import c
+
+def main() -> t.CInt: pass
--- a/Test/ZlibTest/temp/e00d9854a0d03f4f.pyi
+++ b/Test/ZlibTest/temp/e00d9854a0d03f4f.pyi
@@ -0,0 +1,51 @@
+"""
+Auto-generated Python stub file from __zlib.zinflate.py
+Module: __zlib.zinflate
+"""
+
+
+from stdint import *
+import zinflate
+import zchecksum
+import zdef
+import zhuff
+import string
+import t, c
+
+@t.Object
+class zinflate_stream:
+    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(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(wbits: t.CInt) -> zinflate_stream | t.CPtr: pass
--- a/Test/ZlibTest/temp/f9cd063200178785.pyi
+++ b/Test/ZlibTest/temp/f9cd063200178785.pyi
@@ -0,0 +1,65 @@
+"""
+Auto-generated Python stub file from __zlib.zdef.py
+Module: __zlib.zdef
+"""
+
+
+from stdint import *
+import stddef
+import string
+import stdlib
+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 | list[t.CInt, 29]
+zdeflate_len_base: t.CExtern | list[t.CInt, 29]
+zdeflate_dist_extra_bits: t.CExtern | list[t.CInt, 30]
+zdeflate_dist_base: t.CExtern | list[t.CInt, 30]
+zdeflate_codelen_order: t.CExtern | list[int, 19]
+
+@t.Object
+class zbit_writer:
+    buf: BYTE | t.CPtr
+    cap: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def __init__(self: zbit_writer) -> 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(n: t.CSizeT) -> VOIDPTR: pass
+
+def zdef_free(p: VOIDPTR) -> t.CInt: pass
--- a/Test/ZlibTest/temp/fa3691e66b426950.pyi
+++ b/Test/ZlibTest/temp/fa3691e66b426950.pyi
@@ -0,0 +1,80 @@
+"""
+Auto-generated Python stub file from w32.fileio.py
+Module: w32.fileio
+"""
+
+
+import t, c
+from stdint import *
+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: HANDLE
+    closed: bool
+    can_read: bool
+    can_write: bool
+    is_append: bool
+    _share_mode: ULONG
+    def __init__(self: FileW, filename: 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
--- a/Test/ZlibTest/temp/ffaa1aaa1355e604.pyi
+++ b/Test/ZlibTest/temp/ffaa1aaa1355e604.pyi
@@ -0,0 +1,65 @@
+"""
+Auto-generated Python stub file from __zlib.test_pyzlib.py
+Module: __zlib.test_pyzlib
+"""
+
+
+from stdint import *
+import pyzlib
+import zhuff
+import zdef
+from stdio import printf, strlen
+import stdlib
+import string
+import t, c
+
+test_passed: t.CExtern | t.CInt
+test_failed: t.CExtern | t.CInt
+
+def check(name: str, condition: t.CInt, detail: str) -> t.CInt: pass
+
+def print_hex_test(data: BYTEPTR, length: t.CSizeT, max_show: t.CSizeT) -> t.CInt: pass
+
+def print_separator() -> t.CInt: pass
+
+def section_header(title: str) -> t.CInt: pass
+
+def section_footer() -> t.CInt: pass
+
+def test_version() -> t.CInt: pass
+
+def test_compress_decompress() -> t.CInt: pass
+
+def test_compress_levels() -> t.CInt: pass
+
+def test_compressobj() -> t.CInt: pass
+
+def test_decompressobj() -> t.CInt: pass
+
+def test_decompressobj_max_lengthgth() -> t.CInt: pass
+
+def test_decompressobj_unused_data() -> t.CInt: pass
+
+def test_compress_copy() -> t.CInt: pass
+
+def test_decompress_copy() -> t.CInt: pass
+
+def test_adler32() -> t.CInt: pass
+
+def test_crc32() -> t.CInt: pass
+
+def test_empty_compress() -> t.CInt: pass
+
+def test_gzip_format() -> t.CInt: pass
+
+def test_raw_deflate() -> t.CInt: pass
+
+def test_zdict() -> t.CInt: pass
+
+def test_huffman_tree() -> t.CInt: pass
+
+def test_error_handling() -> t.CInt: pass
+
+def test_constants() -> t.CInt: pass
+
+def main123456() -> t.CInt: pass