snapshot before regression test

TransPyV/Test/Sha1Test/temp/271ea3decb810db2.pyi

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

TransPyV/Test/Sha1Test/temp/6f62fe05c5ea1ceb.pyi

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

TransPyV/Test/Sha1Test/temp/6ff26590374ae6fc.pyi

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

TransPyV/Test/Sha1Test/temp/73fcdc4dd1618580.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: t.CArray[t.CUInt32T, 5]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, SHA1_BLOCK_LEN]
+    def __init__(self: sha1) -> t.CInt: pass
+    def transform(self: sha1, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: sha1, s: str) -> t.CInt: pass
+    def final(self: sha1, out: t.CArray[t.CUInt8T, SHA1_DIGEST_LEN]) -> t.CInt: pass

TransPyV/Test/Sha1Test/temp/83210a72e829a086.pyi

@@ -0,0 +1,46 @@
+"""
+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 strstr(s: str, needle: str) -> str: pass
+
+def strspn(s: str, skip: str) -> int: pass
+
+def memset(ptr: t.CVoid | t.CPtr, value: t.CInt, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memset32(ptr: t.CVoid | t.CPtr, value: t.CUInt32T, count: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def memcpy(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr | t.CExport: pass
+
+def memmove(dest: t.CVoid | t.CPtr, src: t.CVoid | t.CPtr, num: t.CSizeT) -> t.CVoid | t.CPtr: pass
+
+def atoi(src: str) -> t.CInt: pass
+
+def atoll(src: str) -> t.CInt64T: pass
+
+def atof(src: str) -> t.CDouble: pass
+
+def split(s: str, delim: str, result: t.CArray[str]) -> int: pass

TransPyV/Test/Sha1Test/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

TransPyV/Test/Sha1Test/temp/_phase1_manifest.json

@@ -0,0 +1 @@
+{"D:\\Users\\TermiNexus\\Desktop\\TransPyC\\TransPyV\\Test\\Sha1Test\\App\\main.py": {"sha1": "f3458d483d1f87c2", "mtime": 1783397909.5463412, "size": 1508}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\atom.py": {"sha1": "271ea3decb810db2", "mtime": 1782226548.693161, "size": 1290}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__init__.py": {"sha1": "96837bcc64032444", "mtime": 1777902641.540433, "size": 186}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__md5.py": {"sha1": "cc436a125bbaf28c", "mtime": 1782266200.556964, "size": 5797}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__sha1.py": {"sha1": "73fcdc4dd1618580", "mtime": 1782266202.164787, "size": 4501}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__sha256.py": {"sha1": "c9d54a4158f7f5a8", "mtime": 1782266203.9352357, "size": 5332}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\hashlib\\__sha512.py": {"sha1": "6ff26590374ae6fc", "mtime": 1782266223.3380039, "size": 7162}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\memhub.py": {"sha1": "ee084e9fc6ee413a", "mtime": 1783101063.0559144, "size": 17765}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdint.py": {"sha1": "f5522571bcce7bcb", "mtime": 1782383975.8824987, "size": 4356}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdio.py": {"sha1": "6f62fe05c5ea1ceb", "mtime": 1783239556.0959673, "size": 714}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\stdlib.py": {"sha1": "e79ec1d5e09b18bc", "mtime": 1782810965.1928923, "size": 382}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\string.py": {"sha1": "83210a72e829a086", "mtime": 1782786805.5320292, "size": 9548}, "D:\\Users\\TermiNexus\\Desktop\\TransPyC\\includes\\viperio.py": {"sha1": "c9f4be41ca1cc2b4", "mtime": 1782812279.506002, "size": 1556}}

TransPyV/Test/Sha1Test/temp/_sha1_map.txt

@@ -0,0 +1,13 @@
+271ea3decb810db2:includes/atom.py
+6f62fe05c5ea1ceb:includes/stdio.py
+6ff26590374ae6fc:includes/hashlib\__sha512.py
+73fcdc4dd1618580:includes/hashlib\__sha1.py
+83210a72e829a086:includes/string.py
+96837bcc64032444:includes/hashlib\__init__.py
+c9d54a4158f7f5a8:includes/hashlib\__sha256.py
+c9f4be41ca1cc2b4:includes/viperio.py
+cc436a125bbaf28c:includes/hashlib\__md5.py
+e79ec1d5e09b18bc:includes/stdlib.py
+ee084e9fc6ee413a:includes/memhub.py
+f3458d483d1f87c2:main.py
+f5522571bcce7bcb:includes/stdint.py

TransPyV/Test/Sha1Test/temp/c9d54a4158f7f5a8.pyi

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

TransPyV/Test/Sha1Test/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

TransPyV/Test/Sha1Test/temp/cc436a125bbaf28c.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 | t.CArray[t.CUInt32T, 64]
+md5_S: t.CExtern | t.CArray[t.CInt, 64]
+
+@t.Object
+class md5:
+    state: t.CArray[t.CUInt32T, 4]
+    count: t.CUInt64T
+    buf: t.CArray[t.CUInt8T, MD5_BLOCK_LEN]
+    def __init__(self: md5) -> t.CInt: pass
+    def transform(self: md5, block: t.CUInt8T | t.CPtr) -> t.CInt: pass
+    def update(self: md5, s: str) -> t.CInt: pass
+    def final(self: md5, out: t.CArray[t.CUInt8T, MD5_DIGEST_LEN]) -> t.CInt: pass

TransPyV/Test/Sha1Test/temp/e79ec1d5e09b18bc.pyi

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

TransPyV/Test/Sha1Test/temp/ee084e9fc6ee413a.pyi

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

TransPyV/Test/Sha1Test/temp/f3458d483d1f87c2.doc.json

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

TransPyV/Test/Sha1Test/temp/f3458d483d1f87c2.pyi

@@ -0,0 +1,17 @@
+"""
+Auto-generated Python stub file from main.py
+Module: main
+"""
+
+
+import t, c
+from stdint import *
+import stdio
+import stdlib
+import memhub
+import hashlib
+
+POOL_SIZE: t.CDefine = 16777480
+
+@t.CExport
+def main() -> int: pass

TransPyV/Test/Sha1Test/temp/f5522571bcce7bcb.pyi

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