Python.bi

#pragma once

#include once "crt/long.bi"
#include once "crt/limits.bi"
#include once "crt/stdio.bi"
#include once "crt/string.bi"
#include once "crt/errno.bi"
#include once "crt/stdlib.bi"
#include once "crt/stdint.bi"
#include once "crt/math.bi"
#include once "crt/time.bi"
#include once "crt/stdarg.bi"
#include once "crt/ctype.bi"
#include once "crt/wchar.bi"
#include once "crt/stddef.bi"

'' The following symbols have been renamed:
''     #define _Py_IDENTIFIER => _Py_IDENTIFIER_
''     typedef destructor => destructor_
''     #define TYPE => TYPE_
''     #define STR => STR_

extern "C"

#define Py_PYTHON_H
const PY_RELEASE_LEVEL_ALPHA = &hA
const PY_RELEASE_LEVEL_BETA = &hB
const PY_RELEASE_LEVEL_GAMMA = &hC
const PY_RELEASE_LEVEL_FINAL = &hF
const PY_MAJOR_VERSION = 3
const PY_MINOR_VERSION = 5
const PY_MICRO_VERSION = 2
const PY_RELEASE_LEVEL = PY_RELEASE_LEVEL_FINAL
const PY_RELEASE_SERIAL = 0
#define PY_VERSION "3.5.2"
const PY_VERSION_HEX = ((((PY_MAJOR_VERSION shl 24) or (PY_MINOR_VERSION shl 16)) or (PY_MICRO_VERSION shl 8)) or (PY_RELEASE_LEVEL shl 4)) or (PY_RELEASE_SERIAL shl 0)
#define Py_PYCONFIG_H
const DOUBLE_IS_LITTLE_ENDIAN_IEEE754 = 1
const ENABLE_IPV6 = 1
const HAVE_ACCEPT4 = 1
const HAVE_ACOSH = 1
const HAVE_ADDRINFO = 1
const HAVE_ALARM = 1
const HAVE_ALLOCA_H = 1
const HAVE_ASINH = 1
const HAVE_ASM_TYPES_H = 1
const HAVE_ATANH = 1
const HAVE_BIND_TEXTDOMAIN_CODESET = 1
const HAVE_BLUETOOTH_BLUETOOTH_H = 1
const HAVE_BUILTIN_ATOMIC = 1
const HAVE_C99_BOOL = 1
const HAVE_CHOWN = 1
const HAVE_CHROOT = 1
const HAVE_CLOCK = 1
const HAVE_CLOCK_GETRES = 1
const HAVE_CLOCK_GETTIME = 1
const HAVE_COMPUTED_GOTOS = 1
const HAVE_CONFSTR = 1
const HAVE_COPYSIGN = 1
const HAVE_CTERMID = 1
const HAVE_CURSES_H = 1
const HAVE_CURSES_IS_TERM_RESIZED = 1
const HAVE_CURSES_RESIZETERM = 1
const HAVE_CURSES_RESIZE_TERM = 1
const HAVE_DECL_ISFINITE = 1
const HAVE_DECL_ISINF = 1
const HAVE_DECL_ISNAN = 1
const HAVE_DEVICE_MACROS = 1
const HAVE_DEV_PTMX = 1
const HAVE_DIRENT_D_TYPE = 1
const HAVE_DIRENT_H = 1
const HAVE_DIRFD = 1
const HAVE_DLFCN_H = 1
const HAVE_DLOPEN = 1
const HAVE_DUP2 = 1
const HAVE_DUP3 = 1
const HAVE_DYNAMIC_LOADING = 1
const HAVE_ENDIAN_H = 1
const HAVE_EPOLL = 1
const HAVE_EPOLL_CREATE1 = 1
const HAVE_ERF = 1
const HAVE_ERFC = 1
const HAVE_ERRNO_H = 1
const HAVE_EXECV = 1
const HAVE_EXPM1 = 1
const HAVE_FACCESSAT = 1
const HAVE_FCHDIR = 1
const HAVE_FCHMOD = 1
const HAVE_FCHMODAT = 1
const HAVE_FCHOWN = 1
const HAVE_FCHOWNAT = 1
const HAVE_FCNTL_H = 1
const HAVE_FDATASYNC = 1
const HAVE_FDOPENDIR = 1
const HAVE_FEXECVE = 1
const HAVE_FINITE = 1
const HAVE_FLOCK = 1
const HAVE_FORK = 1
const HAVE_FORKPTY = 1
const HAVE_FPATHCONF = 1
const HAVE_FSEEKO = 1
const HAVE_FSTATAT = 1
const HAVE_FSTATVFS = 1
const HAVE_FSYNC = 1
const HAVE_FTELLO = 1
const HAVE_FTIME = 1
const HAVE_FTRUNCATE = 1
const HAVE_FUTIMENS = 1
const HAVE_FUTIMES = 1
const HAVE_FUTIMESAT = 1
const HAVE_GAI_STRERROR = 1
const HAVE_GAMMA = 1
const HAVE_GCC_ASM_FOR_X64 = 1
const HAVE_GCC_ASM_FOR_X87 = 1
const HAVE_GCC_UINT128_T = 1
const HAVE_GETADDRINFO = 1
const HAVE_GETC_UNLOCKED = 1
const HAVE_GETGROUPLIST = 1
const HAVE_GETGROUPS = 1
const HAVE_GETHOSTBYNAME_R = 1
const HAVE_GETHOSTBYNAME_R_6_ARG = 1
const HAVE_GETITIMER = 1
const HAVE_GETLOADAVG = 1
const HAVE_GETLOGIN = 1
const HAVE_GETNAMEINFO = 1
const HAVE_GETPAGESIZE = 1
const HAVE_GETPEERNAME = 1
const HAVE_GETPGID = 1
const HAVE_GETPGRP = 1
const HAVE_GETPID = 1
const HAVE_GETPRIORITY = 1
const HAVE_GETPWENT = 1
const HAVE_GETRANDOM_SYSCALL = 1
const HAVE_GETRESGID = 1
const HAVE_GETRESUID = 1
const HAVE_GETSID = 1
const HAVE_GETSPENT = 1
const HAVE_GETSPNAM = 1
const HAVE_GETTIMEOFDAY = 1
const HAVE_GETWD = 1
const HAVE_GRP_H = 1
const HAVE_HSTRERROR = 1
const HAVE_HTOLE64 = 1
const HAVE_HYPOT = 1
const HAVE_IF_NAMEINDEX = 1
const HAVE_INET_ATON = 1
const HAVE_INET_PTON = 1
const HAVE_INITGROUPS = 1
const HAVE_INT32_T = 1
const HAVE_INT64_T = 1
const HAVE_INTTYPES_H = 1
const HAVE_KILL = 1
const HAVE_KILLPG = 1
const HAVE_LANGINFO_H = 1
const HAVE_LCHOWN = 1
const HAVE_LGAMMA = 1
const HAVE_LIBDL = 1
const HAVE_LIBINTL_H = 1
const HAVE_LIBREADLINE = 1
const HAVE_LINK = 1
const HAVE_LINKAT = 1
const HAVE_LINUX_CAN_BCM_H = 1
const HAVE_LINUX_CAN_H = 1
const HAVE_LINUX_CAN_RAW_FD_FRAMES = 1
const HAVE_LINUX_CAN_RAW_H = 1
const HAVE_LINUX_NETLINK_H = 1
const HAVE_LINUX_TIPC_H = 1
const HAVE_LINUX_RANDOM_H = 1
const HAVE_LOCKF = 1
const HAVE_LOG1P = 1
const HAVE_LOG2 = 1
const HAVE_LONG_DOUBLE = 1
const HAVE_LONG_LONG = 1
const HAVE_LSTAT = 1
const HAVE_LUTIMES = 1
const HAVE_MAKEDEV = 1
const HAVE_MBRTOWC = 1
const HAVE_MEMMOVE = 1
const HAVE_MEMORY_H = 1
const HAVE_MEMRCHR = 1
const HAVE_MKDIRAT = 1
const HAVE_MKFIFO = 1
const HAVE_MKFIFOAT = 1
const HAVE_MKNOD = 1
const HAVE_MKNODAT = 1
const HAVE_MKTIME = 1
const HAVE_MMAP = 1
const HAVE_MREMAP = 1
const HAVE_NCURSES_H = 1
const HAVE_NETPACKET_PACKET_H = 1
const HAVE_NET_IF_H = 1
const HAVE_NICE = 1
const HAVE_OPENAT = 1
const HAVE_OPENPTY = 1
const HAVE_PATHCONF = 1
const HAVE_PAUSE = 1
const HAVE_PIPE2 = 1
const HAVE_POLL = 1
const HAVE_POLL_H = 1
const HAVE_POSIX_FADVISE = 1
const HAVE_POSIX_FALLOCATE = 1
const HAVE_PREAD = 1
const HAVE_PRLIMIT = 1
const HAVE_PROTOTYPES = 1
const HAVE_PTHREAD_ATFORK = 1
const HAVE_PTHREAD_H = 1
const HAVE_PTHREAD_KILL = 1
const HAVE_PTHREAD_SIGMASK = 1
const HAVE_PTY_H = 1
const HAVE_PUTENV = 1
const HAVE_PWRITE = 1
const HAVE_RAND_EGD = 1
const HAVE_READLINK = 1
const HAVE_READLINKAT = 1
const HAVE_READV = 1
const HAVE_REALPATH = 1
const HAVE_RENAMEAT = 1
const HAVE_RL_APPEND_HISTORY = 1
const HAVE_RL_CALLBACK = 1
const HAVE_RL_CATCH_SIGNAL = 1
const HAVE_RL_COMPLETION_APPEND_CHARACTER = 1
const HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK = 1
const HAVE_RL_COMPLETION_MATCHES = 1
const HAVE_RL_COMPLETION_SUPPRESS_APPEND = 1
const HAVE_RL_PRE_INPUT_HOOK = 1
const HAVE_RL_RESIZE_TERMINAL = 1
const HAVE_ROUND = 1
const HAVE_SCHED_GET_PRIORITY_MAX = 1
const HAVE_SCHED_H = 1
const HAVE_SCHED_RR_GET_INTERVAL = 1
const HAVE_SCHED_SETAFFINITY = 1
const HAVE_SCHED_SETPARAM = 1
const HAVE_SCHED_SETSCHEDULER = 1
const HAVE_SELECT = 1
const HAVE_SEM_GETVALUE = 1
const HAVE_SEM_OPEN = 1
const HAVE_SEM_TIMEDWAIT = 1
const HAVE_SEM_UNLINK = 1
const HAVE_SENDFILE = 1
const HAVE_SETEGID = 1
const HAVE_SETEUID = 1
const HAVE_SETGID = 1
const HAVE_SETGROUPS = 1
const HAVE_SETHOSTNAME = 1
const HAVE_SETITIMER = 1
const HAVE_SETLOCALE = 1
const HAVE_SETPGID = 1
const HAVE_SETPGRP = 1
const HAVE_SETPRIORITY = 1
const HAVE_SETREGID = 1
const HAVE_SETRESGID = 1
const HAVE_SETRESUID = 1
const HAVE_SETREUID = 1
const HAVE_SETSID = 1
const HAVE_SETUID = 1
const HAVE_SETVBUF = 1
const HAVE_SHADOW_H = 1
const HAVE_SIGACTION = 1
const HAVE_SIGALTSTACK = 1
const HAVE_SIGINTERRUPT = 1
const HAVE_SIGNAL_H = 1
const HAVE_SIGPENDING = 1
const HAVE_SIGRELSE = 1
const HAVE_SIGTIMEDWAIT = 1
const HAVE_SIGWAIT = 1
const HAVE_SIGWAITINFO = 1
const HAVE_SNPRINTF = 1
const HAVE_SOCKADDR_STORAGE = 1
const HAVE_SOCKETPAIR = 1
const HAVE_SPAWN_H = 1
const HAVE_SSIZE_T = 1
const HAVE_STATVFS = 1
const HAVE_STAT_TV_NSEC = 1
const HAVE_STDARG_PROTOTYPES = 1
const HAVE_STDINT_H = 1
const HAVE_STDLIB_H = 1
const HAVE_STD_ATOMIC = 1
const HAVE_STRDUP = 1
const HAVE_STRFTIME = 1
const HAVE_STRINGS_H = 1
const HAVE_STRING_H = 1
const HAVE_STROPTS_H = 1
const HAVE_STRUCT_STAT_ST_BLKSIZE = 1
const HAVE_STRUCT_STAT_ST_BLOCKS = 1
const HAVE_STRUCT_STAT_ST_RDEV = 1
const HAVE_STRUCT_TM_TM_ZONE = 1
const HAVE_SYMLINK = 1
const HAVE_SYMLINKAT = 1
const HAVE_SYNC = 1
const HAVE_SYSCONF = 1
const HAVE_SYSEXITS_H = 1
const HAVE_SYS_EPOLL_H = 1
const HAVE_SYS_FILE_H = 1
const HAVE_SYS_IOCTL_H = 1
const HAVE_SYS_PARAM_H = 1
const HAVE_SYS_POLL_H = 1
const HAVE_SYS_RESOURCE_H = 1
const HAVE_SYS_SELECT_H = 1
const HAVE_SYS_SENDFILE_H = 1
const HAVE_SYS_SOCKET_H = 1
const HAVE_SYS_STATVFS_H = 1
const HAVE_SYS_STAT_H = 1
const HAVE_SYS_SYSCALL_H = 1
const HAVE_SYS_TIMES_H = 1
const HAVE_SYS_TIME_H = 1
const HAVE_SYS_TYPES_H = 1
const HAVE_SYS_UIO_H = 1
const HAVE_SYS_UN_H = 1
const HAVE_SYS_UTSNAME_H = 1
const HAVE_SYS_WAIT_H = 1
const HAVE_SYS_XATTR_H = 1
const HAVE_TCGETPGRP = 1
const HAVE_TCSETPGRP = 1
const HAVE_TEMPNAM = 1
const HAVE_TERMIOS_H = 1
const HAVE_TERM_H = 1
const HAVE_TGAMMA = 1
const HAVE_TIMEGM = 1
const HAVE_TIMES = 1
const HAVE_TMPFILE = 1
const HAVE_TMPNAM = 1
const HAVE_TMPNAM_R = 1
const HAVE_TM_ZONE = 1
const HAVE_TRUNCATE = 1
const HAVE_UINT32_T = 1
const HAVE_UINT64_T = 1
const HAVE_UINTPTR_T = 1
const HAVE_UNAME = 1
const HAVE_UNISTD_H = 1
const HAVE_UNLINKAT = 1
const HAVE_UNSETENV = 1
const HAVE_UTIMENSAT = 1
const HAVE_UTIMES = 1
const HAVE_UTIME_H = 1
const HAVE_WAIT3 = 1
const HAVE_WAIT4 = 1
const HAVE_WAITID = 1
const HAVE_WAITPID = 1
const HAVE_WCHAR_H = 1
const HAVE_WCSCOLL = 1
const HAVE_WCSFTIME = 1
const HAVE_WCSXFRM = 1
const HAVE_WMEMCMP = 1
const HAVE_WORKING_TZSET = 1
const HAVE_WRITEV = 1
const HAVE_ZLIB_COPY = 1
const MVWDELCH_IS_EXPRESSION = 1
const PTHREAD_SYSTEM_SCHED_SUPPORTED = 1
#define PY_FORMAT_LONG_LONG "ll"
#define PY_FORMAT_SIZE_T "z"
const Py_ENABLE_SHARED = 1
type RETSIGTYPE as any
const SIZEOF_DOUBLE = 8
const SIZEOF_FLOAT = 4
const SIZEOF_FPOS_T = 16
const SIZEOF_INT = 4
const SIZEOF_LONG = 8
const SIZEOF_LONG_DOUBLE = 16
const SIZEOF_LONG_LONG = 8
const SIZEOF_OFF_T = 8
const SIZEOF_PID_T = 4
const SIZEOF_PTHREAD_T = 8
const SIZEOF_SHORT = 2
const SIZEOF_SIZE_T = 8
const SIZEOF_TIME_T = 8
const SIZEOF_UINTPTR_T = 8
const SIZEOF_VOID_P = 8
const SIZEOF_WCHAR_T = 4
const SIZEOF__BOOL = 1
const STDC_HEADERS = 1
const SYS_SELECT_WITH_SYS_TIME = 1
const TANH_PRESERVES_ZERO_SIGN = 1
const TIME_WITH_SYS_TIME = 1
const USE_INLINE = 1
const _ALL_SOURCE = 1
const _GNU_SOURCE = 1
const _POSIX_PTHREAD_SEMANTICS = 1
const _TANDEM_SOURCE = 1
const __EXTENSIONS__ = 1
const VA_LIST_IS_ARRAY = 1
const WINDOW_HAS_FLAGS = 1
const WITH_DOC_STRINGS = 1
const WITH_PYMALLOC = 1
const WITH_THREAD = 1
const _BSD_TYPES = 1
const _DARWIN_C_SOURCE = 1
const _FILE_OFFSET_BITS = 64
const _GNU_SOURCE = 1
const _LARGEFILE_SOURCE = 1
const _NETBSD_SOURCE = 1
const _POSIX_C_SOURCE = cast(clong, 200809)
const _XOPEN_SOURCE = 700
const _XOPEN_SOURCE_EXTENDED = 1
const __BSD_VISIBLE = 1
#define PYMACCONFIG_H
#define Py_PYPORT_H
type PY_LONG_LONG as longint
#define PY_LLONG_MIN LLONG_MIN
#define PY_LLONG_MAX LLONG_MAX
#define PY_ULLONG_MAX ULLONG_MAX

type PY_UINT32_T as ulong
type PY_UINT64_T as ulongint
type PY_INT32_T as long
type PY_INT64_T as longint
const PYLONG_BITS_IN_DIGIT = 30
type Py_uintptr_t as uinteger
type Py_intptr_t as integer
type Py_ssize_t as integer
const SIZEOF_PY_HASH_T = SIZEOF_SIZE_T
type Py_hash_t as Py_ssize_t
const SIZEOF_PY_UHASH_T = SIZEOF_SIZE_T
type Py_uhash_t as uinteger
type Py_ssize_clean_t as long

const PY_SIZE_MAX = cuint(-1)
const PY_SSIZE_T_MAX = cast(Py_ssize_t, cuint(-1) shr 1)
const PY_SSIZE_T_MIN = (-PY_SSIZE_T_MAX) - 1
'' TODO: #define Py_LOCAL(type) static type
'' TODO: #define Py_LOCAL_INLINE(type) static inline type
#define Py_MEMCPY memcpy
const S_IFMT = &o170000
const S_IFLNK = &o120000
#define S_ISREG(x) (((x) and S_IFMT) = S_IFREG)
#define S_ISDIR(x) (((x) and S_IFMT) = S_IFDIR)
#define S_ISCHR(x) (((x) and S_IFMT) = S_IFCHR)
#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE_, I, J) ((I) shr (J))
#define Py_FORCE_EXPANSION(X) X
#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) NARROW(VALUE)
'' TODO: #define _Py_SET_EDOM_FOR_NAN(X) ;
#macro Py_SET_ERRNO_ON_MATH_ERROR(X)
    if errno = 0 then
        '' TODO: if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) errno = ERANGE;
        '' TODO: else _Py_SET_EDOM_FOR_NAN(X)
    end if
#endmacro
#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
#macro Py_ADJUST_ERANGE1(X)
    if errno = 0 then
        if ((X) = Py_HUGE_VAL) orelse ((X) = (-Py_HUGE_VAL)) then
            errno = ERANGE
        end if
    elseif (errno = ERANGE) andalso ((X) = 0.0) then
        errno = 0
    end if
#endmacro
#macro Py_ADJUST_ERANGE2(X, Y)
    if ((((X) = Py_HUGE_VAL) orelse ((X) = (-Py_HUGE_VAL))) orelse ((Y) = Py_HUGE_VAL)) orelse ((Y) = (-Py_HUGE_VAL)) then
        if errno = 0 then
            errno = ERANGE
        end if
    elseif errno = ERANGE then
        errno = 0
    end if
#endmacro
const HAVE_PY_SET_53BIT_PRECISION = 1
'' TODO: #define _Py_SET_53BIT_PRECISION_HEADER unsigned short old_387controlword, new_387controlword
#macro _Py_SET_53BIT_PRECISION_START
    scope
        old_387controlword = _Py_get_387controlword()
        new_387controlword = (old_387controlword and (not &h0f00)) or &h0200
        if new_387controlword <> old_387controlword then
            _Py_set_387controlword(new_387controlword)
        end if
    end scope
#endmacro
'' TODO: #define _Py_SET_53BIT_PRECISION_END if (new_387controlword != old_387controlword) _Py_set_387controlword(old_387controlword)
#define PyAPI_FUNC(RTYPE) RTYPE
'' TODO: # define PyAPI_DATA(RTYPE) extern RTYPE
type PyObject as PyObject_
type PyMODINIT_FUNC as PyObject ptr
const LONG_BIT = 8 * SIZEOF_LONG
#define Py_LL(x) x##LL
#define Py_ULL(x) Py_LL(x##U)
#define Py_VA_COPY(x, y) Py_MEMCPY((x), (y), sizeof(va_list))
const PY_BIG_ENDIAN = 0
const PY_LITTLE_ENDIAN = 1
#define Py_PYMACRO_H
#define Py_MIN(x, y) iif((x) > (y), (y), (x))
#define Py_MAX(x, y) iif((x) > (y), (x), (y))
#define Py_ABS(x) iif((x) < 0, -(x), (x))
#define _Py_XSTRINGIFY(x) #x
#define Py_STRINGIFY(x) _Py_XSTRINGIFY(x)
#define Py_CHARMASK(c) cubyte((c) and &hff)
'' TODO: #define Py_BUILD_ASSERT_EXPR(cond) (sizeof(char [1 - 2*!(cond)]) - 1)
#define Py_ARRAY_LENGTH(array) ((sizeof(array) / sizeof((array)[0])) + Py_BUILD_ASSERT_EXPR(-(__builtin_types_compatible_p(typeof(array), typeof(@(array)[0])) = 0)))
'' TODO: #define PyDoc_VAR(name) static char name[]
#define PyDoc_STRVAR(name, str) scope : PyDoc_VAR(name) = PyDoc_STR(str) : end scope
#define PyDoc_STR(str) str
#define _Py_SIZE_ROUND_DOWN(n, a) (cuint(n) and (not cuint((a) - 1)))
#define _Py_SIZE_ROUND_UP(n, a) ((cuint(n) + cuint((a) - 1)) and (not cuint((a) - 1)))
#define _Py_ALIGN_DOWN(p, a) cptr(any ptr, cast(Py_uintptr_t, (p)) and (not cast(Py_uintptr_t, (a) - 1)))
#define _Py_ALIGN_UP(p, a) cptr(any ptr, (cast(Py_uintptr_t, (p)) + cast(Py_uintptr_t, (a) - 1)) and (not cast(Py_uintptr_t, (a) - 1)))
#define _Py_IS_ALIGNED(p, a) ((cast(Py_uintptr_t, (p)) and cast(Py_uintptr_t, (a) - 1)) = 0)
'' TODO: #define Py_UNUSED(name) _unused_ ## name __attribute__((unused))
#define Py_ATOMIC_H
#define Py_PYMATH_H
'' TODO: #define Py_MATH_PIl 3.1415926535897932384626433832795029L
const Py_MATH_PI = 3.14159265358979323846
'' TODO: #define Py_MATH_El 2.7182818284590452353602874713526625L
const Py_MATH_E = 2.7182818284590452354
#define Py_IS_NAN(X) isnan(X)
#define Py_IS_INFINITY(X) isinf(X)
#define Py_IS_FINITE(X) isfinite(X)
#define Py_HUGE_VAL HUGE_VAL
#define Py_NAN (Py_HUGE_VAL * 0.)
#define Py_OVERFLOWED(X) (((X) <> 0.0) andalso (((errno = ERANGE) orelse ((X) = Py_HUGE_VAL)) orelse ((X) = (-Py_HUGE_VAL))))
#define Py_PYMEM_H

declare function PyMem_Malloc(byval size as uinteger) as any ptr
declare function PyMem_Calloc(byval nelem as uinteger, byval elsize as uinteger) as any ptr
declare function PyMem_Realloc(byval ptr as any ptr, byval new_size as uinteger) as any ptr
declare sub PyMem_Free(byval ptr as any ptr)
#define PyMem_New(type, n) iif(cuint(n) > (PY_SSIZE_T_MAX / sizeof(type)), NULL, cptr(type ptr, PyMem_Malloc((n) * sizeof(type))))
#define PyMem_Resize(p, type, n) scope : (p) = iif(cuint(n) > (PY_SSIZE_T_MAX / sizeof(type)), NULL, cptr(type ptr, PyMem_Realloc((p), (n) * sizeof(type)))) : end scope
declare sub PyMem_Del alias "PyMem_Free"(byval ptr as any ptr)

#define Py_OBJECT_H
#define _PyObject_HEAD_EXTRA
#define _PyObject_EXTRA_INIT

'' TODO: #define PyObject_HEAD PyObject ob_base;
'' TODO: #define PyObject_HEAD_INIT(type) { _PyObject_EXTRA_INIT 1, type },
'' TODO: #define PyVarObject_HEAD_INIT(type, size) { PyObject_HEAD_INIT(type) size },
'' TODO: #define PyObject_VAR_HEAD PyVarObject ob_base;
const Py_INVALID_SIZE = cast(Py_ssize_t, -1)

type _object
    ob_refcnt as Py_ssize_t
    ob_type as PyObject ptr
end type

type PyObject_ as _object

type PyVarObject
    ob_base as PyObject
    ob_size as Py_ssize_t
end type

#define Py_REFCNT(ob) cptr(PyObject ptr, (ob))->ob_refcnt
#define Py_TYPE(ob) cptr(PyObject ptr, (ob))->ob_type
#define Py_SIZE(ob) cptr(PyVarObject ptr, (ob))->ob_size

type _Py_Identifier
    next as _Py_Identifier ptr
    string as const zstring ptr
    object as PyObject ptr
end type

#define _Py_static_string_init(value) (0, value, 0)
'' TODO: #define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value)
#define _Py_IDENTIFIER_(varname) _Py_static_string(PyId_##varname, #varname)
type unaryfunc as function(byval as PyObject ptr) as PyObject ptr
type binaryfunc as function(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type ternaryfunc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type inquiry as function(byval as PyObject ptr) as long
type lenfunc as function(byval as PyObject ptr) as Py_ssize_t
type ssizeargfunc as function(byval as PyObject ptr, byval as Py_ssize_t) as PyObject ptr
type ssizessizeargfunc as function(byval as PyObject ptr, byval as Py_ssize_t, byval as Py_ssize_t) as PyObject ptr
type ssizeobjargproc as function(byval as PyObject ptr, byval as Py_ssize_t, byval as PyObject ptr) as long
type ssizessizeobjargproc as function(byval as PyObject ptr, byval as Py_ssize_t, byval as Py_ssize_t, byval as PyObject ptr) as long
type objobjargproc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
type objobjproc as function(byval as PyObject ptr, byval as PyObject ptr) as long
type visitproc as function(byval as PyObject ptr, byval as any ptr) as long
type traverseproc as function(byval as PyObject ptr, byval as visitproc, byval as any ptr) as long
type freefunc as sub(byval as any ptr)
type destructor_ as sub(byval as PyObject ptr)
type getattrfunc as function(byval as PyObject ptr, byval as zstring ptr) as PyObject ptr
type getattrofunc as function(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type setattrfunc as function(byval as PyObject ptr, byval as zstring ptr, byval as PyObject ptr) as long
type setattrofunc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
type reprfunc as function(byval as PyObject ptr) as PyObject ptr
type hashfunc as function(byval as PyObject ptr) as Py_hash_t
type richcmpfunc as function(byval as PyObject ptr, byval as PyObject ptr, byval as long) as PyObject ptr
type getiterfunc as function(byval as PyObject ptr) as PyObject ptr
type iternextfunc as function(byval as PyObject ptr) as PyObject ptr
type descrgetfunc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type descrsetfunc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
type initproc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
type newfunc as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type allocfunc as function(byval as PyObject ptr, byval as Py_ssize_t) as PyObject ptr
type PyTypeObject as PyObject

type PyType_Slot
    slot as long
    pfunc as any ptr
end type

type PyType_Spec
    name as const zstring ptr
    basicsize as long
    itemsize as long
    flags as ulong
    slots as PyType_Slot ptr
end type

declare function PyType_FromSpec(byval as PyType_Spec ptr) as PyObject ptr
declare function PyType_IsSubtype(byval as PyTypeObject ptr, byval as PyTypeObject ptr) as long
#define PyObject_TypeCheck(ob, tp) ((Py_TYPE(ob) = (tp)) orelse PyType_IsSubtype(Py_TYPE(ob), (tp)))
extern PyType_Type as PyTypeObject
extern PyBaseObject_Type as PyTypeObject
extern PySuper_Type as PyTypeObject
declare function PyType_GetFlags(byval as PyTypeObject ptr) as culong
#define PyType_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
#define PyType_CheckExact(op) (Py_TYPE(op) = (@PyType_Type))

declare function PyType_Ready(byval as PyTypeObject ptr) as long
declare function PyType_GenericAlloc(byval as PyTypeObject ptr, byval as Py_ssize_t) as PyObject ptr
declare function PyType_GenericNew(byval as PyTypeObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyType_ClearCache() as ulong
declare sub PyType_Modified(byval as PyTypeObject ptr)
declare function PyObject_Repr(byval as PyObject ptr) as PyObject ptr
declare function PyObject_Str(byval as PyObject ptr) as PyObject ptr
declare function PyObject_ASCII(byval as PyObject ptr) as PyObject ptr
declare function PyObject_Bytes(byval as PyObject ptr) as PyObject ptr
declare function PyObject_RichCompare(byval as PyObject ptr, byval as PyObject ptr, byval as long) as PyObject ptr
declare function PyObject_RichCompareBool(byval as PyObject ptr, byval as PyObject ptr, byval as long) as long
declare function PyObject_GetAttrString(byval as PyObject ptr, byval as const zstring ptr) as PyObject ptr
declare function PyObject_SetAttrString(byval as PyObject ptr, byval as const zstring ptr, byval as PyObject ptr) as long
declare function PyObject_HasAttrString(byval as PyObject ptr, byval as const zstring ptr) as long
declare function PyObject_GetAttr(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyObject_SetAttr(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
declare function PyObject_HasAttr(byval as PyObject ptr, byval as PyObject ptr) as long
declare function _PyObject_IsAbstract(byval as PyObject ptr) as long
declare function _PyObject_GetAttrId(byval as PyObject ptr, byval as _Py_Identifier ptr) as PyObject ptr
declare function _PyObject_SetAttrId(byval as PyObject ptr, byval as _Py_Identifier ptr, byval as PyObject ptr) as long
declare function _PyObject_HasAttrId(byval as PyObject ptr, byval as _Py_Identifier ptr) as long
declare function PyObject_SelfIter(byval as PyObject ptr) as PyObject ptr
declare function PyObject_GenericGetAttr(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyObject_GenericSetAttr(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
declare function PyObject_GenericSetDict(byval as PyObject ptr, byval as PyObject ptr, byval as any ptr) as long
declare function PyObject_Hash(byval as PyObject ptr) as Py_hash_t
declare function PyObject_HashNotImplemented(byval as PyObject ptr) as Py_hash_t
declare function PyObject_IsTrue(byval as PyObject ptr) as long
declare function PyObject_Not(byval as PyObject ptr) as long
declare function PyCallable_Check(byval as PyObject ptr) as long
declare sub PyObject_ClearWeakRefs(byval as PyObject ptr)
declare function _PyObject_GenericGetAttrWithDict(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function _PyObject_GenericSetAttrWithDict(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as long
declare function PyObject_Dir(byval as PyObject ptr) as PyObject ptr
declare function Py_ReprEnter(byval as PyObject ptr) as long
declare sub Py_ReprLeave(byval as PyObject ptr)

const Py_PRINT_RAW = 1
const Py_TPFLAGS_HEAPTYPE = cast(culong, 1) shl 9
const Py_TPFLAGS_BASETYPE = cast(culong, 1) shl 10
const Py_TPFLAGS_READY = cast(culong, 1) shl 12
const Py_TPFLAGS_READYING = cast(culong, 1) shl 13
const Py_TPFLAGS_HAVE_GC = cast(culong, 1) shl 14
const Py_TPFLAGS_HAVE_STACKLESS_EXTENSION = 0
const Py_TPFLAGS_HAVE_VERSION_TAG = cast(culong, 1) shl 18
const Py_TPFLAGS_VALID_VERSION_TAG = cast(culong, 1) shl 19
const Py_TPFLAGS_IS_ABSTRACT = cast(culong, 1) shl 20
const Py_TPFLAGS_LONG_SUBCLASS = cast(culong, 1) shl 24
const Py_TPFLAGS_LIST_SUBCLASS = cast(culong, 1) shl 25
const Py_TPFLAGS_TUPLE_SUBCLASS = cast(culong, 1) shl 26
const Py_TPFLAGS_BYTES_SUBCLASS = cast(culong, 1) shl 27
const Py_TPFLAGS_UNICODE_SUBCLASS = cast(culong, 1) shl 28
const Py_TPFLAGS_DICT_SUBCLASS = cast(culong, 1) shl 29
const Py_TPFLAGS_BASE_EXC_SUBCLASS = cast(culong, 1) shl 30
const Py_TPFLAGS_TYPE_SUBCLASS = cast(culong, 1) shl 31
const Py_TPFLAGS_DEFAULT = (Py_TPFLAGS_HAVE_STACKLESS_EXTENSION or Py_TPFLAGS_HAVE_VERSION_TAG) or 0
const Py_TPFLAGS_HAVE_FINALIZE = cast(culong, 1) shl 0
#define PyType_HasFeature(t, f) ((PyType_GetFlags(t) and (f)) <> 0)
#define PyType_FastSubclass(t, f) PyType_HasFeature(t, f)
#define _Py_INC_REFTOTAL
#define _Py_DEC_REFTOTAL
#define _Py_REF_DEBUG_COMMA
'' TODO: #define _Py_CHECK_REFCNT(OP) ;
#define _PY_DEBUG_PRINT_TOTAL_REFS()
#define _Py_INC_TPALLOCS(OP)
#define _Py_INC_TPFREES(OP)
#define _Py_DEC_TPFREES(OP)
#define _Py_COUNT_ALLOCS_COMMA
'' TODO: #define _Py_NewReference(op) ( _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA Py_REFCNT(op) = 1)
#define _Py_ForgetReference(op) _Py_INC_TPFREES(op)
declare sub _Py_Dealloc(byval as PyObject ptr)
'' TODO: #define Py_INCREF(op) ( _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA ((PyObject *)(op))->ob_refcnt++)
#macro Py_CLEAR(op)
    scope
        dim _py_tmp as PyObject ptr = cptr(PyObject ptr, (op))
        if _py_tmp <> NULL then
            (op) = NULL
            Py_DECREF(_py_tmp)
        end if
    end scope
#endmacro
#macro Py_XINCREF(op)
    scope
        dim _py_xincref_tmp as PyObject ptr = cptr(PyObject ptr, (op))
        if _py_xincref_tmp <> NULL then
            Py_INCREF(_py_xincref_tmp)
        end if
    end scope
#endmacro
#macro Py_XDECREF(op)
    scope
        dim _py_xdecref_tmp as PyObject ptr = cptr(PyObject ptr, (op))
        if _py_xdecref_tmp <> NULL then
            Py_DECREF(_py_xdecref_tmp)
        end if
    end scope
#endmacro
declare sub Py_IncRef(byval as PyObject ptr)
declare sub Py_DecRef(byval as PyObject ptr)

extern _PyNone_Type as PyTypeObject
extern _PyNotImplemented_Type as PyTypeObject
extern _Py_NoneStruct as PyObject
#define Py_None (@_Py_NoneStruct)
'' TODO: #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
extern _Py_NotImplementedStruct as PyObject
#define Py_NotImplemented (@_Py_NotImplementedStruct)
'' TODO: #define Py_RETURN_NOTIMPLEMENTED return Py_INCREF(Py_NotImplemented), Py_NotImplemented

const Py_LT = 0
const Py_LE = 1
const Py_EQ = 2
const Py_NE = 3
const Py_GT = 4
const Py_GE = 5
extern _Py_SwappedOp(0 to 1 - 1) as long
declare sub _PyTrash_deposit_object(byval as PyObject ptr)
declare sub _PyTrash_destroy_chain()
extern _PyTrash_delete_nesting as long
extern _PyTrash_delete_later as PyObject ptr
declare sub _PyTrash_thread_deposit_object(byval as PyObject ptr)
declare sub _PyTrash_thread_destroy_chain()
const PyTrash_UNWIND_LEVEL = 50
'' TODO: #define Py_TRASHCAN_SAFE_BEGIN(op) do { PyThreadState *_tstate = PyThreadState_GET(); if (_tstate->trash_delete_nesting < PyTrash_UNWIND_LEVEL) { ++_tstate->trash_delete_nesting;
'' TODO: #define Py_TRASHCAN_SAFE_END(op) --_tstate->trash_delete_nesting; if (_tstate->trash_delete_later && _tstate->trash_delete_nesting <= 0) _PyTrash_thread_destroy_chain(); } else _PyTrash_thread_deposit_object((PyObject*)op); } while (0);
#define Py_OBJIMPL_H

declare function PyObject_Malloc(byval size as uinteger) as any ptr
declare function PyObject_Calloc(byval nelem as uinteger, byval elsize as uinteger) as any ptr
declare function PyObject_Realloc(byval ptr as any ptr, byval new_size as uinteger) as any ptr
declare sub PyObject_Free(byval ptr as any ptr)
declare function _Py_GetAllocatedBlocks() as Py_ssize_t
declare sub PyObject_Del alias "PyObject_Free"(byval ptr as any ptr)
declare function PyObject_Init(byval as PyObject ptr, byval as PyTypeObject ptr) as PyObject ptr
declare function PyObject_InitVar(byval as PyVarObject ptr, byval as PyTypeObject ptr, byval as Py_ssize_t) as PyVarObject ptr
declare function _PyObject_New(byval as PyTypeObject ptr) as PyObject ptr
declare function _PyObject_NewVar(byval as PyTypeObject ptr, byval as Py_ssize_t) as PyVarObject ptr

#define PyObject_New(type, typeobj) cptr(type ptr, _PyObject_New(typeobj))
#define PyObject_NewVar(type, typeobj, n) cptr(type ptr, _PyObject_NewVar((typeobj), (n)))
#macro PyObject_INIT_VAR(op, typeobj, size)
    scope
        Py_SIZE(op) = (size)
        PyObject_INIT((op), (typeobj))
    end scope
#endmacro
#define _PyObject_SIZE(typeobj) (typeobj)->tp_basicsize
#define _PyObject_VAR_SIZE(typeobj, nitems) _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + ((nitems) * (typeobj)->tp_itemsize), SIZEOF_VOID_P)
#define PyObject_NEW_VAR(type, typeobj, n) cptr(type ptr, PyObject_InitVar(cptr(PyVarObject ptr, PyObject_MALLOC(_PyObject_VAR_SIZE((typeobj), (n)))), (typeobj), (n)))
declare function PyGC_Collect() as Py_ssize_t
#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
#define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) andalso ((Py_TYPE(o)->tp_is_gc = NULL) orelse Py_TYPE(o)->tp_is_gc(o)))
declare function _PyObject_GC_Resize(byval as PyVarObject ptr, byval as Py_ssize_t) as PyVarObject ptr
#define PyObject_GC_Resize(type, op, n) cptr(type ptr, _PyObject_GC_Resize(cptr(PyVarObject ptr, (op)), (n)))

declare function _PyObject_GC_Malloc(byval size as uinteger) as PyObject ptr
declare function _PyObject_GC_Calloc(byval size as uinteger) as PyObject ptr
declare function _PyObject_GC_New(byval as PyTypeObject ptr) as PyObject ptr
declare function _PyObject_GC_NewVar(byval as PyTypeObject ptr, byval as Py_ssize_t) as PyVarObject ptr
declare sub PyObject_GC_Track(byval as any ptr)
declare sub PyObject_GC_UnTrack(byval as any ptr)
declare sub PyObject_GC_Del(byval as any ptr)

#define PyObject_GC_New(type, typeobj) cptr(type ptr, _PyObject_GC_New(typeobj))
#define PyObject_GC_NewVar(type, typeobj, n) cptr(type ptr, _PyObject_GC_NewVar((typeobj), (n)))
#macro Py_VISIT(op)
    if op then
        dim vret as long = visit(cptr(PyObject ptr, (op)), arg)
        if vret then
            return vret
        end if
    end if
#endmacro
#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0)
#define PyObject_GET_WEAKREFS_LISTPTR(o) cptr(PyObject ptr ptr, cptr(zstring ptr, (o)) + Py_TYPE(o)->tp_weaklistoffset)
#undef Py_bf_getbuffer
#undef Py_bf_releasebuffer
const Py_mp_ass_subscript = 3
const Py_mp_length = 4
const Py_mp_subscript = 5
const Py_nb_absolute = 6
const Py_nb_add = 7
const Py_nb_and = 8
const Py_nb_bool = 9
const Py_nb_divmod = 10
const Py_nb_float = 11
const Py_nb_floor_divide = 12
const Py_nb_index = 13
const Py_nb_inplace_add = 14
const Py_nb_inplace_and = 15
const Py_nb_inplace_floor_divide = 16
const Py_nb_inplace_lshift = 17
const Py_nb_inplace_multiply = 18
const Py_nb_inplace_or = 19
const Py_nb_inplace_power = 20
const Py_nb_inplace_remainder = 21
const Py_nb_inplace_rshift = 22
const Py_nb_inplace_subtract = 23
const Py_nb_inplace_true_divide = 24
const Py_nb_inplace_xor = 25
const Py_nb_int = 26
const Py_nb_invert = 27
const Py_nb_lshift = 28
const Py_nb_multiply = 29
const Py_nb_negative = 30
const Py_nb_or = 31
const Py_nb_positive = 32
const Py_nb_power = 33
const Py_nb_remainder = 34
const Py_nb_rshift = 35
const Py_nb_subtract = 36
const Py_nb_true_divide = 37
const Py_nb_xor = 38
const Py_sq_ass_item = 39
const Py_sq_concat = 40
const Py_sq_contains = 41
const Py_sq_inplace_concat = 42
const Py_sq_inplace_repeat = 43
const Py_sq_item = 44
const Py_sq_length = 45
const Py_sq_repeat = 46
const Py_tp_alloc = 47
const Py_tp_base = 48
const Py_tp_bases = 49
const Py_tp_call = 50
const Py_tp_clear = 51
const Py_tp_dealloc = 52
const Py_tp_del = 53
const Py_tp_descr_get = 54
const Py_tp_descr_set = 55
const Py_tp_doc = 56
const Py_tp_getattr = 57
const Py_tp_getattro = 58
const Py_tp_hash = 59
const Py_tp_init = 60
const Py_tp_is_gc = 61
const Py_tp_iter = 62
const Py_tp_iternext = 63
const Py_tp_methods = 64
const Py_tp_new = 65
const Py_tp_repr = 66
const Py_tp_richcompare = 67
const Py_tp_setattr = 68
const Py_tp_setattro = 69
const Py_tp_str = 70
const Py_tp_traverse = 71
const Py_tp_members = 72
const Py_tp_getset = 73
const Py_tp_free = 74
const Py_nb_matrix_multiply = 75
const Py_nb_inplace_matrix_multiply = 76
const Py_am_await = 77
const Py_am_aiter = 78
const Py_am_anext = 79
#define Py_HASH_H
const _PyHASH_MULTIPLIER = cast(culong, 1000003)
const _PyHASH_BITS = 61
const _PyHASH_MODULUS = (cuint(1) shl _PyHASH_BITS) - 1
const _PyHASH_INF = 314159
const _PyHASH_NAN = 0
const _PyHASH_IMAG = _PyHASH_MULTIPLIER
const Py_HASH_CUTOFF = 0
const Py_HASH_EXTERNAL = 0
const Py_HASH_SIPHASH24 = 1
const Py_HASH_FNV = 2
const Py_HASH_ALGORITHM = Py_HASH_SIPHASH24
#define Py_BYTEARRAYOBJECT_H
extern PyByteArray_Type as PyTypeObject
extern PyByteArrayIter_Type as PyTypeObject
#define PyByteArray_Check(self) PyObject_TypeCheck(self, @PyByteArray_Type)
#define PyByteArray_CheckExact(self) (Py_TYPE(self) = (@PyByteArray_Type))

declare function PyByteArray_FromObject(byval as PyObject ptr) as PyObject ptr
declare function PyByteArray_Concat(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyByteArray_FromStringAndSize(byval as const zstring ptr, byval as Py_ssize_t) as PyObject ptr
declare function PyByteArray_Size(byval as PyObject ptr) as Py_ssize_t
declare function PyByteArray_AsString(byval as PyObject ptr) as zstring ptr
declare function PyByteArray_Resize(byval as PyObject ptr, byval as Py_ssize_t) as long
#define Py_BYTESOBJECT_H
extern PyBytes_Type as PyTypeObject
extern PyBytesIter_Type as PyTypeObject
#define PyBytes_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS)
#define PyBytes_CheckExact(op) (Py_TYPE(op) = (@PyBytes_Type))
declare function PyBytes_FromStringAndSize(byval as const zstring ptr, byval as Py_ssize_t) as PyObject ptr
declare function PyBytes_FromString(byval as const zstring ptr) as PyObject ptr
declare function PyBytes_FromObject(byval as PyObject ptr) as PyObject ptr
declare function PyBytes_FromFormatV(byval as const zstring ptr, byval as va_list) as PyObject ptr
declare function PyBytes_FromFormat(byval as const zstring ptr, ...) as PyObject ptr
declare function PyBytes_Size(byval as PyObject ptr) as Py_ssize_t
declare function PyBytes_AsString(byval as PyObject ptr) as zstring ptr
declare function PyBytes_Repr(byval as PyObject ptr, byval as long) as PyObject ptr
declare sub PyBytes_Concat(byval as PyObject ptr ptr, byval as PyObject ptr)
declare sub PyBytes_ConcatAndDel(byval as PyObject ptr ptr, byval as PyObject ptr)
declare function PyBytes_DecodeEscape(byval as const zstring ptr, byval as Py_ssize_t, byval as const zstring ptr, byval as Py_ssize_t, byval as const zstring ptr) as PyObject ptr
declare function PyBytes_AsStringAndSize(byval obj as PyObject ptr, byval s as zstring ptr ptr, byval len as Py_ssize_t ptr) as long

const F_LJUST = 1 shl 0
const F_SIGN = 1 shl 1
const F_BLANK = 1 shl 2
const F_ALT = 1 shl 3
const F_ZERO = 1 shl 4
#define Py_UNICODEOBJECT_H
#define Py_USING_UNICODE
const Py_UNICODE_SIZE = SIZEOF_WCHAR_T
#define Py_UNICODE_WIDE

type Py_UCS4 as ulong
type Py_UCS2 as ushort
type Py_UCS1 as ubyte
extern PyUnicode_Type as PyTypeObject
extern PyUnicodeIter_Type as PyTypeObject

#define PyUnicode_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)
#define PyUnicode_CheckExact(op) (Py_TYPE(op) = (@PyUnicode_Type))
const Py_UNICODE_REPLACEMENT_CHARACTER = cast(Py_UCS4, &hFFFD)

declare function PyUnicode_FromStringAndSize(byval u as const zstring ptr, byval size as Py_ssize_t) as PyObject ptr
declare function PyUnicode_FromString(byval u as const zstring ptr) as PyObject ptr
declare function PyUnicode_Substring(byval str as PyObject ptr, byval start as Py_ssize_t, byval end as Py_ssize_t) as PyObject ptr
declare function PyUnicode_AsUCS4(byval unicode as PyObject ptr, byval buffer as Py_UCS4 ptr, byval buflen as Py_ssize_t, byval copy_null as long) as Py_UCS4 ptr
declare function PyUnicode_AsUCS4Copy(byval unicode as PyObject ptr) as Py_UCS4 ptr
declare function PyUnicode_GetLength(byval unicode as PyObject ptr) as Py_ssize_t
declare function PyUnicode_GetSize(byval unicode as PyObject ptr) as Py_ssize_t
declare function PyUnicode_ReadChar(byval unicode as PyObject ptr, byval index as Py_ssize_t) as Py_UCS4
declare function PyUnicode_WriteChar(byval unicode as PyObject ptr, byval index as Py_ssize_t, byval character as Py_UCS4) as long
declare function PyUnicode_Resize(byval unicode as PyObject ptr ptr, byval length as Py_ssize_t) as long
declare function PyUnicode_FromEncodedObject(byval obj as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_FromObject(byval obj as PyObject ptr) as PyObject ptr
declare function PyUnicode_FromFormatV(byval format as const zstring ptr, byval vargs as va_list) as PyObject ptr
declare function PyUnicode_FromFormat(byval format as const zstring ptr, ...) as PyObject ptr
declare sub PyUnicode_InternInPlace(byval as PyObject ptr ptr)
declare sub PyUnicode_InternImmortal(byval as PyObject ptr ptr)
declare function PyUnicode_InternFromString(byval u as const zstring ptr) as PyObject ptr
#define PyUnicode_CHECK_INTERNED(op) cptr(PyASCIIObject ptr, (op))->state.interned
declare function PyUnicode_FromWideChar(byval w as const wstring ptr, byval size as Py_ssize_t) as PyObject ptr
declare function PyUnicode_AsWideChar(byval unicode as PyObject ptr, byval w as wstring ptr, byval size as Py_ssize_t) as Py_ssize_t
declare function PyUnicode_AsWideCharString(byval unicode as PyObject ptr, byval size as Py_ssize_t ptr) as wstring ptr
declare function PyUnicode_FromOrdinal(byval ordinal as long) as PyObject ptr
declare function PyUnicode_ClearFreeList() as long
declare function PyUnicode_GetDefaultEncoding() as const zstring ptr
declare function PyUnicode_Decode(byval s as const zstring ptr, byval size as Py_ssize_t, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsDecodedObject(byval unicode as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsDecodedUnicode(byval unicode as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsEncodedObject(byval unicode as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsEncodedString(byval unicode as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsEncodedUnicode(byval unicode as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_BuildEncodingMap(byval string as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF7(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF7Stateful(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr, byval consumed as Py_ssize_t ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF8(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF8Stateful(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr, byval consumed as Py_ssize_t ptr) as PyObject ptr
declare function PyUnicode_AsUTF8String(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF32(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr, byval byteorder as long ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF32Stateful(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr, byval byteorder as long ptr, byval consumed as Py_ssize_t ptr) as PyObject ptr
declare function PyUnicode_AsUTF32String(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF16(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr, byval byteorder as long ptr) as PyObject ptr
declare function PyUnicode_DecodeUTF16Stateful(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr, byval byteorder as long ptr, byval consumed as Py_ssize_t ptr) as PyObject ptr
declare function PyUnicode_AsUTF16String(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeUnicodeEscape(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsUnicodeEscapeString(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeRawUnicodeEscape(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsRawUnicodeEscapeString(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeLatin1(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsLatin1String(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeASCII(byval string as const zstring ptr, byval length as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsASCIIString(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeCharmap(byval string as const zstring ptr, byval length as Py_ssize_t, byval mapping as PyObject ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_AsCharmapString(byval unicode as PyObject ptr, byval mapping as PyObject ptr) as PyObject ptr
declare function PyUnicode_DecodeLocaleAndSize(byval str as const zstring ptr, byval len as Py_ssize_t, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_DecodeLocale(byval str as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_EncodeLocale(byval unicode as PyObject ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_FSConverter(byval as PyObject ptr, byval as any ptr) as long
declare function PyUnicode_FSDecoder(byval as PyObject ptr, byval as any ptr) as long
declare function PyUnicode_DecodeFSDefault(byval s as const zstring ptr) as PyObject ptr
declare function PyUnicode_DecodeFSDefaultAndSize(byval s as const zstring ptr, byval size as Py_ssize_t) as PyObject ptr
declare function PyUnicode_EncodeFSDefault(byval unicode as PyObject ptr) as PyObject ptr
declare function PyUnicode_Concat(byval left as PyObject ptr, byval right as PyObject ptr) as PyObject ptr
declare sub PyUnicode_Append(byval pleft as PyObject ptr ptr, byval right as PyObject ptr)
declare sub PyUnicode_AppendAndDel(byval pleft as PyObject ptr ptr, byval right as PyObject ptr)
declare function PyUnicode_Split(byval s as PyObject ptr, byval sep as PyObject ptr, byval maxsplit as Py_ssize_t) as PyObject ptr
declare function PyUnicode_Splitlines(byval s as PyObject ptr, byval keepends as long) as PyObject ptr
declare function PyUnicode_Partition(byval s as PyObject ptr, byval sep as PyObject ptr) as PyObject ptr
declare function PyUnicode_RPartition(byval s as PyObject ptr, byval sep as PyObject ptr) as PyObject ptr
declare function PyUnicode_RSplit(byval s as PyObject ptr, byval sep as PyObject ptr, byval maxsplit as Py_ssize_t) as PyObject ptr
declare function PyUnicode_Translate(byval str as PyObject ptr, byval table as PyObject ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyUnicode_Join(byval separator as PyObject ptr, byval seq as PyObject ptr) as PyObject ptr
declare function PyUnicode_Tailmatch(byval str as PyObject ptr, byval substr as PyObject ptr, byval start as Py_ssize_t, byval end as Py_ssize_t, byval direction as long) as Py_ssize_t
declare function PyUnicode_Find(byval str as PyObject ptr, byval substr as PyObject ptr, byval start as Py_ssize_t, byval end as Py_ssize_t, byval direction as long) as Py_ssize_t
declare function PyUnicode_FindChar(byval str as PyObject ptr, byval ch as Py_UCS4, byval start as Py_ssize_t, byval end as Py_ssize_t, byval direction as long) as Py_ssize_t
declare function PyUnicode_Count(byval str as PyObject ptr, byval substr as PyObject ptr, byval start as Py_ssize_t, byval end as Py_ssize_t) as Py_ssize_t
declare function PyUnicode_Replace(byval str as PyObject ptr, byval substr as PyObject ptr, byval replstr as PyObject ptr, byval maxcount as Py_ssize_t) as PyObject ptr
declare function PyUnicode_Compare(byval left as PyObject ptr, byval right as PyObject ptr) as long
declare function PyUnicode_CompareWithASCIIString(byval left as PyObject ptr, byval right as const zstring ptr) as long
declare function PyUnicode_RichCompare(byval left as PyObject ptr, byval right as PyObject ptr, byval op as long) as PyObject ptr
declare function PyUnicode_Format(byval format as PyObject ptr, byval args as PyObject ptr) as PyObject ptr
declare function PyUnicode_Contains(byval container as PyObject ptr, byval element as PyObject ptr) as long
declare function PyUnicode_IsIdentifier(byval s as PyObject ptr) as long
declare function _PyUnicode_FromId(byval as _Py_Identifier ptr) as PyObject ptr
declare sub _PyUnicode_ClearStaticStrings()
#define Py_LONGOBJECT_H
type PyLongObject as PyObject
extern PyLong_Type as PyTypeObject
#define PyLong_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)
#define PyLong_CheckExact(op) (Py_TYPE(op) = (@PyLong_Type))
declare function PyLong_FromLong(byval as clong) as PyObject ptr
declare function PyLong_FromUnsignedLong(byval as culong) as PyObject ptr
declare function PyLong_FromSize_t(byval as uinteger) as PyObject ptr
declare function PyLong_FromSsize_t(byval as Py_ssize_t) as PyObject ptr
declare function PyLong_FromDouble(byval as double) as PyObject ptr
declare function PyLong_AsLong(byval as PyObject ptr) as clong
declare function PyLong_AsLongAndOverflow(byval as PyObject ptr, byval as long ptr) as clong
declare function PyLong_AsSsize_t(byval as PyObject ptr) as Py_ssize_t
declare function PyLong_AsSize_t(byval as PyObject ptr) as uinteger
declare function PyLong_AsUnsignedLong(byval as PyObject ptr) as culong
declare function PyLong_AsUnsignedLongMask(byval as PyObject ptr) as culong
declare function PyLong_GetInfo() as PyObject ptr
#define PyLong_AS_LONG(op) PyLong_AsLong(op)
#define _Py_PARSE_PID "i"
declare function PyLong_FromPid alias "PyLong_FromLong"(byval as clong) as PyObject ptr
declare function PyLong_AsPid alias "PyLong_AsLong"(byval as PyObject ptr) as clong
#define _Py_PARSE_INTPTR "l"
#define _Py_PARSE_UINTPTR "k"
declare function PyLong_AsDouble(byval as PyObject ptr) as double
declare function PyLong_FromVoidPtr(byval as any ptr) as PyObject ptr
declare function PyLong_AsVoidPtr(byval as PyObject ptr) as any ptr
declare function PyLong_FromLongLong(byval as longint) as PyObject ptr
declare function PyLong_FromUnsignedLongLong(byval as ulongint) as PyObject ptr
declare function PyLong_AsLongLong(byval as PyObject ptr) as longint
declare function PyLong_AsUnsignedLongLong(byval as PyObject ptr) as ulongint
declare function PyLong_AsUnsignedLongLongMask(byval as PyObject ptr) as ulongint
declare function PyLong_AsLongLongAndOverflow(byval as PyObject ptr, byval as long ptr) as longint
declare function PyLong_FromString(byval as const zstring ptr, byval as zstring ptr ptr, byval as long) as PyObject ptr
declare function PyOS_strtoul(byval as const zstring ptr, byval as zstring ptr ptr, byval as long) as culong
declare function PyOS_strtol(byval as const zstring ptr, byval as zstring ptr ptr, byval as long) as clong
declare function _PyLong_GCD(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
#define Py_BOOLOBJECT_H
extern PyBool_Type as PyTypeObject
#define PyBool_Check(x) (Py_TYPE(x) = (@PyBool_Type))
extern _Py_FalseStruct as PyObject
extern _Py_TrueStruct as PyObject
#define Py_False cptr(PyObject ptr, @_Py_FalseStruct)
#define Py_True cptr(PyObject ptr, @_Py_TrueStruct)
'' TODO: #define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True
'' TODO: #define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False
declare function PyBool_FromLong(byval as clong) as PyObject ptr
#define Py_FLOATOBJECT_H
extern PyFloat_Type as PyTypeObject
#define PyFloat_Check(op) PyObject_TypeCheck(op, @PyFloat_Type)
#define PyFloat_CheckExact(op) (Py_TYPE(op) = (@PyFloat_Type))
'' TODO: #define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)
#macro Py_RETURN_INF(sign)
    if copysign(1., sign) = 1. then
        return PyFloat_FromDouble(Py_HUGE_VAL)
    else
        return PyFloat_FromDouble(-Py_HUGE_VAL)
    end if
#endmacro
declare function PyFloat_GetMax() as double
declare function PyFloat_GetMin() as double
declare function PyFloat_GetInfo() as PyObject ptr
declare function PyFloat_FromString(byval as PyObject ptr) as PyObject ptr
declare function PyFloat_FromDouble(byval as double) as PyObject ptr
declare function PyFloat_AsDouble(byval as PyObject ptr) as double
#define Py_COMPLEXOBJECT_H
extern PyComplex_Type as PyTypeObject
#define PyComplex_Check(op) PyObject_TypeCheck(op, @PyComplex_Type)
#define PyComplex_CheckExact(op) (Py_TYPE(op) = (@PyComplex_Type))
declare function PyComplex_FromDoubles(byval real as double, byval imag as double) as PyObject ptr
declare function PyComplex_RealAsDouble(byval op as PyObject ptr) as double
declare function PyComplex_ImagAsDouble(byval op as PyObject ptr) as double
#define Py_RANGEOBJECT_H

extern PyRange_Type as PyTypeObject
extern PyRangeIter_Type as PyTypeObject
extern PyLongRangeIter_Type as PyTypeObject
#define PyRange_Check(op) (Py_TYPE(op) = (@PyRange_Type))
#define Py_MEMORYOBJECT_H
extern PyMemoryView_Type as PyTypeObject
#define PyMemoryView_Check(op) (Py_TYPE(op) = (@PyMemoryView_Type))

declare function PyMemoryView_FromObject(byval base as PyObject ptr) as PyObject ptr
declare function PyMemoryView_FromMemory(byval mem as zstring ptr, byval size as Py_ssize_t, byval flags as long) as PyObject ptr
declare function PyMemoryView_GetContiguous(byval base as PyObject ptr, byval buffertype as long, byval order as byte) as PyObject ptr
#define Py_TUPLEOBJECT_H
extern PyTuple_Type as PyTypeObject
extern PyTupleIter_Type as PyTypeObject
#define PyTuple_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS)
#define PyTuple_CheckExact(op) (Py_TYPE(op) = (@PyTuple_Type))
declare function PyTuple_New(byval size as Py_ssize_t) as PyObject ptr
declare function PyTuple_Size(byval as PyObject ptr) as Py_ssize_t
declare function PyTuple_GetItem(byval as PyObject ptr, byval as Py_ssize_t) as PyObject ptr
declare function PyTuple_SetItem(byval as PyObject ptr, byval as Py_ssize_t, byval as PyObject ptr) as long
declare function PyTuple_GetSlice(byval as PyObject ptr, byval as Py_ssize_t, byval as Py_ssize_t) as PyObject ptr
declare function PyTuple_Pack(byval as Py_ssize_t, ...) as PyObject ptr
declare function PyTuple_ClearFreeList() as long
#define Py_LISTOBJECT_H

extern PyList_Type as PyTypeObject
extern PyListIter_Type as PyTypeObject
extern PyListRevIter_Type as PyTypeObject
extern PySortWrapper_Type as PyTypeObject
#define PyList_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
#define PyList_CheckExact(op) (Py_TYPE(op) = (@PyList_Type))

declare function PyList_New(byval size as Py_ssize_t) as PyObject ptr
declare function PyList_Size(byval as PyObject ptr) as Py_ssize_t
declare function PyList_GetItem(byval as PyObject ptr, byval as Py_ssize_t) as PyObject ptr
declare function PyList_SetItem(byval as PyObject ptr, byval as Py_ssize_t, byval as PyObject ptr) as long
declare function PyList_Insert(byval as PyObject ptr, byval as Py_ssize_t, byval as PyObject ptr) as long
declare function PyList_Append(byval as PyObject ptr, byval as PyObject ptr) as long
declare function PyList_GetSlice(byval as PyObject ptr, byval as Py_ssize_t, byval as Py_ssize_t) as PyObject ptr
declare function PyList_SetSlice(byval as PyObject ptr, byval as Py_ssize_t, byval as Py_ssize_t, byval as PyObject ptr) as long
declare function PyList_Sort(byval as PyObject ptr) as long
declare function PyList_Reverse(byval as PyObject ptr) as long
declare function PyList_AsTuple(byval as PyObject ptr) as PyObject ptr
#define Py_DICTOBJECT_H

extern PyDict_Type as PyTypeObject
extern PyDictIterKey_Type as PyTypeObject
extern PyDictIterValue_Type as PyTypeObject
extern PyDictIterItem_Type as PyTypeObject
extern PyDictKeys_Type as PyTypeObject
extern PyDictItems_Type as PyTypeObject
extern PyDictValues_Type as PyTypeObject

#define PyDict_Check(op) PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
#define PyDict_CheckExact(op) (Py_TYPE(op) = (@PyDict_Type))
#define PyDictKeys_Check(op) PyObject_TypeCheck(op, @PyDictKeys_Type)
#define PyDictItems_Check(op) PyObject_TypeCheck(op, @PyDictItems_Type)
#define PyDictValues_Check(op) PyObject_TypeCheck(op, @PyDictValues_Type)
#define PyDictViewSet_Check(op) (PyDictKeys_Check(op) orelse PyDictItems_Check(op))

declare function PyDict_New() as PyObject ptr
declare function PyDict_GetItem(byval mp as PyObject ptr, byval key as PyObject ptr) as PyObject ptr
declare function PyDict_GetItemWithError(byval mp as PyObject ptr, byval key as PyObject ptr) as PyObject ptr
declare function _PyDict_GetItemIdWithError(byval dp as PyObject ptr, byval key as _Py_Identifier ptr) as PyObject ptr
declare function PyDict_SetItem(byval mp as PyObject ptr, byval key as PyObject ptr, byval item as PyObject ptr) as long
declare function PyDict_DelItem(byval mp as PyObject ptr, byval key as PyObject ptr) as long
declare sub PyDict_Clear(byval mp as PyObject ptr)
declare function PyDict_Next(byval mp as PyObject ptr, byval pos as Py_ssize_t ptr, byval key as PyObject ptr ptr, byval value as PyObject ptr ptr) as long
declare function PyDict_Keys(byval mp as PyObject ptr) as PyObject ptr
declare function PyDict_Values(byval mp as PyObject ptr) as PyObject ptr
declare function PyDict_Items(byval mp as PyObject ptr) as PyObject ptr
declare function PyDict_Size(byval mp as PyObject ptr) as Py_ssize_t
declare function PyDict_Copy(byval mp as PyObject ptr) as PyObject ptr
declare function PyDict_Contains(byval mp as PyObject ptr, byval key as PyObject ptr) as long
declare function PyDict_Update(byval mp as PyObject ptr, byval other as PyObject ptr) as long
declare function PyDict_Merge(byval mp as PyObject ptr, byval other as PyObject ptr, byval override as long) as long
declare function PyDict_MergeFromSeq2(byval d as PyObject ptr, byval seq2 as PyObject ptr, byval override as long) as long
declare function PyDict_GetItemString(byval dp as PyObject ptr, byval key as const zstring ptr) as PyObject ptr
declare function _PyDict_GetItemId(byval dp as PyObject ptr, byval key as _Py_Identifier ptr) as PyObject ptr
declare function PyDict_SetItemString(byval dp as PyObject ptr, byval key as const zstring ptr, byval item as PyObject ptr) as long
declare function _PyDict_SetItemId(byval dp as PyObject ptr, byval key as _Py_Identifier ptr, byval item as PyObject ptr) as long
declare function PyDict_DelItemString(byval dp as PyObject ptr, byval key as const zstring ptr) as long

#define Py_ODICTOBJECT_H
#define PyODict_Check(op) PyObject_TypeCheck(op, @PyODict_Type)
#define PyODict_CheckExact(op) (Py_TYPE(op) = (@PyODict_Type))
'' TODO: #define PyODict_HasKey(od, key) (PyMapping_HasKey(PyObject *)od, key)

declare function PyODict_New() as PyObject ptr
declare function PyODict_SetItem(byval od as PyObject ptr, byval key as PyObject ptr, byval item as PyObject ptr) as long
declare function PyODict_DelItem(byval od as PyObject ptr, byval key as PyObject ptr) as long

#define PyODict_GetItem(od, key) PyDict_GetItem(cptr(PyObject ptr, od), key)
#define PyODict_GetItemWithError(od, key) PyDict_GetItemWithError(cptr(PyObject ptr, od), key)
#define PyODict_Contains(od, key) PyDict_Contains(cptr(PyObject ptr, od), key)
#define PyODict_Size(od) PyDict_Size(cptr(PyObject ptr, od))
#define PyODict_GetItemString(od, key) PyDict_GetItemString(cptr(PyObject ptr, od), key)
#define Py_ENUMOBJECT_H
extern PyEnum_Type as PyTypeObject
extern PyReversed_Type as PyTypeObject
#define Py_SETOBJECT_H

extern PySet_Type as PyTypeObject
extern PyFrozenSet_Type as PyTypeObject
extern PySetIter_Type as PyTypeObject

declare function PySet_New(byval as PyObject ptr) as PyObject ptr
declare function PyFrozenSet_New(byval as PyObject ptr) as PyObject ptr
declare function PySet_Add(byval set as PyObject ptr, byval key as PyObject ptr) as long
declare function PySet_Clear(byval set as PyObject ptr) as long
declare function PySet_Contains(byval anyset as PyObject ptr, byval key as PyObject ptr) as long
declare function PySet_Discard(byval set as PyObject ptr, byval key as PyObject ptr) as long
declare function PySet_Pop(byval set as PyObject ptr) as PyObject ptr
declare function PySet_Size(byval anyset as PyObject ptr) as Py_ssize_t

#define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) = (@PyFrozenSet_Type))
#define PyAnySet_CheckExact(ob) ((Py_TYPE(ob) = (@PySet_Type)) orelse (Py_TYPE(ob) = (@PyFrozenSet_Type)))
#define PyAnySet_Check(ob) ((((Py_TYPE(ob) = (@PySet_Type)) orelse (Py_TYPE(ob) = (@PyFrozenSet_Type))) orelse PyType_IsSubtype(Py_TYPE(ob), @PySet_Type)) orelse PyType_IsSubtype(Py_TYPE(ob), @PyFrozenSet_Type))
#define PySet_Check(ob) ((Py_TYPE(ob) = (@PySet_Type)) orelse PyType_IsSubtype(Py_TYPE(ob), @PySet_Type))
#define PyFrozenSet_Check(ob) ((Py_TYPE(ob) = (@PyFrozenSet_Type)) orelse PyType_IsSubtype(Py_TYPE(ob), @PyFrozenSet_Type))
#define Py_METHODOBJECT_H
extern PyCFunction_Type as PyTypeObject
#define PyCFunction_Check(op) (Py_TYPE(op) = (@PyCFunction_Type))

type PyCFunction as function(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type PyCFunctionWithKeywords as function(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
type PyNoArgsFunction as function(byval as PyObject ptr) as PyObject ptr

declare function PyCFunction_GetFunction(byval as PyObject ptr) as PyCFunction
declare function PyCFunction_GetSelf(byval as PyObject ptr) as PyObject ptr
declare function PyCFunction_GetFlags(byval as PyObject ptr) as long
declare function PyCFunction_Call(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr

type PyMethodDef
    ml_name as const zstring ptr
    ml_meth as PyCFunction
    ml_flags as long
    ml_doc as const zstring ptr
end type

#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL)
declare function PyCFunction_NewEx(byval as PyMethodDef ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
const METH_VARARGS = &h0001
const METH_KEYWORDS = &h0002
const METH_NOARGS = &h0004
const METH_O = &h0008
const METH_CLASS = &h0010
const METH_STATIC = &h0020
const METH_COEXIST = &h0040
declare function PyCFunction_ClearFreeList() as long
#define Py_MODULEOBJECT_H
extern PyModule_Type as PyTypeObject
#define PyModule_Check(op) PyObject_TypeCheck(op, @PyModule_Type)
#define PyModule_CheckExact(op) (Py_TYPE(op) = (@PyModule_Type))

declare function PyModule_NewObject(byval name as PyObject ptr) as PyObject ptr
declare function PyModule_New(byval name as const zstring ptr) as PyObject ptr
declare function PyModule_GetDict(byval as PyObject ptr) as PyObject ptr
declare function PyModule_GetNameObject(byval as PyObject ptr) as PyObject ptr
declare function PyModule_GetName(byval as PyObject ptr) as const zstring ptr
declare function PyModule_GetFilename(byval as PyObject ptr) as const zstring ptr
declare function PyModule_GetFilenameObject(byval as PyObject ptr) as PyObject ptr
type PyModuleDef as PyModuleDef_
declare function PyModule_GetDef(byval as PyObject ptr) as PyModuleDef ptr
declare function PyModule_GetState(byval as PyObject ptr) as any ptr

type PyModuleDef_Base
    ob_base as PyObject
    m_init as function() as PyObject ptr
    m_index as Py_ssize_t
    m_copy as PyObject ptr
end type

'' TODO: #define PyModuleDef_HEAD_INIT { PyObject_HEAD_INIT(NULL) NULL, 0, NULL, }
type PyModuleDef_Slot as PyModuleDef_Slot_

type PyModuleDef_
    m_base as PyModuleDef_Base
    m_name as const zstring ptr
    m_doc as const zstring ptr
    m_size as Py_ssize_t
    m_methods as PyMethodDef ptr
    m_slots as PyModuleDef_Slot ptr
    m_traverse as traverseproc
    m_clear as inquiry
    m_free as freefunc
end type

#define Py_FILEOBJECT_H
#define PY_STDIOTEXTMODE "b"
declare function PyFile_FromFd(byval as long, byval as const zstring ptr, byval as const zstring ptr, byval as long, byval as const zstring ptr, byval as const zstring ptr, byval as const zstring ptr, byval as long) as PyObject ptr
declare function PyFile_GetLine(byval as PyObject ptr, byval as long) as PyObject ptr
declare function PyFile_WriteObject(byval as PyObject ptr, byval as PyObject ptr, byval as long) as long
declare function PyFile_WriteString(byval as const zstring ptr, byval as PyObject ptr) as long
declare function PyObject_AsFileDescriptor(byval as PyObject ptr) as long
extern Py_FileSystemDefaultEncoding as const zstring ptr
extern Py_HasFileSystemDefaultEncoding as long
#define _PyIsSelectable_fd(FD) (((FD) >= 0) andalso ((FD) < FD_SETSIZE))
#define Py_CAPSULE_H
extern PyCapsule_Type as PyTypeObject
type PyCapsule_Destructor as sub(byval as PyObject ptr)
#define PyCapsule_CheckExact(op) (Py_TYPE(op) = (@PyCapsule_Type))
declare function PyCapsule_New(byval pointer as any ptr, byval name as const zstring ptr, byval destructor_ as PyCapsule_Destructor) as PyObject ptr
declare function PyCapsule_GetPointer(byval capsule as PyObject ptr, byval name as const zstring ptr) as any ptr
declare function PyCapsule_GetDestructor(byval capsule as PyObject ptr) as PyCapsule_Destructor
declare function PyCapsule_GetName(byval capsule as PyObject ptr) as const zstring ptr
declare function PyCapsule_GetContext(byval capsule as PyObject ptr) as any ptr
declare function PyCapsule_IsValid(byval capsule as PyObject ptr, byval name as const zstring ptr) as long
declare function PyCapsule_SetPointer(byval capsule as PyObject ptr, byval pointer as any ptr) as long
declare function PyCapsule_SetDestructor(byval capsule as PyObject ptr, byval destructor_ as PyCapsule_Destructor) as long
declare function PyCapsule_SetName(byval capsule as PyObject ptr, byval name as const zstring ptr) as long
declare function PyCapsule_SetContext(byval capsule as PyObject ptr, byval context as any ptr) as long
declare function PyCapsule_Import(byval name as const zstring ptr, byval no_block as long) as any ptr
#define Py_TRACEBACK_H
#define Py_PYSTATE_H
type PyInterpreterState as _is
type PyThreadState as _ts
declare function PyInterpreterState_New() as PyInterpreterState ptr
declare sub PyInterpreterState_Clear(byval as PyInterpreterState ptr)
declare sub PyInterpreterState_Delete(byval as PyInterpreterState ptr)
declare function _PyState_AddModule(byval as PyObject ptr, byval as PyModuleDef ptr) as long
declare function PyState_FindModule(byval as PyModuleDef ptr) as PyObject ptr
declare function PyThreadState_New(byval as PyInterpreterState ptr) as PyThreadState ptr
declare function _PyThreadState_Prealloc(byval as PyInterpreterState ptr) as PyThreadState ptr
declare sub _PyThreadState_Init(byval as PyThreadState ptr)
declare sub PyThreadState_Clear(byval as PyThreadState ptr)
declare sub PyThreadState_Delete(byval as PyThreadState ptr)
declare sub _PyThreadState_DeleteExcept(byval tstate as PyThreadState ptr)
declare sub PyThreadState_DeleteCurrent()
declare sub _PyGILState_Reinit()
declare function PyThreadState_Get() as PyThreadState ptr
declare function _PyThreadState_UncheckedGet() as PyThreadState ptr
declare function PyThreadState_Swap(byval as PyThreadState ptr) as PyThreadState ptr
declare function PyThreadState_GetDict() as PyObject ptr
declare function PyThreadState_SetAsyncExc(byval as clong, byval as PyObject ptr) as long

type PyGILState_STATE as long
enum
    PyGILState_LOCKED
    PyGILState_UNLOCKED
end enum

declare function PyGILState_Ensure() as PyGILState_STATE
declare sub PyGILState_Release(byval as PyGILState_STATE)
declare function PyGILState_GetThisThreadState() as PyThreadState ptr
declare function PyTraceBack_Here(byval as PyObject ptr) as long
declare function PyTraceBack_Print(byval as PyObject ptr, byval as PyObject ptr) as long
extern PyTraceBack_Type as PyTypeObject
#define PyTraceBack_Check(v) (Py_TYPE(v) = (@PyTraceBack_Type))
declare sub _Py_DumpTraceback(byval fd as long, byval tstate as PyThreadState ptr)
declare function _Py_DumpTracebackThreads(byval fd as long, byval interp as PyInterpreterState ptr, byval current_thread as PyThreadState ptr) as const zstring ptr
#define Py_SLICEOBJECT_H
extern _Py_EllipsisObject as PyObject
#define Py_Ellipsis (@_Py_EllipsisObject)
extern PySlice_Type as PyTypeObject
extern PyEllipsis_Type as PyTypeObject
#define PySlice_Check(op) (Py_TYPE(op) = (@PySlice_Type))
declare function PySlice_New(byval start as PyObject ptr, byval stop as PyObject ptr, byval step as PyObject ptr) as PyObject ptr
declare function PySlice_GetIndices(byval r as PyObject ptr, byval length as Py_ssize_t, byval start as Py_ssize_t ptr, byval stop as Py_ssize_t ptr, byval step as Py_ssize_t ptr) as long
declare function PySlice_GetIndicesEx(byval r as PyObject ptr, byval length as Py_ssize_t, byval start as Py_ssize_t ptr, byval stop as Py_ssize_t ptr, byval step as Py_ssize_t ptr, byval slicelength as Py_ssize_t ptr) as long
#define Py_ITEROBJECT_H

extern PySeqIter_Type as PyTypeObject
extern PyCallIter_Type as PyTypeObject
extern PyCmpWrapper_Type as PyTypeObject
#define PySeqIter_Check(op) (Py_TYPE(op) = (@PySeqIter_Type))
declare function PySeqIter_New(byval as PyObject ptr) as PyObject ptr
#define PyCallIter_Check(op) (Py_TYPE(op) = (@PyCallIter_Type))
declare function PyCallIter_New(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
#define Py_DESCROBJECT_H
type getter as function(byval as PyObject ptr, byval as any ptr) as PyObject ptr
type setter as function(byval as PyObject ptr, byval as PyObject ptr, byval as any ptr) as long

type PyGetSetDef
    name as zstring ptr
    get as getter
    set as setter
    doc as zstring ptr
    closure as any ptr
end type

extern PyClassMethodDescr_Type as PyTypeObject
extern PyGetSetDescr_Type as PyTypeObject
extern PyMemberDescr_Type as PyTypeObject
extern PyMethodDescr_Type as PyTypeObject
extern PyWrapperDescr_Type as PyTypeObject
extern PyDictProxy_Type as PyTypeObject
extern _PyMethodWrapper_Type as PyTypeObject
declare function PyDescr_NewMethod(byval as PyTypeObject ptr, byval as PyMethodDef ptr) as PyObject ptr
declare function PyDescr_NewClassMethod(byval as PyTypeObject ptr, byval as PyMethodDef ptr) as PyObject ptr
type PyMemberDef as PyMemberDef_

declare function PyDescr_NewMember(byval as PyTypeObject ptr, byval as PyMemberDef ptr) as PyObject ptr
declare function PyDescr_NewGetSet(byval as PyTypeObject ptr, byval as PyGetSetDef ptr) as PyObject ptr
declare function PyDictProxy_New(byval as PyObject ptr) as PyObject ptr
declare function PyWrapper_New(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
extern PyProperty_Type as PyTypeObject
#define Py_WARNINGS_H
declare function PyErr_WarnEx(byval category as PyObject ptr, byval message as const zstring ptr, byval stack_level as Py_ssize_t) as long
declare function PyErr_WarnFormat(byval category as PyObject ptr, byval stack_level as Py_ssize_t, byval format as const zstring ptr, ...) as long
declare function PyErr_WarnExplicit(byval category as PyObject ptr, byval message as const zstring ptr, byval filename as const zstring ptr, byval lineno as long, byval module as const zstring ptr, byval registry as PyObject ptr) as long
#define Py_WEAKREFOBJECT_H
type PyWeakReference as _PyWeakReference

extern _PyWeakref_RefType as PyTypeObject
extern _PyWeakref_ProxyType as PyTypeObject
extern _PyWeakref_CallableProxyType as PyTypeObject

#define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, @_PyWeakref_RefType)
#define PyWeakref_CheckRefExact(op) (Py_TYPE(op) = (@_PyWeakref_RefType))
#define PyWeakref_CheckProxy(op) ((Py_TYPE(op) = (@_PyWeakref_ProxyType)) orelse (Py_TYPE(op) = (@_PyWeakref_CallableProxyType)))
#define PyWeakref_Check(op) (PyWeakref_CheckRef(op) orelse PyWeakref_CheckProxy(op))

declare function PyWeakref_NewRef(byval ob as PyObject ptr, byval callback as PyObject ptr) as PyObject ptr
declare function PyWeakref_NewProxy(byval ob as PyObject ptr, byval callback as PyObject ptr) as PyObject ptr
declare function PyWeakref_GetObject(byval ref as PyObject ptr) as PyObject ptr
#define PyWeakref_GET_OBJECT(ref) iif(Py_REFCNT(cptr(PyWeakReference ptr, (ref))->wr_object) > 0, cptr(PyWeakReference ptr, (ref))->wr_object, Py_None)
#define Py_STRUCTSEQ_H

type PyStructSequence_Field
    name as zstring ptr
    doc as zstring ptr
end type

type PyStructSequence_Desc
    name as zstring ptr
    doc as zstring ptr
    fields as PyStructSequence_Field ptr
    n_in_sequence as long
end type

extern PyStructSequence_UnnamedField as zstring ptr
declare function PyStructSequence_NewType(byval desc as PyStructSequence_Desc ptr) as PyTypeObject ptr
declare function PyStructSequence_New(byval type as PyTypeObject ptr) as PyObject ptr
declare sub PyStructSequence_SetItem(byval as PyObject ptr, byval as Py_ssize_t, byval as PyObject ptr)
declare function PyStructSequence_GetItem(byval as PyObject ptr, byval as Py_ssize_t) as PyObject ptr
#define NAMESPACEOBJECT_H
extern _PyNamespace_Type as PyTypeObject
declare function _PyNamespace_New(byval kwds as PyObject ptr) as PyObject ptr
#define Py_CODECREGISTRY_H
declare function PyCodec_Register(byval search_function as PyObject ptr) as long
declare function PyCodec_KnownEncoding(byval encoding as const zstring ptr) as long
declare function PyCodec_Encode(byval object as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyCodec_Decode(byval object as PyObject ptr, byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyCodec_Encoder(byval encoding as const zstring ptr) as PyObject ptr
declare function PyCodec_Decoder(byval encoding as const zstring ptr) as PyObject ptr
declare function PyCodec_IncrementalEncoder(byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyCodec_IncrementalDecoder(byval encoding as const zstring ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyCodec_StreamReader(byval encoding as const zstring ptr, byval stream as PyObject ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyCodec_StreamWriter(byval encoding as const zstring ptr, byval stream as PyObject ptr, byval errors as const zstring ptr) as PyObject ptr
declare function PyCodec_RegisterError(byval name as const zstring ptr, byval error as PyObject ptr) as long
declare function PyCodec_LookupError(byval name as const zstring ptr) as PyObject ptr
declare function PyCodec_StrictErrors(byval exc as PyObject ptr) as PyObject ptr
declare function PyCodec_IgnoreErrors(byval exc as PyObject ptr) as PyObject ptr
declare function PyCodec_ReplaceErrors(byval exc as PyObject ptr) as PyObject ptr
declare function PyCodec_XMLCharRefReplaceErrors(byval exc as PyObject ptr) as PyObject ptr
declare function PyCodec_BackslashReplaceErrors(byval exc as PyObject ptr) as PyObject ptr
declare function PyCodec_NameReplaceErrors(byval exc as PyObject ptr) as PyObject ptr
extern Py_hexdigits as const zstring ptr
#define Py_ERRORS_H
declare sub PyErr_SetNone(byval as PyObject ptr)
declare sub PyErr_SetObject(byval as PyObject ptr, byval as PyObject ptr)
declare sub PyErr_SetString(byval exception as PyObject ptr, byval string as const zstring ptr)
declare function PyErr_Occurred() as PyObject ptr
declare sub PyErr_Clear()
declare sub PyErr_Fetch(byval as PyObject ptr ptr, byval as PyObject ptr ptr, byval as PyObject ptr ptr)
declare sub PyErr_Restore(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr)
declare sub PyErr_GetExcInfo(byval as PyObject ptr ptr, byval as PyObject ptr ptr, byval as PyObject ptr ptr)
declare sub PyErr_SetExcInfo(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr)
declare sub Py_FatalError(byval message as const zstring ptr)
#define _PyErr_OCCURRED() PyErr_Occurred()
declare function PyErr_GivenExceptionMatches(byval as PyObject ptr, byval as PyObject ptr) as long
declare function PyErr_ExceptionMatches(byval as PyObject ptr) as long
declare sub PyErr_NormalizeException(byval as PyObject ptr ptr, byval as PyObject ptr ptr, byval as PyObject ptr ptr)
declare function PyException_SetTraceback(byval as PyObject ptr, byval as PyObject ptr) as long
declare function PyException_GetTraceback(byval as PyObject ptr) as PyObject ptr
declare function PyException_GetCause(byval as PyObject ptr) as PyObject ptr
declare sub PyException_SetCause(byval as PyObject ptr, byval as PyObject ptr)
declare function PyException_GetContext(byval as PyObject ptr) as PyObject ptr
declare sub PyException_SetContext(byval as PyObject ptr, byval as PyObject ptr)

#define PyExceptionClass_Check(x) (PyType_Check((x)) andalso PyType_FastSubclass(cptr(PyTypeObject ptr, (x)), Py_TPFLAGS_BASE_EXC_SUBCLASS))
#define PyExceptionInstance_Check(x) PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS)
#define PyExceptionClass_Name(x) cptr(zstring ptr, cptr(PyTypeObject ptr, (x))->tp_name)
#define PyExceptionInstance_Class(x) cptr(PyObject ptr, (x)->ob_type)

extern PyExc_BaseException as PyObject ptr
extern PyExc_Exception as PyObject ptr
extern PyExc_StopAsyncIteration as PyObject ptr
extern PyExc_StopIteration as PyObject ptr
extern PyExc_GeneratorExit as PyObject ptr
extern PyExc_ArithmeticError as PyObject ptr
extern PyExc_LookupError as PyObject ptr
extern PyExc_AssertionError as PyObject ptr
extern PyExc_AttributeError as PyObject ptr
extern PyExc_BufferError as PyObject ptr
extern PyExc_EOFError as PyObject ptr
extern PyExc_FloatingPointError as PyObject ptr
extern PyExc_OSError as PyObject ptr
extern PyExc_ImportError as PyObject ptr
extern PyExc_IndexError as PyObject ptr
extern PyExc_KeyError as PyObject ptr
extern PyExc_KeyboardInterrupt as PyObject ptr
extern PyExc_MemoryError as PyObject ptr
extern PyExc_NameError as PyObject ptr
extern PyExc_OverflowError as PyObject ptr
extern PyExc_RuntimeError as PyObject ptr
extern PyExc_RecursionError as PyObject ptr
extern PyExc_NotImplementedError as PyObject ptr
extern PyExc_SyntaxError as PyObject ptr
extern PyExc_IndentationError as PyObject ptr
extern PyExc_TabError as PyObject ptr
extern PyExc_ReferenceError as PyObject ptr
extern PyExc_SystemError as PyObject ptr
extern PyExc_SystemExit as PyObject ptr
extern PyExc_TypeError as PyObject ptr
extern PyExc_UnboundLocalError as PyObject ptr
extern PyExc_UnicodeError as PyObject ptr
extern PyExc_UnicodeEncodeError as PyObject ptr
extern PyExc_UnicodeDecodeError as PyObject ptr
extern PyExc_UnicodeTranslateError as PyObject ptr
extern PyExc_ValueError as PyObject ptr
extern PyExc_ZeroDivisionError as PyObject ptr
extern PyExc_BlockingIOError as PyObject ptr
extern PyExc_BrokenPipeError as PyObject ptr
extern PyExc_ChildProcessError as PyObject ptr
extern PyExc_ConnectionError as PyObject ptr
extern PyExc_ConnectionAbortedError as PyObject ptr
extern PyExc_ConnectionRefusedError as PyObject ptr
extern PyExc_ConnectionResetError as PyObject ptr
extern PyExc_FileExistsError as PyObject ptr
extern PyExc_FileNotFoundError as PyObject ptr
extern PyExc_InterruptedError as PyObject ptr
extern PyExc_IsADirectoryError as PyObject ptr
extern PyExc_NotADirectoryError as PyObject ptr
extern PyExc_PermissionError as PyObject ptr
extern PyExc_ProcessLookupError as PyObject ptr
extern PyExc_TimeoutError as PyObject ptr
extern PyExc_EnvironmentError as PyObject ptr
extern PyExc_IOError as PyObject ptr
extern PyExc_RecursionErrorInst as PyObject ptr
extern PyExc_Warning as PyObject ptr
extern PyExc_UserWarning as PyObject ptr
extern PyExc_DeprecationWarning as PyObject ptr
extern PyExc_PendingDeprecationWarning as PyObject ptr
extern PyExc_SyntaxWarning as PyObject ptr
extern PyExc_RuntimeWarning as PyObject ptr
extern PyExc_FutureWarning as PyObject ptr
extern PyExc_ImportWarning as PyObject ptr
extern PyExc_UnicodeWarning as PyObject ptr
extern PyExc_BytesWarning as PyObject ptr
extern PyExc_ResourceWarning as PyObject ptr

declare function PyErr_BadArgument() as long
declare function PyErr_NoMemory() as PyObject ptr
declare function PyErr_SetFromErrno(byval as PyObject ptr) as PyObject ptr
declare function PyErr_SetFromErrnoWithFilenameObject(byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyErr_SetFromErrnoWithFilenameObjects(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyErr_SetFromErrnoWithFilename(byval exc as PyObject ptr, byval filename as const zstring ptr) as PyObject ptr
declare function PyErr_Format(byval exception as PyObject ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function PyErr_SetExcWithArgsKwargs(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyErr_SetImportError(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
#undef PyErr_BadInternalCall
declare sub PyErr_BadInternalCall()
declare sub _PyErr_BadInternalCall(byval filename as const zstring ptr, byval lineno as long)
#undef PyErr_BadInternalCall
#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
declare function PyErr_NewException(byval name as const zstring ptr, byval base as PyObject ptr, byval dict as PyObject ptr) as PyObject ptr
declare function PyErr_NewExceptionWithDoc(byval name as const zstring ptr, byval doc as const zstring ptr, byval base as PyObject ptr, byval dict as PyObject ptr) as PyObject ptr
declare sub PyErr_WriteUnraisable(byval as PyObject ptr)
declare function PyErr_CheckSignals() as long
declare sub PyErr_SetInterrupt()
declare sub PyErr_SyntaxLocation(byval filename as const zstring ptr, byval lineno as long)
declare sub PyErr_SyntaxLocationEx(byval filename as const zstring ptr, byval lineno as long, byval col_offset as long)
declare function PyErr_ProgramText(byval filename as const zstring ptr, byval lineno as long) as PyObject ptr
declare function PyUnicodeDecodeError_Create(byval encoding as const zstring ptr, byval object as const zstring ptr, byval length as Py_ssize_t, byval start as Py_ssize_t, byval end as Py_ssize_t, byval reason as const zstring ptr) as PyObject ptr
declare function PyUnicodeEncodeError_GetEncoding(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeDecodeError_GetEncoding(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeEncodeError_GetObject(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeDecodeError_GetObject(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeTranslateError_GetObject(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeEncodeError_GetStart(byval as PyObject ptr, byval as Py_ssize_t ptr) as long
declare function PyUnicodeDecodeError_GetStart(byval as PyObject ptr, byval as Py_ssize_t ptr) as long
declare function PyUnicodeTranslateError_GetStart(byval as PyObject ptr, byval as Py_ssize_t ptr) as long
declare function PyUnicodeEncodeError_SetStart(byval as PyObject ptr, byval as Py_ssize_t) as long
declare function PyUnicodeDecodeError_SetStart(byval as PyObject ptr, byval as Py_ssize_t) as long
declare function PyUnicodeTranslateError_SetStart(byval as PyObject ptr, byval as Py_ssize_t) as long
declare function PyUnicodeEncodeError_GetEnd(byval as PyObject ptr, byval as Py_ssize_t ptr) as long
declare function PyUnicodeDecodeError_GetEnd(byval as PyObject ptr, byval as Py_ssize_t ptr) as long
declare function PyUnicodeTranslateError_GetEnd(byval as PyObject ptr, byval as Py_ssize_t ptr) as long
declare function PyUnicodeEncodeError_SetEnd(byval as PyObject ptr, byval as Py_ssize_t) as long
declare function PyUnicodeDecodeError_SetEnd(byval as PyObject ptr, byval as Py_ssize_t) as long
declare function PyUnicodeTranslateError_SetEnd(byval as PyObject ptr, byval as Py_ssize_t) as long
declare function PyUnicodeEncodeError_GetReason(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeDecodeError_GetReason(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeTranslateError_GetReason(byval as PyObject ptr) as PyObject ptr
declare function PyUnicodeEncodeError_SetReason(byval exc as PyObject ptr, byval reason as const zstring ptr) as long
declare function PyUnicodeDecodeError_SetReason(byval exc as PyObject ptr, byval reason as const zstring ptr) as long
declare function PyUnicodeTranslateError_SetReason(byval exc as PyObject ptr, byval reason as const zstring ptr) as long
declare function PyOS_snprintf(byval str as zstring ptr, byval size as uinteger, byval format as const zstring ptr, ...) as long
declare function PyOS_vsnprintf(byval str as zstring ptr, byval size as uinteger, byval format as const zstring ptr, byval va as va_list) as long
#define Py_MODSUPPORT_H
declare function _Py_VaBuildValue_SizeT(byval as const zstring ptr, byval as va_list) as PyObject ptr
declare function PyArg_Parse(byval as PyObject ptr, byval as const zstring ptr, ...) as long
declare function PyArg_ParseTuple(byval as PyObject ptr, byval as const zstring ptr, ...) as long
declare function PyArg_ParseTupleAndKeywords(byval as PyObject ptr, byval as PyObject ptr, byval as const zstring ptr, byval as zstring ptr ptr, ...) as long
declare function PyArg_ValidateKeywordArguments(byval as PyObject ptr) as long
declare function PyArg_UnpackTuple(byval as PyObject ptr, byval as const zstring ptr, byval as Py_ssize_t, byval as Py_ssize_t, ...) as long
declare function Py_BuildValue(byval as const zstring ptr, ...) as PyObject ptr
declare function _Py_BuildValue_SizeT(byval as const zstring ptr, ...) as PyObject ptr
declare function Py_VaBuildValue(byval as const zstring ptr, byval as va_list) as PyObject ptr
declare function PyModule_AddObject(byval as PyObject ptr, byval as const zstring ptr, byval as PyObject ptr) as long
declare function PyModule_AddIntConstant(byval as PyObject ptr, byval as const zstring ptr, byval as clong) as long
declare function PyModule_AddStringConstant(byval as PyObject ptr, byval as const zstring ptr, byval as const zstring ptr) as long

#define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c)
#define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c)
const Py_CLEANUP_SUPPORTED = &h20000
const PYTHON_API_VERSION = 1013
#define PYTHON_API_STRING "1013"
const PYTHON_ABI_VERSION = 3
#define PYTHON_ABI_STRING "3"
declare function PyModule_Create2(byval as PyModuleDef ptr, byval apiver as long) as PyObject ptr
#define PyModule_Create(module) PyModule_Create2(module, PYTHON_ABI_VERSION)
#define Py_PYTHONRUN_H
#define PyCF_MASK ((((((CO_FUTURE_DIVISION or CO_FUTURE_ABSOLUTE_IMPORT) or CO_FUTURE_WITH_STATEMENT) or CO_FUTURE_PRINT_FUNCTION) or CO_FUTURE_UNICODE_LITERALS) or CO_FUTURE_BARRY_AS_BDFL) or CO_FUTURE_GENERATOR_STOP)
#define PyCF_MASK_OBSOLETE CO_NESTED
const PyCF_SOURCE_IS_UTF8 = &h0100
const PyCF_DONT_IMPLY_DEDENT = &h0200
const PyCF_ONLY_AST = &h0400
const PyCF_IGNORE_COOKIE = &h0800
#define PyParser_SimpleParseString(S, B) PyParser_SimpleParseStringFlags(S, B, 0)
#define PyParser_SimpleParseFile(FP, S, B) PyParser_SimpleParseFileFlags(FP, S, B, 0)
type _node as _node_

declare function PyParser_SimpleParseStringFlags(byval as const zstring ptr, byval as long, byval as long) as _node ptr
declare function PyParser_SimpleParseStringFlagsFilename(byval as const zstring ptr, byval as const zstring ptr, byval as long, byval as long) as _node ptr
declare function PyParser_SimpleParseFileFlags(byval as FILE ptr, byval as const zstring ptr, byval as long, byval as long) as _node ptr
declare function Py_CompileString(byval as const zstring ptr, byval as const zstring ptr, byval as long) as PyObject ptr
type symtable as symtable_
declare function Py_SymtableString(byval str as const zstring ptr, byval filename as const zstring ptr, byval start as long) as symtable ptr
declare sub PyErr_Print()
declare sub PyErr_PrintEx(byval as long)
declare sub PyErr_Display(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr)
extern PyOS_InputHook as function() as long
extern PyOS_ReadlineFunctionPointer as function(byval as FILE ptr, byval as FILE ptr, byval as const zstring ptr) as zstring ptr
const PYOS_STACK_MARGIN = 2048
#define Py_PYLIFECYCLE_H
declare sub Py_SetProgramName(byval as wstring ptr)
declare function Py_GetProgramName() as wstring ptr
declare sub Py_SetPythonHome(byval as wstring ptr)
declare function Py_GetPythonHome() as wstring ptr
declare sub Py_Initialize()
declare sub Py_InitializeEx(byval as long)
declare sub Py_Finalize()
declare function Py_IsInitialized() as long
declare function Py_NewInterpreter() as PyThreadState ptr
declare sub Py_EndInterpreter(byval as PyThreadState ptr)
declare function Py_AtExit(byval func as sub()) as long
declare sub Py_Exit(byval as long)
declare function Py_Main(byval argc as long, byval argv as wstring ptr ptr) as long
declare function Py_GetProgramFullPath() as wstring ptr
declare function Py_GetPrefix() as wstring ptr
declare function Py_GetExecPrefix() as wstring ptr
declare function Py_GetPath() as wstring ptr
declare sub Py_SetPath(byval as const wstring ptr)
declare function Py_GetVersion() as const zstring ptr
declare function Py_GetPlatform() as const zstring ptr
declare function Py_GetCopyright() as const zstring ptr
declare function Py_GetCompiler() as const zstring ptr
declare function Py_GetBuildInfo() as const zstring ptr
type PyOS_sighandler_t as sub(byval as long)
declare function PyOS_getsig(byval as long) as PyOS_sighandler_t
declare function PyOS_setsig(byval as long, byval as PyOS_sighandler_t) as PyOS_sighandler_t
declare function _PyOS_URandom(byval buffer as any ptr, byval size as Py_ssize_t) as long
#define Py_CEVAL_H
declare function PyEval_CallObjectWithKeywords(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
#define PyEval_CallObject(func, arg) PyEval_CallObjectWithKeywords(func, arg, cptr(PyObject ptr, NULL))
declare function PyEval_CallFunction(byval obj as PyObject ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function PyEval_CallMethod(byval obj as PyObject ptr, byval methodname as const zstring ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function PyEval_GetBuiltins() as PyObject ptr
declare function PyEval_GetGlobals() as PyObject ptr
declare function PyEval_GetLocals() as PyObject ptr
declare function PyEval_GetFrame() as PyObject ptr
declare function Py_AddPendingCall(byval func as function(byval as any ptr) as long, byval arg as any ptr) as long
declare function Py_MakePendingCalls() as long
declare sub Py_SetRecursionLimit(byval as long)
declare function Py_GetRecursionLimit() as long
#define Py_EnterRecursiveCall(where) (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) andalso _Py_CheckRecursiveCall(where))
#macro Py_LeaveRecursiveCall()
    if _Py_MakeEndRecCheck(PyThreadState_GET()->recursion_depth) then
        PyThreadState_GET()->overflowed = 0
    end if
#endmacro
declare function _Py_CheckRecursiveCall(byval where as const zstring ptr) as long
extern _Py_CheckRecursionLimit as long
'' TODO: # define _Py_MakeRecCheck(x) (++(x) > _Py_CheckRecursionLimit)
#define _Py_RecursionLimitLowerWaterMark(limit) iif((limit) > 200, (limit) - 50, 3 * ((limit) shr 2))

'' TODO: #define _Py_MakeEndRecCheck(x) (--(x) < _Py_RecursionLimitLowerWaterMark(_Py_CheckRecursionLimit))
'' TODO: #define Py_ALLOW_RECURSION do { unsigned char _old = PyThreadState_GET()->recursion_critical; PyThreadState_GET()->recursion_critical = 1;
'' TODO: #define Py_END_ALLOW_RECURSION PyThreadState_GET()->recursion_critical = _old; } while(0);

declare function PyEval_GetFuncName(byval as PyObject ptr) as const zstring ptr
declare function PyEval_GetFuncDesc(byval as PyObject ptr) as const zstring ptr
declare function PyEval_GetCallStats(byval as PyObject ptr) as PyObject ptr
declare function PyEval_EvalFrame(byval as PyObject ptr) as PyObject ptr
declare function PyEval_EvalFrameEx(byval f as PyObject ptr, byval exc as long) as PyObject ptr
declare function PyEval_SaveThread() as PyThreadState ptr
declare sub PyEval_RestoreThread(byval as PyThreadState ptr)
declare function PyEval_ThreadsInitialized() as long
declare sub PyEval_InitThreads()
declare sub _PyEval_FiniThreads()
declare sub PyEval_AcquireLock()
declare sub PyEval_ReleaseLock()
declare sub PyEval_AcquireThread(byval tstate as PyThreadState ptr)
declare sub PyEval_ReleaseThread(byval tstate as PyThreadState ptr)
declare sub PyEval_ReInitThreads()

'' TODO: #define Py_BEGIN_ALLOW_THREADS { PyThreadState *_save; _save = PyEval_SaveThread();
'' TODO: #define Py_BLOCK_THREADS PyEval_RestoreThread(_save);
'' TODO: #define Py_UNBLOCK_THREADS _save = PyEval_SaveThread();
'' TODO: #define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); }
#define Py_SYSMODULE_H

declare function PySys_GetObject(byval as const zstring ptr) as PyObject ptr
declare function PySys_SetObject(byval as const zstring ptr, byval as PyObject ptr) as long
declare function _PySys_SetObjectId(byval key as _Py_Identifier ptr, byval as PyObject ptr) as long
declare sub PySys_SetArgv(byval as long, byval as wstring ptr ptr)
declare sub PySys_SetArgvEx(byval as long, byval as wstring ptr ptr, byval as long)
declare sub PySys_SetPath(byval as const wstring ptr)
declare sub PySys_WriteStdout(byval format as const zstring ptr, ...)
declare sub PySys_WriteStderr(byval format as const zstring ptr, ...)
declare sub PySys_FormatStdout(byval format as const zstring ptr, ...)
declare sub PySys_FormatStderr(byval format as const zstring ptr, ...)
declare sub PySys_ResetWarnOptions()
declare sub PySys_AddWarnOption(byval as const wstring ptr)
declare sub PySys_AddWarnOptionUnicode(byval as PyObject ptr)
declare function PySys_HasWarnOptions() as long
declare sub PySys_AddXOption(byval as const wstring ptr)
declare function PySys_GetXOptions() as PyObject ptr
#define Py_INTRCHECK_H
declare function PyOS_InterruptOccurred() as long
declare sub PyOS_InitInterrupts()
declare sub PyOS_AfterFork()
declare function _PyOS_IsMainThread() as long
#define Py_IMPORT_H
declare sub _PyImportZip_Init()
declare function PyInit_imp() as PyObject ptr
declare function PyImport_GetMagicNumber() as clong
declare function PyImport_GetMagicTag() as const zstring ptr
declare function PyImport_ExecCodeModule(byval name as const zstring ptr, byval co as PyObject ptr) as PyObject ptr
declare function PyImport_ExecCodeModuleEx(byval name as const zstring ptr, byval co as PyObject ptr, byval pathname as const zstring ptr) as PyObject ptr
declare function PyImport_ExecCodeModuleWithPathnames(byval name as const zstring ptr, byval co as PyObject ptr, byval pathname as const zstring ptr, byval cpathname as const zstring ptr) as PyObject ptr
declare function PyImport_ExecCodeModuleObject(byval name as PyObject ptr, byval co as PyObject ptr, byval pathname as PyObject ptr, byval cpathname as PyObject ptr) as PyObject ptr
declare function PyImport_GetModuleDict() as PyObject ptr
declare function PyImport_AddModuleObject(byval name as PyObject ptr) as PyObject ptr
declare function PyImport_AddModule(byval name as const zstring ptr) as PyObject ptr
declare function PyImport_ImportModule(byval name as const zstring ptr) as PyObject ptr
declare function PyImport_ImportModuleNoBlock(byval name as const zstring ptr) as PyObject ptr
declare function PyImport_ImportModuleLevel(byval name as const zstring ptr, byval globals as PyObject ptr, byval locals as PyObject ptr, byval fromlist as PyObject ptr, byval level as long) as PyObject ptr
declare function PyImport_ImportModuleLevelObject(byval name as PyObject ptr, byval globals as PyObject ptr, byval locals as PyObject ptr, byval fromlist as PyObject ptr, byval level as long) as PyObject ptr
#define PyImport_ImportModuleEx(n, g, l, f) PyImport_ImportModuleLevel(n, g, l, f, 0)
declare function PyImport_GetImporter(byval path as PyObject ptr) as PyObject ptr
declare function PyImport_Import(byval name as PyObject ptr) as PyObject ptr
declare function PyImport_ReloadModule(byval m as PyObject ptr) as PyObject ptr
declare sub PyImport_Cleanup()
declare function PyImport_ImportFrozenModuleObject(byval name as PyObject ptr) as long
declare function PyImport_ImportFrozenModule(byval name as const zstring ptr) as long
extern PyNullImporter_Type as PyTypeObject
declare function PyImport_AppendInittab(byval name as const zstring ptr, byval initfunc as function() as PyObject ptr) as long

#define Py_ABSTRACTOBJECT_H
#define PyObject_DelAttrString(O, A) PyObject_SetAttrString((O), (A), NULL)
#define PyObject_DelAttr(O, A) PyObject_SetAttr((O), (A), NULL)

declare function PyObject_Call(byval callable_object as PyObject ptr, byval args as PyObject ptr, byval kw as PyObject ptr) as PyObject ptr
declare function PyObject_CallObject(byval callable_object as PyObject ptr, byval args as PyObject ptr) as PyObject ptr
declare function PyObject_CallFunction(byval callable_object as PyObject ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function PyObject_CallMethod(byval o as PyObject ptr, byval method as const zstring ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function _PyObject_CallMethodId(byval o as PyObject ptr, byval method as _Py_Identifier ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function _PyObject_CallFunction_SizeT(byval callable as PyObject ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function _PyObject_CallMethod_SizeT(byval o as PyObject ptr, byval name as const zstring ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function _PyObject_CallMethodId_SizeT(byval o as PyObject ptr, byval name as _Py_Identifier ptr, byval format as const zstring ptr, ...) as PyObject ptr
declare function PyObject_CallFunctionObjArgs(byval callable as PyObject ptr, ...) as PyObject ptr
declare function PyObject_CallMethodObjArgs(byval o as PyObject ptr, byval method as PyObject ptr, ...) as PyObject ptr
declare function _PyObject_CallMethodIdObjArgs(byval o as PyObject ptr, byval method as _Py_Identifier ptr, ...) as PyObject ptr
declare function PyObject_Type(byval o as PyObject ptr) as PyObject ptr
declare function PyObject_Size(byval o as PyObject ptr) as Py_ssize_t
#undef PyObject_Length
#undef PyObject_Length
declare function PyObject_Length(byval o as PyObject ptr) as Py_ssize_t
#undef PyObject_Length
declare function PyObject_Length alias "PyObject_Size"(byval o as PyObject ptr) as Py_ssize_t
declare function PyObject_GetItem(byval o as PyObject ptr, byval key as PyObject ptr) as PyObject ptr
declare function PyObject_SetItem(byval o as PyObject ptr, byval key as PyObject ptr, byval v as PyObject ptr) as long
declare function PyObject_DelItemString(byval o as PyObject ptr, byval key as const zstring ptr) as long
declare function PyObject_DelItem(byval o as PyObject ptr, byval key as PyObject ptr) as long
declare function PyObject_AsCharBuffer(byval obj as PyObject ptr, byval buffer as const zstring ptr ptr, byval buffer_len as Py_ssize_t ptr) as long
declare function PyObject_CheckReadBuffer(byval obj as PyObject ptr) as long
declare function PyObject_AsReadBuffer(byval obj as PyObject ptr, byval buffer as const any ptr ptr, byval buffer_len as Py_ssize_t ptr) as long
declare function PyObject_AsWriteBuffer(byval obj as PyObject ptr, byval buffer as any ptr ptr, byval buffer_len as Py_ssize_t ptr) as long
declare function PyObject_Format(byval obj as PyObject ptr, byval format_spec as PyObject ptr) as PyObject ptr
declare function PyObject_GetIter(byval as PyObject ptr) as PyObject ptr
#define PyIter_Check(obj) (((obj)->ob_type->tp_iternext <> NULL) andalso ((obj)->ob_type->tp_iternext <> (@_PyObject_NextNotImplemented)))
declare function PyIter_Next(byval as PyObject ptr) as PyObject ptr
declare function PyNumber_Check(byval o as PyObject ptr) as long
declare function PyNumber_Add(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Subtract(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Multiply(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_MatrixMultiply(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_FloorDivide(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_TrueDivide(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Remainder(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Divmod(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Power(byval o1 as PyObject ptr, byval o2 as PyObject ptr, byval o3 as PyObject ptr) as PyObject ptr
declare function PyNumber_Negative(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_Positive(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_Absolute(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_Invert(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_Lshift(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Rshift(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_And(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Xor(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_Or(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
#define PyIndex_Check(obj) (((obj)->ob_type->tp_as_number <> NULL) andalso ((obj)->ob_type->tp_as_number->nb_index <> NULL))
declare function PyNumber_Index(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_AsSsize_t(byval o as PyObject ptr, byval exc as PyObject ptr) as Py_ssize_t
declare function PyNumber_Long(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_Float(byval o as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceAdd(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceSubtract(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceMultiply(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceMatrixMultiply(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceFloorDivide(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceTrueDivide(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceRemainder(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlacePower(byval o1 as PyObject ptr, byval o2 as PyObject ptr, byval o3 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceLshift(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceRshift(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceAnd(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceXor(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_InPlaceOr(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PyNumber_ToBase(byval n as PyObject ptr, byval base as long) as PyObject ptr
declare function PySequence_Check(byval o as PyObject ptr) as long
declare function PySequence_Size(byval o as PyObject ptr) as Py_ssize_t
#undef PySequence_Length
#undef PySequence_Length
declare function PySequence_Length(byval o as PyObject ptr) as Py_ssize_t
#undef PySequence_Length
declare function PySequence_Length alias "PySequence_Size"(byval o as PyObject ptr) as Py_ssize_t
declare function PySequence_Concat(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PySequence_Repeat(byval o as PyObject ptr, byval count as Py_ssize_t) as PyObject ptr
declare function PySequence_GetItem(byval o as PyObject ptr, byval i as Py_ssize_t) as PyObject ptr
declare function PySequence_GetSlice(byval o as PyObject ptr, byval i1 as Py_ssize_t, byval i2 as Py_ssize_t) as PyObject ptr
declare function PySequence_SetItem(byval o as PyObject ptr, byval i as Py_ssize_t, byval v as PyObject ptr) as long
declare function PySequence_DelItem(byval o as PyObject ptr, byval i as Py_ssize_t) as long
declare function PySequence_SetSlice(byval o as PyObject ptr, byval i1 as Py_ssize_t, byval i2 as Py_ssize_t, byval v as PyObject ptr) as long
declare function PySequence_DelSlice(byval o as PyObject ptr, byval i1 as Py_ssize_t, byval i2 as Py_ssize_t) as long
declare function PySequence_Tuple(byval o as PyObject ptr) as PyObject ptr
declare function PySequence_List(byval o as PyObject ptr) as PyObject ptr
declare function PySequence_Fast(byval o as PyObject ptr, byval m as const zstring ptr) as PyObject ptr

#define PySequence_Fast_GET_SIZE(o) iif(PyList_Check(o), PyList_GET_SIZE(o), PyTuple_GET_SIZE(o))
#define PySequence_Fast_GET_ITEM(o, i) iif(PyList_Check(o), PyList_GET_ITEM(o, i), PyTuple_GET_ITEM(o, i))
#define PySequence_ITEM(o, i) Py_TYPE(o)->tp_as_sequence->sq_item(o, i)
#define PySequence_Fast_ITEMS(sf) iif(PyList_Check(sf), cptr(PyListObject ptr, (sf))->ob_item, cptr(PyTupleObject ptr, (sf))->ob_item)
declare function PySequence_Count(byval o as PyObject ptr, byval value as PyObject ptr) as Py_ssize_t
declare function PySequence_Contains(byval seq as PyObject ptr, byval ob as PyObject ptr) as long
#undef PySequence_In
#undef PySequence_In
declare function PySequence_In(byval o as PyObject ptr, byval value as PyObject ptr) as long
#undef PySequence_In

declare function PySequence_In alias "PySequence_Contains"(byval seq as PyObject ptr, byval ob as PyObject ptr) as long
declare function PySequence_Index(byval o as PyObject ptr, byval value as PyObject ptr) as Py_ssize_t
declare function PySequence_InPlaceConcat(byval o1 as PyObject ptr, byval o2 as PyObject ptr) as PyObject ptr
declare function PySequence_InPlaceRepeat(byval o as PyObject ptr, byval count as Py_ssize_t) as PyObject ptr
declare function PyMapping_Check(byval o as PyObject ptr) as long
declare function PyMapping_Size(byval o as PyObject ptr) as Py_ssize_t
#undef PyMapping_Length
#undef PyMapping_Length
declare function PyMapping_Length(byval o as PyObject ptr) as Py_ssize_t
#undef PyMapping_Length
declare function PyMapping_Length alias "PyMapping_Size"(byval o as PyObject ptr) as Py_ssize_t
#define PyMapping_DelItemString(O, K) PyObject_DelItemString((O), (K))
#define PyMapping_DelItem(O, K) PyObject_DelItem((O), (K))
declare function PyMapping_HasKeyString(byval o as PyObject ptr, byval key as const zstring ptr) as long
declare function PyMapping_HasKey(byval o as PyObject ptr, byval key as PyObject ptr) as long
declare function PyMapping_Keys(byval o as PyObject ptr) as PyObject ptr
declare function PyMapping_Values(byval o as PyObject ptr) as PyObject ptr
declare function PyMapping_Items(byval o as PyObject ptr) as PyObject ptr
declare function PyMapping_GetItemString(byval o as PyObject ptr, byval key as const zstring ptr) as PyObject ptr
declare function PyMapping_SetItemString(byval o as PyObject ptr, byval key as const zstring ptr, byval value as PyObject ptr) as long
declare function PyObject_IsInstance(byval object as PyObject ptr, byval typeorclass as PyObject ptr) as long
declare function PyObject_IsSubclass(byval object as PyObject ptr, byval typeorclass as PyObject ptr) as long
declare sub _Py_add_one_to_index_F(byval nd as long, byval index as Py_ssize_t ptr, byval shape as const Py_ssize_t ptr)
declare sub _Py_add_one_to_index_C(byval nd as long, byval index as Py_ssize_t ptr, byval shape as const Py_ssize_t ptr)
#define Py_BLTINMODULE_H

extern PyFilter_Type as PyTypeObject
extern PyMap_Type as PyTypeObject
extern PyZip_Type as PyTypeObject

#define Py_COMPILE_H
const Py_single_input = 256
const Py_file_input = 257
const Py_eval_input = 258
#define Py_EVAL_H
declare function PyEval_EvalCode(byval as PyObject ptr, byval as PyObject ptr, byval as PyObject ptr) as PyObject ptr
declare function PyEval_EvalCodeEx(byval co as PyObject ptr, byval globals as PyObject ptr, byval locals as PyObject ptr, byval args as PyObject ptr ptr, byval argc as long, byval kwds as PyObject ptr ptr, byval kwdc as long, byval defs as PyObject ptr ptr, byval defc as long, byval kwdefs as PyObject ptr, byval closure as PyObject ptr) as PyObject ptr
#define Py_STRTOD_H
declare function PyOS_string_to_double(byval str as const zstring ptr, byval endptr as zstring ptr ptr, byval overflow_exception as PyObject ptr) as double
declare function PyOS_double_to_string(byval val as double, byval format_code as byte, byval precision as long, byval flags as long, byval type as long ptr) as zstring ptr
const Py_DTSF_SIGN = &h01
const Py_DTSF_ADD_DOT_0 = &h02
const Py_DTSF_ALT = &h04
const Py_DTST_FINITE = 0
const Py_DTST_INFINITE = 1
const Py_DTST_NAN = 2
#define Py_STRCMP_H

declare function PyOS_mystrnicmp(byval as const zstring ptr, byval as const zstring ptr, byval as Py_ssize_t) as long
declare function PyOS_mystricmp(byval as const zstring ptr, byval as const zstring ptr) as long
declare function PyOS_strnicmp alias "PyOS_mystrnicmp"(byval as const zstring ptr, byval as const zstring ptr, byval as Py_ssize_t) as long
declare function PyOS_stricmp alias "PyOS_mystricmp"(byval as const zstring ptr, byval as const zstring ptr) as long
#define Py_FILEUTILS_H
declare function _Py_device_encoding(byval as long) as PyObject ptr
declare function Py_DecodeLocale(byval arg as const zstring ptr, byval size as uinteger ptr) as wstring ptr
declare function Py_EncodeLocale(byval text as const wstring ptr, byval error_pos as uinteger ptr) as zstring ptr
declare function _Py_wfopen(byval path as const wstring ptr, byval mode as const wstring ptr) as FILE ptr
declare function _Py_fopen(byval pathname as const zstring ptr, byval mode as const zstring ptr) as FILE ptr
declare function _Py_fopen_obj(byval path as PyObject ptr, byval mode as const zstring ptr) as FILE ptr
declare function _Py_read(byval fd as long, byval buf as any ptr, byval count as uinteger) as Py_ssize_t
declare function _Py_write(byval fd as long, byval buf as const any ptr, byval count as uinteger) as Py_ssize_t
declare function _Py_write_noraise(byval fd as long, byval buf as const any ptr, byval count as uinteger) as Py_ssize_t
declare function _Py_wreadlink(byval path as const wstring ptr, byval buf as wstring ptr, byval bufsiz_ as uinteger) as long
declare function _Py_wrealpath(byval path as const wstring ptr, byval resolved_path as wstring ptr, byval resolved_path_size as uinteger) as wstring ptr
declare function _Py_wgetcwd(byval buf as wstring ptr, byval size as uinteger) as wstring ptr

#define Py_PYFPE_H
#define PyFPE_START_PROTECT(err_string, leave_stmt)
#define PyFPE_END_PROTECT(v)
#define Py_STRUCTMEMBER_H

type PyMemberDef_
    name as zstring ptr
    as long type
    offset as Py_ssize_t
    flags as long
    doc as zstring ptr
end type

const T_SHORT = 0
const T_INT = 1
const T_LONG = 2
const T_FLOAT = 3
const T_DOUBLE = 4
const T_STRING = 5
const T_OBJECT = 6
const T_CHAR = 7
const T_BYTE = 8
const T_UBYTE = 9
const T_USHORT = 10
const T_UINT = 11
const T_ULONG = 12
const T_STRING_INPLACE = 13
const T_BOOL = 14
const T_OBJECT_EX = 16
const T_LONGLONG = 17
const T_ULONGLONG = 18
const T_PYSSIZET = 19
const T_NONE = 20
const READONLY = 1
const READ_RESTRICTED = 2
const PY_WRITE_RESTRICTED = 4
const RESTRICTED = READ_RESTRICTED or PY_WRITE_RESTRICTED
declare function PyMember_GetOne(byval as const zstring ptr, byval as PyMemberDef ptr) as PyObject ptr
declare function PyMember_SetOne(byval as zstring ptr, byval as PyMemberDef ptr, byval as PyObject ptr) as long
#define Py_NODE_H

type _node_
    n_type as short
    n_str as zstring ptr
    n_lineno as long
    n_col_offset as long
    n_nchildren as long
    n_child as _node ptr
end type

type node as _node
declare function PyNode_New(byval type as long) as node ptr
declare function PyNode_AddChild(byval n as node ptr, byval type as long, byval str as zstring ptr, byval lineno as long, byval col_offset as long) as long
declare sub PyNode_Free(byval n as node ptr)

#define NCH(n) (n)->n_nchildren
#define CHILD(n, i) (@(n)->n_child[i])
#define RCHILD(n, i) CHILD(n, NCH(n) + i)
#define TYPE_(n) (n)->n_type
#define STR_(n) (n)->n_str
#define LINENO(n) (n)->n_lineno
#define REQ(n, type) assert(-(TYPE_(n) = (type)))
declare sub PyNode_ListTree(byval as node ptr)

end extern