补充

Test/TestProject/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/TestProject/temp/0d13cde396f4a15f.pyi

@@ -0,0 +1,29 @@
+"""
+Auto-generated Python stub file from hashlib.__sha1.py
+Module: hashlib.__sha1
+"""
+
+
+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: list[t.CUInt32T, 5]
+    count: t.CUInt64T
+    buf: list[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: list[t.CUInt8T, SHA1_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject/temp/0d4517fd5afeb330.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 | list[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: list[t.CUInt32T, 8]
+    count: t.CUInt64T
+    buf: list[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: list[t.CUInt8T, SHA256_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject/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

Test/TestProject/temp/2d7f623c6e3004ce.pyi

@@ -0,0 +1,57 @@
+"""
+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 stdio
+import mpool
+import t, c
+
+@t.Object
+class zdeflate_stream:
+    pool: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | 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/TestProject/temp/2e756dd336749fc2.pyi

@@ -0,0 +1,108 @@
+"""
+Auto-generated Python stub file from test_numpy.py
+Module: test_numpy
+"""
+
+
+from stdint import *
+import numpy
+from stdio import printf
+from stdlib import calloc, free
+import string
+import vipermath
+import mpool
+import t, c
+
+EPS: t.CExtern | t.CDouble
+EPS_LOOSE: t.CExtern | t.CDouble
+SIMD_BLOCK: t.CExtern | t.CSizeT
+arena: t.CExtern | t.CUInt8T | t.CPtr
+pool: t.CExtern | mpool.MPool | t.CPtr
+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 approx_eq(a: t.CDouble, b: t.CDouble) -> t.CInt: pass
+
+def approx_loose(a: t.CDouble, b: t.CDouble) -> t.CInt: pass
+
+def section_header(title: str) -> t.CInt: pass
+
+def section_footer() -> t.CInt: pass
+
+def vec4(p: mpool.MPool | t.CPtr, v0: t.CDouble, v1: t.CDouble, v2: t.CDouble, v3: t.CDouble) -> numpy.ndarray | t.CPtr: pass
+
+def vec3(p: mpool.MPool | t.CPtr, v0: t.CDouble, v1: t.CDouble, v2: t.CDouble) -> numpy.ndarray | t.CPtr: pass
+
+def vec2(p: mpool.MPool | t.CPtr, v0: t.CDouble, v1: t.CDouble) -> numpy.ndarray | t.CPtr: pass
+
+def test_zeros_ones() -> t.CInt: pass
+
+def test_arange_linspace() -> t.CInt: pass
+
+def test_eye_diag() -> t.CInt: pass
+
+def test_sum_mean_min_max() -> t.CInt: pass
+
+def test_fill_copy() -> t.CInt: pass
+
+def test_add_sub_mul_div() -> t.CInt: pass
+
+def test_neg() -> t.CInt: pass
+
+def test_len() -> t.CInt: pass
+
+def test_scalar_ops() -> t.CInt: pass
+
+def test_math_funcs() -> t.CInt: pass
+
+def test_matmul() -> t.CInt: pass
+
+def test_dot() -> t.CInt: pass
+
+def test_transpose() -> t.CInt: pass
+
+def test_var_std_norm() -> t.CInt: pass
+
+def test_clip_concatenate() -> t.CInt: pass
+
+def test_sort_reverse() -> t.CInt: pass
+
+def test_print_arr() -> t.CInt: pass
+
+def test_floordiv_mod() -> t.CInt: pass
+
+def test_additional_math() -> t.CInt: pass
+
+def test_trig_hyperbolic() -> t.CInt: pass
+
+def test_degrees_radians() -> t.CInt: pass
+
+def test_cumsum_diff() -> t.CInt: pass
+
+def test_max_min_where() -> t.CInt: pass
+
+def test_flatten_trace() -> t.CInt: pass
+
+def test_outer() -> t.CInt: pass
+
+def test_bool_comparison() -> t.CInt: pass
+
+def test_linalg() -> t.CInt: pass
+
+def test_additional_creation() -> t.CInt: pass
+
+def test_interp() -> t.CInt: pass
+
+def test_numpy_edge() -> t.CInt: pass
+
+def bench_numpy_perf() -> t.CInt: pass
+
+def test_numpy_correct() -> t.CInt: pass
+
+def test_numpy_edge_main() -> t.CInt: pass
+
+def bench_numpy_main() -> t.CInt: pass
+
+def test_numpy_main() -> t.CInt: pass

Test/TestProject/temp/3d1656b26b38b359.pyi

@@ -0,0 +1,46 @@
+"""
+Auto-generated Python stub file from binascii.py
+Module: binascii
+"""
+
+
+import t, c
+import stdint
+
+HEX_CHARS: t.CExtern | list[t.CChar, None]
+HEX_VALS: t.CExtern | list[t.CInt, 256]
+B64_CHARS: t.CExtern | list[t.CChar, None]
+B64_VALS: t.CExtern | list[t.CInt, 256]
+HQX_CHARS: t.CExtern | list[t.CChar, 64]
+HQX_VALS: t.CExtern | list[t.CInt, 256]
+UU_CHARS: t.CExtern | list[t.CChar, None]
+CRC32_TABLE: t.CExtern | list[t.CUnsignedInt, 256]
+CRC_HQX_TABLE: t.CExtern | list[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/TestProject/temp/3ee89b588a1da94f.pyi

@@ -0,0 +1,13 @@
+"""
+Auto-generated Python stub file from BINASCII.py
+Module: BINASCII
+"""
+
+
+import stdio
+import stdlib
+import string
+import binascii
+import t, c
+
+def main222() -> t.CInt: pass

Test/TestProject/temp/3f7c5e78d8652535.pyi

@@ -0,0 +1,128 @@
+"""
+Auto-generated Python stub file from vipermath.py
+Module: vipermath
+"""
+
+
+import t, c
+
+U_M_PI:   t.CDefine = 3.14159265358979323846
+U_M_E:    t.CDefine = 2.71828182845904523536
+U_M_PI_2: t.CDefine = 1.57079632679489661923
+U_M_PI_4: t.CDefine = 0.78539816339744830962
+U_M_1_PI: t.CDefine = 0.31830988618379067154
+U_M_2_PI: t.CDefine = 0.63661977236758134308
+U_M_LN2:  t.CDefine = 0.69314718055994530942
+U_M_LN10: t.CDefine = 2.30258509299404568402
+U_M_2_SQRT_PI: t.CDefine = 1.77245385090551602730
+
+def radians(degrees: t.CDouble) -> t.CDouble: pass
+
+def degrees(radians: t.CDouble) -> t.CDouble: pass
+
+def sin(x: t.CDouble) -> t.CDouble: pass
+
+def cos(x: t.CDouble) -> t.CDouble: pass
+
+def tan(x: t.CDouble) -> t.CDouble: pass
+
+def asin(x: t.CDouble) -> t.CDouble: pass
+
+def acos(x: t.CDouble) -> t.CDouble: pass
+
+def _atan_core(x: t.CDouble) -> t.CDouble: pass
+
+def atan(x: t.CDouble) -> t.CDouble: pass
+
+def atan2(y: t.CDouble, x: t.CDouble) -> t.CDouble: pass
+
+def sinh(x: t.CDouble) -> t.CDouble: pass
+
+def cosh(x: t.CDouble) -> t.CDouble: pass
+
+def tanh(x: t.CDouble) -> t.CDouble: pass
+
+def exp(x: t.CDouble) -> t.CDouble: pass
+
+def log(x: t.CDouble) -> t.CDouble: pass
+
+def sqrt(x: t.CDouble) -> t.CDouble: pass
+
+def abs(x: t.CInt) -> t.CInt: pass
+
+def fabs(x: t.CDouble) -> t.CDouble: pass
+
+def labs(x: t.CLong) -> t.CLong: pass
+
+def factorial(n: t.CInt) -> t.CDouble: pass
+
+def combination(n: t.CInt, k: t.CInt) -> t.CDouble: pass
+
+def permutation(n: t.CInt, k: t.CInt) -> t.CDouble: pass
+
+def pow(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def powf(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def cbrt(x: t.CDouble) -> t.CDouble: pass
+
+def hypot(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def floor(x: t.CDouble) -> t.CDouble: pass
+
+def ceil(x: t.CDouble) -> t.CDouble: pass
+
+def round(x: t.CDouble) -> t.CDouble: pass
+
+def trunc(x: t.CDouble) -> t.CDouble: pass
+
+def fmod(x: t.CDouble, y: t.CDouble) -> t.CDouble: pass
+
+def fmodf(x: float, y: float) -> float: pass
+
+def modf(x: t.CDouble, iptr: t.CDouble | t.CPtr) -> t.CDouble: pass
+
+def log10(x: t.CDouble) -> t.CDouble: pass
+
+def log2(x: t.CDouble) -> t.CDouble: pass
+
+def exp2(x: t.CDouble) -> t.CDouble: pass
+
+def expm1(x: t.CDouble) -> t.CDouble: pass
+
+def log1p(x: t.CDouble) -> t.CDouble: pass
+
+def asinh(x: t.CDouble) -> t.CDouble: pass
+
+def acosh(x: t.CDouble) -> t.CDouble: pass
+
+def atanh(x: t.CDouble) -> t.CDouble: pass
+
+def gamma(x: t.CDouble) -> t.CDouble: pass
+
+def erf(x: t.CDouble) -> t.CDouble: pass
+
+def erfc(x: t.CDouble) -> t.CDouble: pass
+
+def sqrtf(x: t.CFloat) -> t.CFloat: pass
+
+def sinf(x: t.CFloat) -> t.CFloat: pass
+
+def cosf(x: t.CFloat) -> t.CFloat: pass
+
+def tanf(x: t.CFloat) -> t.CFloat: pass
+
+def fabsf(x: t.CFloat) -> t.CFloat: pass
+
+def floorf(x: t.CFloat) -> t.CFloat: pass
+
+def ceilf(x: t.CFloat) -> t.CFloat: pass
+
+
+class _U(t.CUnion):
+    d: t.CDouble
+    u: t.CUInt64T
+
+def isnan(x: t.CDouble) -> t.CStatic | t.CInt: pass
+
+def isinf(x: t.CDouble) -> t.CStatic | t.CInt: pass

Test/TestProject/temp/439f5b503003443f.pyi

@@ -0,0 +1,67 @@
+"""
+Auto-generated Python stub file from test_zlib.py
+Module: test_zlib
+"""
+
+
+from stdint import *
+import zlib.pyzlib as pyzlib
+import zlib.zhuff as zhuff
+import zlib.zdef as zdef
+from stdio import printf, strlen
+import stdlib
+import string
+import mpool
+import t, c
+
+pool: t.CExtern | mpool.MPool | t.CPtr
+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

Test/TestProject/temp/4638d411fd53fef0.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

Test/TestProject/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

Test/TestProject/temp/58121a0fb0ca7466.pyi

@@ -0,0 +1,17 @@
+"""
+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 test_zlib as tpz
+import test_numpy as tn
+import t, c
+
+def main() -> t.CInt | t.CExport: pass

Test/TestProject/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

Test/TestProject/temp/68c4fe4b12c908e3.pyi

@@ -0,0 +1,50 @@
+"""
+Auto-generated Python stub file from mpool.py
+Module: mpool
+"""
+
+
+import t, c
+from stdint import *
+import viperio
+import string
+
+MPOOL_ALIGN: t.CDefine = 8
+MPOOL_TYPE_SLAB: t.CDefine = 0
+MPOOL_TYPE_BUMP: t.CDefine = 2
+
+def _align_up(val: t.CSizeT, align: t.CSizeT) -> t.CSizeT: pass
+
+
+class MPool:
+    mtype: t.CInt
+    mem: t.CVoid | t.CPtr
+    mem_size: t.CSizeT
+    offset: t.CSizeT
+    high_water: t.CSizeT
+    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
+    def __init__(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
+    def _init_bump(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT) -> t.CInt: pass
+    def _init_slab(self: MPool, mem: t.CVoid | t.CPtr, mem_size: t.CSizeT, block_size: t.CSizeT) -> t.CInt: pass
+    def __enter__(self: MPool) -> 'MPool' | t.CPtr: pass
+    def __exit__(self: MPool) -> t.CInt: pass
+    def _slab_reset(self: MPool) -> t.CInt: pass
+    def alloc(self: MPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def alloc_buf(self: MPool, capacity: t.CSizeT) -> viperio.Buf | t.CPtr: pass
+    def free(self: MPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+    def realloc(self: MPool, ptr: t.CVoid | t.CPtr, old_size: t.CSizeT, new_size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def reset(self: MPool) -> t.CInt: pass
+    def _bump_alloc(self: MPool, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+    def _slab_alloc(self: MPool) -> t.CVoid | t.CPtr: pass
+    def _slab_free(self: MPool, ptr: t.CVoid | t.CPtr) -> t.CInt: pass
+
+def bump_create(mem: t.CVoid | t.CPtr, mem_size: t.CSizeT) -> MPool | t.CPtr: pass
+
+def alloc(pool: MPool | t.CPtr, size: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def reset(pool: MPool | t.CPtr) -> t.CInt: pass

Test/TestProject/temp/6aee24fdefa3cbc0.pyi

@@ -0,0 +1,44 @@
+"""
+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 atoll(src: str) -> t.CInt64T: pass
+
+def atof(src: str) -> t.CDouble: pass
+
+def split(s: str, delim: str, result: list[str]) -> int: pass

Test/TestProject/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/TestProject/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

Test/TestProject/temp/7538e542cab4c1d5.pyi

@@ -0,0 +1,18 @@
+"""
+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 calloc(nmemb: UINT, 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

Test/TestProject/temp/7e4cef8dd61984f0.pyi

@@ -0,0 +1,15 @@
+"""
+Auto-generated Python stub file from base64.py
+Module: base64
+"""
+
+
+import binascii
+import t, c
+
+b64_tab: t.CExtern | list[t.CChar, None]
+b64_dec_tab: t.CExtern | list[t.CInt8T, 80]
+
+def b64encode(s: str, out: str) -> t.CSizeT: pass
+
+def b64decode(s: str, out: t.CUInt8T | t.CPtr) -> t.CSizeT: pass

Test/TestProject/temp/88e3e48eab9e1653.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 | list[t.CUInt64T, 80]
+
+@t.Object
+class sha512:
+    state: list[t.CUInt64T, 8]
+    count: list[t.CUInt64T, 2]
+    buf: list[t.CUInt8T, SHA512_BLOCK_LEN]
+    def __init__(self: sha512) -> t.CInt: pass
+    def transform(self: sha512, block: list[t.CUInt8T, SHA512_BLOCK_LEN]) -> t.CInt: pass
+    def update(self: sha512, s: str) -> t.CInt: pass
+    def final(self: sha512, out: list[t.CUInt8T, SHA512_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject/temp/8e0d8fdba991b3b4.pyi

@@ -0,0 +1,25 @@
+"""
+Auto-generated Python stub file from config.py
+Module: config
+"""
+
+
+import stdint
+import t, c
+
+A: t.CExtern | t.CChar | t.CPtr
+
+class BIT_TEST(t.Object):
+    a: t.CInt | t.Bit(1)
+    b: t.CInt | t.Bit(1)
+    c: t.CInt | t.Bit(1)
+    d: t.CInt | t.Bit(5)
+class OOP_TEST(t.Object):
+    a: t.CInt
+    def __init__(self: OOP_TEST) -> t.CInt: pass
+    def __call__(self: OOP_TEST) -> stdint.UINT: pass
+class ENUM_TEST(t.CEnum):
+    A: t.State
+    B: t.State
+    C: t.State
+    Len: t.State

Test/TestProject/temp/94496ec50b0d13fc.pyi

@@ -0,0 +1,34 @@
+"""
+Auto-generated Python stub file from hashlib.__md5.py
+Module: hashlib.__md5
+"""
+
+
+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 | list[t.CUInt32T, 64]
+md5_S: t.CExtern | list[t.CInt, 64]
+
+@t.Object
+class md5:
+    state: list[t.CUInt32T, 4]
+    count: t.CUInt64T
+    buf: list[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: list[t.CUInt8T, MD5_DIGEST_LEN]) -> t.CInt: pass

Test/TestProject/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/TestProject/temp/_sha1_map.txt

@@ -0,0 +1,29 @@
+0d13cde396f4a15f:includes/hashlib\__sha1.py
+0d4517fd5afeb330:includes/hashlib\__sha256.py
+2d7f623c6e3004ce:includes/zlib\zdeflate.py
+2e756dd336749fc2:test_numpy.py
+3d1656b26b38b359:includes/binascii.py
+3ee89b588a1da94f:BINASCII.py
+3f7c5e78d8652535:includes/vipermath.py
+439f5b503003443f:test_zlib.py
+4638d411fd53fef0:includes/zlib\zchecksum.py
+56cdd754a8a09347:includes/stdint.py
+58121a0fb0ca7466:main.py
+5a6a2137958c28c5:includes/w32\win32base.py
+68c4fe4b12c908e3:includes/mpool.py
+6aee24fdefa3cbc0:includes/string.py
+73edbcf76e32d00b:includes/stdio.py
+7538e542cab4c1d5:includes/stdlib.py
+7e4cef8dd61984f0:includes/base64.py
+88e3e48eab9e1653:includes/hashlib\__sha512.py
+8e0d8fdba991b3b4:config.py
+94496ec50b0d13fc:includes/hashlib\__md5.py
+96837bcc64032444:includes/hashlib\__init__.py
+a9fa0f6200c09e65:includes/zlib\zdef.py
+b0267503e816efc4:includes/zlib\zhuff.py
+ba2e1c2dfc8e2f85:HASHLIB.py
+bbdf3bbd4c3bc28c:includes/w32\win32console.py
+c3eb91093118e1e1:includes/numpy\__init__.py
+c9f4be41ca1cc2b4:includes/viperio.py
+d282a7cb3385ecf0:includes/zlib\pyzlib.py
+f9629b8eb4ebdcc2:includes/zlib\zinflate.py

Test/TestProject/temp/a9fa0f6200c09e65.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 mpool
+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:
+    pool: mpool.MPool | t.CPtr
+    buf: BYTE | t.CPtr
+    cap: t.CSizeT
+    byte_pos: t.CSizeT
+    bit_pos: t.CInt
+    def __init__(self: zbit_writer, pool: mpool.MPool | 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: mpool.MPool | t.CPtr, n: t.CSizeT) -> VOIDPTR: pass
+
+def zdef_free(pool: mpool.MPool | t.CPtr, p: VOIDPTR) -> t.CInt: pass

Test/TestProject/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

Test/TestProject/temp/b0267503e816efc4.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 mpool
+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: mpool.MPool | t.CPtr
+    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:
+    pool: mpool.MPool | t.CPtr
+    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

Test/TestProject/temp/ba2e1c2dfc8e2f85.pyi

@@ -0,0 +1,19 @@
+"""
+Auto-generated Python stub file from HASHLIB.py
+Module: HASHLIB
+"""
+
+
+import stdio
+import stdlib
+import string
+import stdint
+import t, c
+import base64
+import hashlib
+
+def default_value_test_function(a: t.CInt, b: t.CInt) -> t.CInt: pass
+
+def print_hex(buf: t.CUInt8T | t.CPtr, length: t.CInt) -> t.CInt: pass
+
+def main1() -> t.CInt: pass

Test/TestProject/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/TestProject/temp/c3eb91093118e1e1.pyi

@@ -0,0 +1,234 @@
+"""
+Auto-generated Python stub file from numpy.__init__.py
+Module: numpy.__init__
+"""
+
+
+from stdint import *
+import stdlib
+import string
+import vipermath
+import stdio
+import t, c
+import mpool
+
+MAX_NDIM: t.CDefine = 4
+float64: t.CTypedef = t.CDouble
+float32: t.CTypedef = t.CFloat
+int64: t.CTypedef = t.CLong
+int32: t.CTypedef = t.CInt
+uint8: t.CTypedef = t.CUnsignedChar
+pi: t.CDefine = 3.14159265358979323846
+e:  t.CDefine = 2.71828182845904523536
+
+@t.Object
+class ndarray:
+    data: t.CDouble | t.CPtr
+    shape: list[t.CSizeT, MAX_NDIM]
+    strides: list[t.CSizeT, MAX_NDIM]
+    ndim: t.CInt
+    size: t.CSizeT
+    owns_data: t.CInt
+    pool: mpool.MPool | t.CPtr
+    def __new__(self: ndarray, pool: mpool.MPool | t.CPtr, n: t.CSizeT) -> t.CInt: pass
+    def __add__(self: ndarray, other: 'ndarray' | t.CPtr) -> 'ndarray' | t.CPtr: pass
+    def __sub__(self: ndarray, other: 'ndarray' | t.CPtr) -> 'ndarray' | t.CPtr: pass
+    def __mul__(self: ndarray, other: 'ndarray' | t.CPtr) -> 'ndarray' | t.CPtr: pass
+    def __truediv__(self: ndarray, other: 'ndarray' | t.CPtr) -> 'ndarray' | t.CPtr: pass
+    def __floordiv__(self: ndarray, other: 'ndarray' | t.CPtr) -> 'ndarray' | t.CPtr: pass
+    def __mod__(self: ndarray, other: 'ndarray' | t.CPtr) -> 'ndarray' | t.CPtr: pass
+    def __neg__(self: ndarray) -> 'ndarray' | t.CPtr: pass
+    def __len__(self: ndarray) -> t.CInt: pass
+    def at2d(self: ndarray, row: t.CSizeT, col: t.CSizeT) -> t.CDouble: pass
+    def set2d(self: ndarray, row: t.CSizeT, col: t.CSizeT, val: t.CDouble) -> t.CInt: pass
+    def delete(self: ndarray) -> t.CInt: pass
+    def fill(self: ndarray, val: t.CDouble) -> t.CInt: pass
+    def copy(self: ndarray) -> 'ndarray' | t.CPtr: pass
+    def reshape(self: ndarray, new_shape: INTPTR, new_ndim: t.CInt) -> 'ndarray' | t.CPtr: pass
+    def sum(self: ndarray) -> t.CDouble: pass
+    def mean(self: ndarray) -> t.CDouble: pass
+    def min(self: ndarray) -> t.CDouble: pass
+    def max(self: ndarray) -> t.CDouble: pass
+    def argmax(self: ndarray) -> t.CInt: pass
+    def argmin(self: ndarray) -> t.CInt: pass
+    def dot(self: ndarray, other: 'ndarray' | t.CPtr) -> t.CDouble: pass
+    def T(self: ndarray) -> 'ndarray' | t.CPtr: pass
+    def print_arr(self: ndarray) -> t.CInt: pass
+
+def _alloc_ndarray(pool: mpool.MPool | t.CPtr) -> ndarray | t.CPtr: pass
+
+def _compute_strides(a: ndarray | t.CPtr) -> t.CInt: pass
+
+def _empty_like(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def array(pool: mpool.MPool | t.CPtr, data: t.CDouble | t.CPtr, n: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def zeros(pool: mpool.MPool | t.CPtr, n: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def ones(pool: mpool.MPool | t.CPtr, n: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def full(pool: mpool.MPool | t.CPtr, n: t.CSizeT, val: t.CDouble) -> ndarray | t.CPtr: pass
+
+def arange(pool: mpool.MPool | t.CPtr, start: t.CDouble, stop: t.CDouble, step: t.CDouble) -> ndarray | t.CPtr: pass
+
+def linspace(pool: mpool.MPool | t.CPtr, start: t.CDouble, stop: t.CDouble, num: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def empty2d(pool: mpool.MPool | t.CPtr, rows: t.CSizeT, cols: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def zeros2d(pool: mpool.MPool | t.CPtr, rows: t.CSizeT, cols: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def ones2d(pool: mpool.MPool | t.CPtr, rows: t.CSizeT, cols: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def eye(pool: mpool.MPool | t.CPtr, n: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def diag(pool: mpool.MPool | t.CPtr, vals: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_abs(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_sqrt(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_exp(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_log(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_sin(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_cos(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_tan(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_pow(a: ndarray | t.CPtr, p: t.CDouble) -> ndarray | t.CPtr: pass
+
+def add_scalar(a: ndarray | t.CPtr, s: t.CDouble) -> ndarray | t.CPtr: pass
+
+def mul_scalar(a: ndarray | t.CPtr, s: t.CDouble) -> ndarray | t.CPtr: pass
+
+def sub_scalar(a: ndarray | t.CPtr, s: t.CDouble) -> ndarray | t.CPtr: pass
+
+def div_scalar(a: ndarray | t.CPtr, s: t.CDouble) -> ndarray | t.CPtr: pass
+
+def matmul(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def dot_product(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> t.CDouble: pass
+
+def np_sum(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def np_mean(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def np_min(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def np_max(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def np_argmax(a: ndarray | t.CPtr) -> t.CInt: pass
+
+def np_argmin(a: ndarray | t.CPtr) -> t.CInt: pass
+
+def var(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def std(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def norm(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def clip(a: ndarray | t.CPtr, lo: t.CDouble, hi: t.CDouble) -> ndarray | t.CPtr: pass
+
+def concatenate(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def sort_arr(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def reverse(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_log10(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_log2(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_floor(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_ceil(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_round(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_sign(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_tanh(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_sinh(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_cosh(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_arcsin(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_arccos(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_arctan(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_arctan2(y: ndarray | t.CPtr, x: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_degrees(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_radians(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_isnan(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_isinf(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_maximum(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_minimum(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def cumsum(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def diff(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def flatten(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def trace(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def outer(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_where(condition: ndarray | t.CPtr, x: ndarray | t.CPtr, y: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_count_nonzero(a: ndarray | t.CPtr) -> t.CInt: pass
+
+def np_all(a: ndarray | t.CPtr) -> t.CInt: pass
+
+def np_any(a: ndarray | t.CPtr) -> t.CInt: pass
+
+def np_equal(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_not_equal(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_less(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_greater(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_less_equal(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_greater_equal(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def empty(pool: mpool.MPool | t.CPtr, n: t.CSizeT) -> ndarray | t.CPtr: pass
+
+def full2d(pool: mpool.MPool | t.CPtr, rows: t.CSizeT, cols: t.CSizeT, val: t.CDouble) -> ndarray | t.CPtr: pass
+
+def zeros_like(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def ones_like(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def arange1(pool: mpool.MPool | t.CPtr, stop: t.CDouble) -> ndarray | t.CPtr: pass
+
+def linspace2(pool: mpool.MPool | t.CPtr, start: t.CDouble, stop: t.CDouble) -> ndarray | t.CPtr: pass
+
+def meshgrid(x: ndarray | t.CPtr, y: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def det2x2(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def inv2x2(a: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def cross3(a: ndarray | t.CPtr, b: ndarray | t.CPtr) -> ndarray | t.CPtr: pass
+
+def np_interp(x: t.CDouble, xp: ndarray | t.CPtr, fp: ndarray | t.CPtr) -> t.CDouble: pass
+
+def prod(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def median(a: ndarray | t.CPtr) -> t.CDouble: pass
+
+def percentile(a: ndarray | t.CPtr, q: t.CDouble) -> t.CDouble: pass

Test/TestProject/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/TestProject/temp/d282a7cb3385ecf0.pyi

@@ -0,0 +1,126 @@
+"""
+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 stdio
+import mpool
+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:
+    pool: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | t.CPtr, src: BYTEPTR, length: t.CSizeT) -> BYTEPTR: pass
+
+def append_bytes(pool: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | 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/TestProject/temp/f9629b8eb4ebdcc2.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 mpool
+import t, c
+
+@t.Object
+class zinflate_stream:
+    pool: mpool.MPool | 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: mpool.MPool | 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: mpool.MPool | t.CPtr, wbits: t.CInt) -> zinflate_stream | t.CPtr: pass

Test/TestProject/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