Declarations

pytab.py

# c_void_p PyMem_Malloc(c_size_t)
PyMem_Malloc = _dll.PyMem_Malloc
PyMem_Malloc.restype = c_void_p
PyMem_Malloc.argtypes = [ c_size_t ]



# c_void_p PyMem_Realloc(c_void_p, c_size_t)
PyMem_Realloc = _dll.PyMem_Realloc
PyMem_Realloc.restype = c_void_p
PyMem_Realloc.argtypes = [ c_void_p, c_size_t ]



# c_void PyMem_Free(c_void_p)
PyMem_Free = _dll.PyMem_Free
PyMem_Free.restype = c_void
PyMem_Free.argtypes = [ c_void_p ]



# c_int PyType_IsSubtype(PyTypeObject_p, PyTypeObject_p)
PyType_IsSubtype = _dll.PyType_IsSubtype
PyType_IsSubtype.restype = c_int
PyType_IsSubtype.argtypes = [ PyTypeObject_p, PyTypeObject_p ]



# extern PyTypeObject PyType_Type
PyType_Type = PyTypeObject.from_address(_dll.PyType_Type)



# extern PyTypeObject PyBaseObject_Type
PyBaseObject_Type = PyTypeObject.from_address(_dll.PyBaseObject_Type)



# extern PyTypeObject PySuper_Type
PySuper_Type = PyTypeObject.from_address(_dll.PySuper_Type)



# c_int PyType_Ready(PyTypeObject_p)
PyType_Ready = _dll.PyType_Ready
PyType_Ready.restype = c_int
PyType_Ready.argtypes = [ PyTypeObject_p ]



# PyObject_p PyType_GenericAlloc(PyTypeObject_p, Py_ssize_t)
PyType_GenericAlloc = _dll.PyType_GenericAlloc
PyType_GenericAlloc.restype = PyObject_p
PyType_GenericAlloc.argtypes = [ PyTypeObject_p, Py_ssize_t ]



# PyObject_p PyType_GenericNew(PyTypeObject_p, PyObject_p, PyObject_p)
PyType_GenericNew = _dll.PyType_GenericNew
PyType_GenericNew.restype = PyObject_p
PyType_GenericNew.argtypes = [ PyTypeObject_p, PyObject_p, PyObject_p ]



# PyObject_p _PyType_Lookup(PyTypeObject_p, PyObject_p)
_PyType_Lookup = _dll._PyType_Lookup
_PyType_Lookup.restype = PyObject_p
_PyType_Lookup.argtypes = [ PyTypeObject_p, PyObject_p ]



# PyObject_p _PyObject_LookupSpecial(PyObject_p, char_p, PyObject_p_p)
_PyObject_LookupSpecial = _dll._PyObject_LookupSpecial
_PyObject_LookupSpecial.restype = PyObject_p
_PyObject_LookupSpecial.argtypes = [ PyObject_p, char_p, PyObject_p_p ]



# c_uint PyType_ClearCache(c_void)
PyType_ClearCache = _dll.PyType_ClearCache
PyType_ClearCache.restype = c_uint
PyType_ClearCache.argtypes = [ c_void ]



# c_void PyType_Modified(PyTypeObject_p)
PyType_Modified = _dll.PyType_Modified
PyType_Modified.restype = c_void
PyType_Modified.argtypes = [ PyTypeObject_p ]



# c_int PyObject_Prc_int(PyObject_p, FILE_p, c_int)
PyObject_Prc_int = _dll.PyObject_Prc_int
PyObject_Prc_int.restype = c_int
PyObject_Prc_int.argtypes = [ PyObject_p, FILE_p, c_int ]



# c_void _PyObject_Dump(PyObject_p)
_PyObject_Dump = _dll._PyObject_Dump
_PyObject_Dump.restype = c_void
_PyObject_Dump.argtypes = [ PyObject_p ]



# PyObject_p PyObject_Repr(PyObject_p)
PyObject_Repr = _dll.PyObject_Repr
PyObject_Repr.restype = PyObject_p
PyObject_Repr.argtypes = [ PyObject_p ]



# PyObject_p _PyObject_Str(PyObject_p)
_PyObject_Str = _dll._PyObject_Str
_PyObject_Str.restype = PyObject_p
_PyObject_Str.argtypes = [ PyObject_p ]



# PyObject_p PyObject_Str(PyObject_p)
PyObject_Str = _dll.PyObject_Str
PyObject_Str.restype = PyObject_p
PyObject_Str.argtypes = [ PyObject_p ]



# PyObject_p PyObject_Unicode(PyObject_p)
PyObject_Unicode = _dll.PyObject_Unicode
PyObject_Unicode.restype = PyObject_p
PyObject_Unicode.argtypes = [ PyObject_p ]



# c_int PyObject_Compare(PyObject_p, PyObject_p)
PyObject_Compare = _dll.PyObject_Compare
PyObject_Compare.restype = c_int
PyObject_Compare.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyObject_RichCompare(PyObject_p, PyObject_p, c_int)
PyObject_RichCompare = _dll.PyObject_RichCompare
PyObject_RichCompare.restype = PyObject_p
PyObject_RichCompare.argtypes = [ PyObject_p, PyObject_p, c_int ]



# c_int PyObject_RichCompareBool(PyObject_p, PyObject_p, c_int)
PyObject_RichCompareBool = _dll.PyObject_RichCompareBool
PyObject_RichCompareBool.restype = c_int
PyObject_RichCompareBool.argtypes = [ PyObject_p, PyObject_p, c_int ]



# PyObject_p PyObject_GetAttrString(PyObject_p, char_p)
PyObject_GetAttrString = _dll.PyObject_GetAttrString
PyObject_GetAttrString.restype = PyObject_p
PyObject_GetAttrString.argtypes = [ PyObject_p, char_p ]



# c_int PyObject_SetAttrString(PyObject_p, char_p, PyObject_p)
PyObject_SetAttrString = _dll.PyObject_SetAttrString
PyObject_SetAttrString.restype = c_int
PyObject_SetAttrString.argtypes = [ PyObject_p, char_p, PyObject_p ]



# c_int PyObject_HasAttrString(PyObject_p, char_p)
PyObject_HasAttrString = _dll.PyObject_HasAttrString
PyObject_HasAttrString.restype = c_int
PyObject_HasAttrString.argtypes = [ PyObject_p, char_p ]



# PyObject_p PyObject_GetAttr(PyObject_p, PyObject_p)
PyObject_GetAttr = _dll.PyObject_GetAttr
PyObject_GetAttr.restype = PyObject_p
PyObject_GetAttr.argtypes = [ PyObject_p, PyObject_p ]



# c_int PyObject_SetAttr(PyObject_p, PyObject_p, PyObject_p)
PyObject_SetAttr = _dll.PyObject_SetAttr
PyObject_SetAttr.restype = c_int
PyObject_SetAttr.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# c_int PyObject_HasAttr(PyObject_p, PyObject_p)
PyObject_HasAttr = _dll.PyObject_HasAttr
PyObject_HasAttr.restype = c_int
PyObject_HasAttr.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p_p _PyObject_GetDictPtr(PyObject_p)
_PyObject_GetDictPtr = _dll._PyObject_GetDictPtr
_PyObject_GetDictPtr.restype = PyObject_p_p
_PyObject_GetDictPtr.argtypes = [ PyObject_p ]



# PyObject_p PyObject_SelfIter(PyObject_p)
PyObject_SelfIter = _dll.PyObject_SelfIter
PyObject_SelfIter.restype = PyObject_p
PyObject_SelfIter.argtypes = [ PyObject_p ]



# PyObject_p _PyObject_NextNotImplemented(PyObject_p)
_PyObject_NextNotImplemented = _dll._PyObject_NextNotImplemented
_PyObject_NextNotImplemented.restype = PyObject_p
_PyObject_NextNotImplemented.argtypes = [ PyObject_p ]



# PyObject_p PyObject_GenericGetAttr(PyObject_p, PyObject_p)
PyObject_GenericGetAttr = _dll.PyObject_GenericGetAttr
PyObject_GenericGetAttr.restype = PyObject_p
PyObject_GenericGetAttr.argtypes = [ PyObject_p, PyObject_p ]



# c_int PyObject_GenericSetAttr(PyObject_p, PyObject_p, PyObject_p)
PyObject_GenericSetAttr = _dll.PyObject_GenericSetAttr
PyObject_GenericSetAttr.restype = c_int
PyObject_GenericSetAttr.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# c_long PyObject_Hash(PyObject_p)
PyObject_Hash = _dll.PyObject_Hash
PyObject_Hash.restype = c_long
PyObject_Hash.argtypes = [ PyObject_p ]



# c_long PyObject_HashNotImplemented(PyObject_p)
PyObject_HashNotImplemented = _dll.PyObject_HashNotImplemented
PyObject_HashNotImplemented.restype = c_long
PyObject_HashNotImplemented.argtypes = [ PyObject_p ]



# c_int PyObject_IsTrue(PyObject_p)
PyObject_IsTrue = _dll.PyObject_IsTrue
PyObject_IsTrue.restype = c_int
PyObject_IsTrue.argtypes = [ PyObject_p ]



# c_int PyObject_Not(PyObject_p)
PyObject_Not = _dll.PyObject_Not
PyObject_Not.restype = c_int
PyObject_Not.argtypes = [ PyObject_p ]



# c_int PyCallable_Check(PyObject_p)
PyCallable_Check = _dll.PyCallable_Check
PyCallable_Check.restype = c_int
PyCallable_Check.argtypes = [ PyObject_p ]



# c_int PyNumber_Coerce(PyObject_p_p, PyObject_p_p)
PyNumber_Coerce = _dll.PyNumber_Coerce
PyNumber_Coerce.restype = c_int
PyNumber_Coerce.argtypes = [ PyObject_p_p, PyObject_p_p ]



# c_int PyNumber_CoerceEx(PyObject_p_p, PyObject_p_p)
PyNumber_CoerceEx = _dll.PyNumber_CoerceEx
PyNumber_CoerceEx.restype = c_int
PyNumber_CoerceEx.argtypes = [ PyObject_p_p, PyObject_p_p ]



# c_void PyObject_ClearWeakRefs(PyObject_p)
PyObject_ClearWeakRefs = _dll.PyObject_ClearWeakRefs
PyObject_ClearWeakRefs.restype = c_void
PyObject_ClearWeakRefs.argtypes = [ PyObject_p ]



# PyObject_p _PyObject_GenericGetAttrWithDict(PyObject_p, PyObject_p, PyObject_p)
_PyObject_GenericGetAttrWithDict = _dll._PyObject_GenericGetAttrWithDict
_PyObject_GenericGetAttrWithDict.restype = PyObject_p
_PyObject_GenericGetAttrWithDict.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# c_int _PyObject_GenericSetAttrWithDict(PyObject_p, PyObject_p, PyObject_p, PyObject_p)
_PyObject_GenericSetAttrWithDict = _dll._PyObject_GenericSetAttrWithDict
_PyObject_GenericSetAttrWithDict.restype = c_int
_PyObject_GenericSetAttrWithDict.argtypes = [ PyObject_p, PyObject_p, PyObject_p, PyObject_p ]



# PyObject_p PyObject_Dir(PyObject_p)
PyObject_Dir = _dll.PyObject_Dir
PyObject_Dir.restype = PyObject_p
PyObject_Dir.argtypes = [ PyObject_p ]



# c_int Py_ReprEnter(PyObject_p)
Py_ReprEnter = _dll.Py_ReprEnter
Py_ReprEnter.restype = c_int
Py_ReprEnter.argtypes = [ PyObject_p ]



# c_void Py_ReprLeave(PyObject_p)
Py_ReprLeave = _dll.Py_ReprLeave
Py_ReprLeave.restype = c_void
Py_ReprLeave.argtypes = [ PyObject_p ]



# c_long _Py_HashDouble(double)
_Py_HashDouble = _dll._Py_HashDouble
_Py_HashDouble.restype = c_long
_Py_HashDouble.argtypes = [ double ]



# c_long _Py_HashPoc_inter(c_void_p)
_Py_HashPoc_inter = _dll._Py_HashPoc_inter
_Py_HashPoc_inter.restype = c_long
_Py_HashPoc_inter.argtypes = [ c_void_p ]



# c_void Py_IncRef(PyObject_p)
Py_IncRef = _dll.Py_IncRef
Py_IncRef.restype = c_void
Py_IncRef.argtypes = [ PyObject_p ]



# c_void Py_DecRef(PyObject_p)
Py_DecRef = _dll.Py_DecRef
Py_DecRef.restype = c_void
Py_DecRef.argtypes = [ PyObject_p ]



# extern PyObject _Py_NoneStruct
_Py_NoneStruct = PyObject.from_address(_dll._Py_NoneStruct)



# extern PyObject _Py_NotImplementedStruct
_Py_NotImplementedStruct = PyObject.from_address(_dll._Py_NotImplementedStruct)



# c_void _PyTrash_deposit_object(PyObject_p)
_PyTrash_deposit_object = _dll._PyTrash_deposit_object
_PyTrash_deposit_object.restype = c_void
_PyTrash_deposit_object.argtypes = [ PyObject_p ]



# c_void _PyTrash_destroy_chain(c_void)
_PyTrash_destroy_chain = _dll._PyTrash_destroy_chain
_PyTrash_destroy_chain.restype = c_void
_PyTrash_destroy_chain.argtypes = [ c_void ]



# extern c_int _PyTrash_delete_nesting
_PyTrash_delete_nesting = c_int.from_address(_dll._PyTrash_delete_nesting)



# extern PyObject_p _PyTrash_delete_later
_PyTrash_delete_later = PyObject_p.from_address(_dll._PyTrash_delete_later)



# c_void_p PyObject_Malloc(c_size_t)
PyObject_Malloc = _dll.PyObject_Malloc
PyObject_Malloc.restype = c_void_p
PyObject_Malloc.argtypes = [ c_size_t ]



# c_void_p PyObject_Realloc(c_void_p, c_size_t)
PyObject_Realloc = _dll.PyObject_Realloc
PyObject_Realloc.restype = c_void_p
PyObject_Realloc.argtypes = [ c_void_p, c_size_t ]



# c_void PyObject_Free(c_void_p)
PyObject_Free = _dll.PyObject_Free
PyObject_Free.restype = c_void
PyObject_Free.argtypes = [ c_void_p ]



# PyObject_p PyObject_Init(PyObject_p, PyTypeObject_p)
PyObject_Init = _dll.PyObject_Init
PyObject_Init.restype = PyObject_p
PyObject_Init.argtypes = [ PyObject_p, PyTypeObject_p ]



# PyVarObject_p PyObject_InitVar(PyVarObject_p, PyTypeObject_p, Py_ssize_t)
PyObject_InitVar = _dll.PyObject_InitVar
PyObject_InitVar.restype = PyVarObject_p
PyObject_InitVar.argtypes = [ PyVarObject_p, PyTypeObject_p, Py_ssize_t ]



# PyObject_p _PyObject_New(PyTypeObject_p)
_PyObject_New = _dll._PyObject_New
_PyObject_New.restype = PyObject_p
_PyObject_New.argtypes = [ PyTypeObject_p ]



# PyVarObject_p _PyObject_NewVar(PyTypeObject_p, Py_ssize_t)
_PyObject_NewVar = _dll._PyObject_NewVar
_PyObject_NewVar.restype = PyVarObject_p
_PyObject_NewVar.argtypes = [ PyTypeObject_p, Py_ssize_t ]



# Py_ssize_t PyGC_Collect(c_void)
PyGC_Collect = _dll.PyGC_Collect
PyGC_Collect.restype = Py_ssize_t
PyGC_Collect.argtypes = [ c_void ]



# PyVarObject_p _PyObject_GC_Resize(PyVarObject_p, Py_ssize_t)
_PyObject_GC_Resize = _dll._PyObject_GC_Resize
_PyObject_GC_Resize.restype = PyVarObject_p
_PyObject_GC_Resize.argtypes = [ PyVarObject_p, Py_ssize_t ]



# PyObject_p _PyObject_GC_Malloc(c_size_t)
_PyObject_GC_Malloc = _dll._PyObject_GC_Malloc
_PyObject_GC_Malloc.restype = PyObject_p
_PyObject_GC_Malloc.argtypes = [ c_size_t ]



# PyObject_p _PyObject_GC_New(PyTypeObject_p)
_PyObject_GC_New = _dll._PyObject_GC_New
_PyObject_GC_New.restype = PyObject_p
_PyObject_GC_New.argtypes = [ PyTypeObject_p ]



# PyVarObject_p _PyObject_GC_NewVar(PyTypeObject_p, Py_ssize_t)
_PyObject_GC_NewVar = _dll._PyObject_GC_NewVar
_PyObject_GC_NewVar.restype = PyVarObject_p
_PyObject_GC_NewVar.argtypes = [ PyTypeObject_p, Py_ssize_t ]



# c_void PyObject_GC_Track(c_void_p)
PyObject_GC_Track = _dll.PyObject_GC_Track
PyObject_GC_Track.restype = c_void
PyObject_GC_Track.argtypes = [ c_void_p ]



# c_void PyObject_GC_UnTrack(c_void_p)
PyObject_GC_UnTrack = _dll.PyObject_GC_UnTrack
PyObject_GC_UnTrack.restype = c_void
PyObject_GC_UnTrack.argtypes = [ c_void_p ]



# c_void PyObject_GC_Del(c_void_p)
PyObject_GC_Del = _dll.PyObject_GC_Del
PyObject_GC_Del.restype = c_void
PyObject_GC_Del.argtypes = [ c_void_p ]



# extern c_int Py_DebugFlag
Py_DebugFlag = c_int.from_address(_dll.Py_DebugFlag)



# extern c_int Py_VerboseFlag
Py_VerboseFlag = c_int.from_address(_dll.Py_VerboseFlag)



# extern c_int Py_c_interactiveFlag
Py_c_interactiveFlag = c_int.from_address(_dll.Py_c_interactiveFlag)



# extern c_int Py_InspectFlag
Py_InspectFlag = c_int.from_address(_dll.Py_InspectFlag)



# extern c_int Py_OptimizeFlag
Py_OptimizeFlag = c_int.from_address(_dll.Py_OptimizeFlag)



# extern c_int Py_NoSiteFlag
Py_NoSiteFlag = c_int.from_address(_dll.Py_NoSiteFlag)



# extern c_int Py_BytesWarningFlag
Py_BytesWarningFlag = c_int.from_address(_dll.Py_BytesWarningFlag)



# extern c_int Py_UseClassExceptionsFlag
Py_UseClassExceptionsFlag = c_int.from_address(_dll.Py_UseClassExceptionsFlag)



# extern c_int Py_FrozenFlag
Py_FrozenFlag = c_int.from_address(_dll.Py_FrozenFlag)



# extern c_int Py_TabcheckFlag
Py_TabcheckFlag = c_int.from_address(_dll.Py_TabcheckFlag)



# extern c_int Py_UnicodeFlag
Py_UnicodeFlag = c_int.from_address(_dll.Py_UnicodeFlag)



# extern c_int Py_IgnoreEnvironmentFlag
Py_IgnoreEnvironmentFlag = c_int.from_address(_dll.Py_IgnoreEnvironmentFlag)



# extern c_int Py_DivisionWarningFlag
Py_DivisionWarningFlag = c_int.from_address(_dll.Py_DivisionWarningFlag)



# extern c_int Py_DontWriteBytecodeFlag
Py_DontWriteBytecodeFlag = c_int.from_address(_dll.Py_DontWriteBytecodeFlag)



# extern c_int Py_NoUserSiteDirectory
Py_NoUserSiteDirectory = c_int.from_address(_dll.Py_NoUserSiteDirectory)



# extern c_int _Py_QnewFlag
_Py_QnewFlag = c_int.from_address(_dll._Py_QnewFlag)



# extern c_int Py_Py3kWarningFlag
Py_Py3kWarningFlag = c_int.from_address(_dll.Py_Py3kWarningFlag)



# c_void Py_FatalError(char_pmessage)
Py_FatalError = _dll.Py_FatalError
Py_FatalError.restype = c_void
Py_FatalError.argtypes = [ char_pmessage ]



# extern PyTypeObject PyUnicode_Type
PyUnicode_Type = PyTypeObject.from_address(_dll.PyUnicode_Type)



# PyObject_p PyUnicodeUCS2_FromUnicode( Py_UNICODE_pu, Py_ssize_t size )
PyUnicodeUCS2_FromUnicode = _dll.PyUnicodeUCS2_FromUnicode
PyUnicodeUCS2_FromUnicode.restype = PyObject_p
PyUnicodeUCS2_FromUnicode.argtypes = [  Py_UNICODE_pu, Py_ssize_t size  ]



# PyObject_p PyUnicodeUCS2_FromStringAndSize( char_pu, Py_ssize_t size )
PyUnicodeUCS2_FromStringAndSize = _dll.PyUnicodeUCS2_FromStringAndSize
PyUnicodeUCS2_FromStringAndSize.restype = PyObject_p
PyUnicodeUCS2_FromStringAndSize.argtypes = [  char_pu, Py_ssize_t size  ]



# PyObject_p PyUnicodeUCS2_FromString( char_pu )
PyUnicodeUCS2_FromString = _dll.PyUnicodeUCS2_FromString
PyUnicodeUCS2_FromString.restype = PyObject_p
PyUnicodeUCS2_FromString.argtypes = [  char_pu  ]



# Py_UNICODE_p PyUnicodeUCS2_AsUnicode( PyObject_punicode )
PyUnicodeUCS2_AsUnicode = _dll.PyUnicodeUCS2_AsUnicode
PyUnicodeUCS2_AsUnicode.restype = Py_UNICODE_p
PyUnicodeUCS2_AsUnicode.argtypes = [  PyObject_punicode  ]



# Py_ssize_t PyUnicodeUCS2_GetSize( PyObject_punicode )
PyUnicodeUCS2_GetSize = _dll.PyUnicodeUCS2_GetSize
PyUnicodeUCS2_GetSize.restype = Py_ssize_t
PyUnicodeUCS2_GetSize.argtypes = [  PyObject_punicode  ]



# Py_UNICODE PyUnicodeUCS2_GetMax(c_void)
PyUnicodeUCS2_GetMax = _dll.PyUnicodeUCS2_GetMax
PyUnicodeUCS2_GetMax.restype = Py_UNICODE
PyUnicodeUCS2_GetMax.argtypes = [ c_void ]



# c_int PyUnicodeUCS2_Resize( PyObject_p_punicode, Py_ssize_t length )
PyUnicodeUCS2_Resize = _dll.PyUnicodeUCS2_Resize
PyUnicodeUCS2_Resize.restype = c_int
PyUnicodeUCS2_Resize.argtypes = [  PyObject_p_punicode, Py_ssize_t length  ]



# PyObject_p PyUnicodeUCS2_FromEncodedObject( register PyObject_pobj, char_pencoding, char_perrors )
PyUnicodeUCS2_FromEncodedObject = _dll.PyUnicodeUCS2_FromEncodedObject
PyUnicodeUCS2_FromEncodedObject.restype = PyObject_p
PyUnicodeUCS2_FromEncodedObject.argtypes = [  register PyObject_pobj, char_pencoding, char_perrors  ]



# PyObject_p PyUnicodeUCS2_FromObject( register PyObject_pobj )
PyUnicodeUCS2_FromObject = _dll.PyUnicodeUCS2_FromObject
PyUnicodeUCS2_FromObject.restype = PyObject_p
PyUnicodeUCS2_FromObject.argtypes = [  register PyObject_pobj  ]



# PyObject_p PyUnicodeUCS2_FromFormatV(char_p, va_list)
PyUnicodeUCS2_FromFormatV = _dll.PyUnicodeUCS2_FromFormatV
PyUnicodeUCS2_FromFormatV.restype = PyObject_p
PyUnicodeUCS2_FromFormatV.argtypes = [ char_p, va_list ]



# PyObject_p PyUnicodeUCS2_FromFormat(char_p, ...)
PyUnicodeUCS2_FromFormat = _dll.PyUnicodeUCS2_FromFormat
PyUnicodeUCS2_FromFormat.restype = PyObject_p
PyUnicodeUCS2_FromFormat.argtypes = [ char_p, ... ]



# PyObject_p _PyUnicode_FormatAdvanced(PyObject_pobj, Py_UNICODE_pformat_spec, Py_ssize_t format_spec_len)
_PyUnicode_FormatAdvanced = _dll._PyUnicode_FormatAdvanced
_PyUnicode_FormatAdvanced.restype = PyObject_p
_PyUnicode_FormatAdvanced.argtypes = [ PyObject_pobj, Py_UNICODE_pformat_spec, Py_ssize_t format_spec_len ]



# PyObject_p PyUnicodeUCS2_FromWideChar( register wchar_t_pw, Py_ssize_t size )
PyUnicodeUCS2_FromWideChar = _dll.PyUnicodeUCS2_FromWideChar
PyUnicodeUCS2_FromWideChar.restype = PyObject_p
PyUnicodeUCS2_FromWideChar.argtypes = [  register wchar_t_pw, Py_ssize_t size  ]



# Py_ssize_t PyUnicodeUCS2_AsWideChar( PyUnicodeObject_punicode, register wchar_t_pw, Py_ssize_t size )
PyUnicodeUCS2_AsWideChar = _dll.PyUnicodeUCS2_AsWideChar
PyUnicodeUCS2_AsWideChar.restype = Py_ssize_t
PyUnicodeUCS2_AsWideChar.argtypes = [  PyUnicodeObject_punicode, register wchar_t_pw, Py_ssize_t size  ]



# PyObject_p PyUnicodeUCS2_FromOrdinal(c_int ordinal)
PyUnicodeUCS2_FromOrdinal = _dll.PyUnicodeUCS2_FromOrdinal
PyUnicodeUCS2_FromOrdinal.restype = PyObject_p
PyUnicodeUCS2_FromOrdinal.argtypes = [ c_int ordinal ]



# c_int PyUnicodeUCS2_ClearFreelist(c_void)
PyUnicodeUCS2_ClearFreelist = _dll.PyUnicodeUCS2_ClearFreelist
PyUnicodeUCS2_ClearFreelist.restype = c_int
PyUnicodeUCS2_ClearFreelist.argtypes = [ c_void ]



# PyObject_p _PyUnicodeUCS2_AsDefaultEncodedString( PyObject_p, char_p)
_PyUnicodeUCS2_AsDefaultEncodedString = _dll._PyUnicodeUCS2_AsDefaultEncodedString
_PyUnicodeUCS2_AsDefaultEncodedString.restype = PyObject_p
_PyUnicodeUCS2_AsDefaultEncodedString.argtypes = [  PyObject_p, char_p ]



# char_p PyUnicodeUCS2_GetDefaultEncoding(c_void)
PyUnicodeUCS2_GetDefaultEncoding = _dll.PyUnicodeUCS2_GetDefaultEncoding
PyUnicodeUCS2_GetDefaultEncoding.restype = char_p
PyUnicodeUCS2_GetDefaultEncoding.argtypes = [ c_void ]



# c_int PyUnicodeUCS2_SetDefaultEncoding( char_pencoding )
PyUnicodeUCS2_SetDefaultEncoding = _dll.PyUnicodeUCS2_SetDefaultEncoding
PyUnicodeUCS2_SetDefaultEncoding.restype = c_int
PyUnicodeUCS2_SetDefaultEncoding.argtypes = [  char_pencoding  ]



# PyObject_p PyUnicodeUCS2_Decode( char_ps, Py_ssize_t size, char_pencoding, char_perrors )
PyUnicodeUCS2_Decode = _dll.PyUnicodeUCS2_Decode
PyUnicodeUCS2_Decode.restype = PyObject_p
PyUnicodeUCS2_Decode.argtypes = [  char_ps, Py_ssize_t size, char_pencoding, char_perrors  ]



# PyObject_p PyUnicodeUCS2_Encode( Py_UNICODE_ps, Py_ssize_t size, char_pencoding, char_perrors )
PyUnicodeUCS2_Encode = _dll.PyUnicodeUCS2_Encode
PyUnicodeUCS2_Encode.restype = PyObject_p
PyUnicodeUCS2_Encode.argtypes = [  Py_UNICODE_ps, Py_ssize_t size, char_pencoding, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsEncodedObject( PyObject_punicode, char_pencoding, char_perrors )
PyUnicodeUCS2_AsEncodedObject = _dll.PyUnicodeUCS2_AsEncodedObject
PyUnicodeUCS2_AsEncodedObject.restype = PyObject_p
PyUnicodeUCS2_AsEncodedObject.argtypes = [  PyObject_punicode, char_pencoding, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsEncodedString( PyObject_punicode, char_pencoding, char_perrors )
PyUnicodeUCS2_AsEncodedString = _dll.PyUnicodeUCS2_AsEncodedString
PyUnicodeUCS2_AsEncodedString.restype = PyObject_p
PyUnicodeUCS2_AsEncodedString.argtypes = [  PyObject_punicode, char_pencoding, char_perrors  ]



# PyObject_p PyUnicode_BuildEncodingMap( PyObject_p string )
PyUnicode_BuildEncodingMap = _dll.PyUnicode_BuildEncodingMap
PyUnicode_BuildEncodingMap.restype = PyObject_p
PyUnicode_BuildEncodingMap.argtypes = [  PyObject_p string  ]



# PyObject_p PyUnicode_DecodeUTF7( char_pstring, Py_ssize_t length, char_perrors )
PyUnicode_DecodeUTF7 = _dll.PyUnicode_DecodeUTF7
PyUnicode_DecodeUTF7.restype = PyObject_p
PyUnicode_DecodeUTF7.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicode_DecodeUTF7Stateful( char_pstring, Py_ssize_t length, char_perrors, Py_ssize_t_pconsumed )
PyUnicode_DecodeUTF7Stateful = _dll.PyUnicode_DecodeUTF7Stateful
PyUnicode_DecodeUTF7Stateful.restype = PyObject_p
PyUnicode_DecodeUTF7Stateful.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, Py_ssize_t_pconsumed  ]



# PyObject_p PyUnicode_EncodeUTF7( Py_UNICODE_pdata, Py_ssize_t length, c_int base64SetO, c_int base64WhiteSpace, char_perrors )
PyUnicode_EncodeUTF7 = _dll.PyUnicode_EncodeUTF7
PyUnicode_EncodeUTF7.restype = PyObject_p
PyUnicode_EncodeUTF7.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, c_int base64SetO, c_int base64WhiteSpace, char_perrors  ]



# PyObject_p PyUnicodeUCS2_DecodeUTF8( char_pstring, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_DecodeUTF8 = _dll.PyUnicodeUCS2_DecodeUTF8
PyUnicodeUCS2_DecodeUTF8.restype = PyObject_p
PyUnicodeUCS2_DecodeUTF8.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_DecodeUTF8Stateful( char_pstring, Py_ssize_t length, char_perrors, Py_ssize_t_pconsumed )
PyUnicodeUCS2_DecodeUTF8Stateful = _dll.PyUnicodeUCS2_DecodeUTF8Stateful
PyUnicodeUCS2_DecodeUTF8Stateful.restype = PyObject_p
PyUnicodeUCS2_DecodeUTF8Stateful.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, Py_ssize_t_pconsumed  ]



# PyObject_p PyUnicodeUCS2_AsUTF8String( PyObject_punicode )
PyUnicodeUCS2_AsUTF8String = _dll.PyUnicodeUCS2_AsUTF8String
PyUnicodeUCS2_AsUTF8String.restype = PyObject_p
PyUnicodeUCS2_AsUTF8String.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeUTF8( Py_UNICODE_pdata, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_EncodeUTF8 = _dll.PyUnicodeUCS2_EncodeUTF8
PyUnicodeUCS2_EncodeUTF8.restype = PyObject_p
PyUnicodeUCS2_EncodeUTF8.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_DecodeUTF32( char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder )
PyUnicodeUCS2_DecodeUTF32 = _dll.PyUnicodeUCS2_DecodeUTF32
PyUnicodeUCS2_DecodeUTF32.restype = PyObject_p
PyUnicodeUCS2_DecodeUTF32.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder  ]



# PyObject_p PyUnicodeUCS2_DecodeUTF32Stateful( char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder, Py_ssize_t_pconsumed )
PyUnicodeUCS2_DecodeUTF32Stateful = _dll.PyUnicodeUCS2_DecodeUTF32Stateful
PyUnicodeUCS2_DecodeUTF32Stateful.restype = PyObject_p
PyUnicodeUCS2_DecodeUTF32Stateful.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder, Py_ssize_t_pconsumed  ]



# PyObject_p PyUnicodeUCS2_AsUTF32String( PyObject_punicode )
PyUnicodeUCS2_AsUTF32String = _dll.PyUnicodeUCS2_AsUTF32String
PyUnicodeUCS2_AsUTF32String.restype = PyObject_p
PyUnicodeUCS2_AsUTF32String.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeUTF32( Py_UNICODE_pdata, Py_ssize_t length, char_perrors, c_int byteorder )
PyUnicodeUCS2_EncodeUTF32 = _dll.PyUnicodeUCS2_EncodeUTF32
PyUnicodeUCS2_EncodeUTF32.restype = PyObject_p
PyUnicodeUCS2_EncodeUTF32.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, char_perrors, c_int byteorder  ]



# PyObject_p PyUnicodeUCS2_DecodeUTF16( char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder )
PyUnicodeUCS2_DecodeUTF16 = _dll.PyUnicodeUCS2_DecodeUTF16
PyUnicodeUCS2_DecodeUTF16.restype = PyObject_p
PyUnicodeUCS2_DecodeUTF16.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder  ]



# PyObject_p PyUnicodeUCS2_DecodeUTF16Stateful( char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder, Py_ssize_t_pconsumed )
PyUnicodeUCS2_DecodeUTF16Stateful = _dll.PyUnicodeUCS2_DecodeUTF16Stateful
PyUnicodeUCS2_DecodeUTF16Stateful.restype = PyObject_p
PyUnicodeUCS2_DecodeUTF16Stateful.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, c_int_pbyteorder, Py_ssize_t_pconsumed  ]



# PyObject_p PyUnicodeUCS2_AsUTF16String( PyObject_punicode )
PyUnicodeUCS2_AsUTF16String = _dll.PyUnicodeUCS2_AsUTF16String
PyUnicodeUCS2_AsUTF16String.restype = PyObject_p
PyUnicodeUCS2_AsUTF16String.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeUTF16( Py_UNICODE_pdata, Py_ssize_t length, char_perrors, c_int byteorder )
PyUnicodeUCS2_EncodeUTF16 = _dll.PyUnicodeUCS2_EncodeUTF16
PyUnicodeUCS2_EncodeUTF16.restype = PyObject_p
PyUnicodeUCS2_EncodeUTF16.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, char_perrors, c_int byteorder  ]



# PyObject_p PyUnicodeUCS2_DecodeUnicodeEscape( char_pstring, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_DecodeUnicodeEscape = _dll.PyUnicodeUCS2_DecodeUnicodeEscape
PyUnicodeUCS2_DecodeUnicodeEscape.restype = PyObject_p
PyUnicodeUCS2_DecodeUnicodeEscape.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsUnicodeEscapeString( PyObject_punicode )
PyUnicodeUCS2_AsUnicodeEscapeString = _dll.PyUnicodeUCS2_AsUnicodeEscapeString
PyUnicodeUCS2_AsUnicodeEscapeString.restype = PyObject_p
PyUnicodeUCS2_AsUnicodeEscapeString.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeUnicodeEscape( Py_UNICODE_pdata, Py_ssize_t length )
PyUnicodeUCS2_EncodeUnicodeEscape = _dll.PyUnicodeUCS2_EncodeUnicodeEscape
PyUnicodeUCS2_EncodeUnicodeEscape.restype = PyObject_p
PyUnicodeUCS2_EncodeUnicodeEscape.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length  ]



# PyObject_p PyUnicodeUCS2_DecodeRawUnicodeEscape( char_pstring, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_DecodeRawUnicodeEscape = _dll.PyUnicodeUCS2_DecodeRawUnicodeEscape
PyUnicodeUCS2_DecodeRawUnicodeEscape.restype = PyObject_p
PyUnicodeUCS2_DecodeRawUnicodeEscape.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsRawUnicodeEscapeString( PyObject_punicode )
PyUnicodeUCS2_AsRawUnicodeEscapeString = _dll.PyUnicodeUCS2_AsRawUnicodeEscapeString
PyUnicodeUCS2_AsRawUnicodeEscapeString.restype = PyObject_p
PyUnicodeUCS2_AsRawUnicodeEscapeString.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeRawUnicodeEscape( Py_UNICODE_pdata, Py_ssize_t length )
PyUnicodeUCS2_EncodeRawUnicodeEscape = _dll.PyUnicodeUCS2_EncodeRawUnicodeEscape
PyUnicodeUCS2_EncodeRawUnicodeEscape.restype = PyObject_p
PyUnicodeUCS2_EncodeRawUnicodeEscape.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length  ]



# PyObject_p PyUnicodeUCS2_DecodeLatin1( char_pstring, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_DecodeLatin1 = _dll.PyUnicodeUCS2_DecodeLatin1
PyUnicodeUCS2_DecodeLatin1.restype = PyObject_p
PyUnicodeUCS2_DecodeLatin1.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsLatin1String( PyObject_punicode )
PyUnicodeUCS2_AsLatin1String = _dll.PyUnicodeUCS2_AsLatin1String
PyUnicodeUCS2_AsLatin1String.restype = PyObject_p
PyUnicodeUCS2_AsLatin1String.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeLatin1( Py_UNICODE_pdata, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_EncodeLatin1 = _dll.PyUnicodeUCS2_EncodeLatin1
PyUnicodeUCS2_EncodeLatin1.restype = PyObject_p
PyUnicodeUCS2_EncodeLatin1.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_DecodeASCII( char_pstring, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_DecodeASCII = _dll.PyUnicodeUCS2_DecodeASCII
PyUnicodeUCS2_DecodeASCII.restype = PyObject_p
PyUnicodeUCS2_DecodeASCII.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsASCIIString( PyObject_punicode )
PyUnicodeUCS2_AsASCIIString = _dll.PyUnicodeUCS2_AsASCIIString
PyUnicodeUCS2_AsASCIIString.restype = PyObject_p
PyUnicodeUCS2_AsASCIIString.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicodeUCS2_EncodeASCII( Py_UNICODE_pdata, Py_ssize_t length, char_perrors )
PyUnicodeUCS2_EncodeASCII = _dll.PyUnicodeUCS2_EncodeASCII
PyUnicodeUCS2_EncodeASCII.restype = PyObject_p
PyUnicodeUCS2_EncodeASCII.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicodeUCS2_DecodeCharmap( char_pstring, Py_ssize_t length, PyObject_pmapping, char_perrors )
PyUnicodeUCS2_DecodeCharmap = _dll.PyUnicodeUCS2_DecodeCharmap
PyUnicodeUCS2_DecodeCharmap.restype = PyObject_p
PyUnicodeUCS2_DecodeCharmap.argtypes = [  char_pstring, Py_ssize_t length, PyObject_pmapping, char_perrors  ]



# PyObject_p PyUnicodeUCS2_AsCharmapString( PyObject_punicode, PyObject_pmapping )
PyUnicodeUCS2_AsCharmapString = _dll.PyUnicodeUCS2_AsCharmapString
PyUnicodeUCS2_AsCharmapString.restype = PyObject_p
PyUnicodeUCS2_AsCharmapString.argtypes = [  PyObject_punicode, PyObject_pmapping  ]



# PyObject_p PyUnicodeUCS2_EncodeCharmap( Py_UNICODE_pdata, Py_ssize_t length, PyObject_pmapping, char_perrors )
PyUnicodeUCS2_EncodeCharmap = _dll.PyUnicodeUCS2_EncodeCharmap
PyUnicodeUCS2_EncodeCharmap.restype = PyObject_p
PyUnicodeUCS2_EncodeCharmap.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, PyObject_pmapping, char_perrors  ]



# PyObject_p PyUnicodeUCS2_TranslateCharmap( Py_UNICODE_pdata, Py_ssize_t length, PyObject_ptable, char_perrors )
PyUnicodeUCS2_TranslateCharmap = _dll.PyUnicodeUCS2_TranslateCharmap
PyUnicodeUCS2_TranslateCharmap.restype = PyObject_p
PyUnicodeUCS2_TranslateCharmap.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, PyObject_ptable, char_perrors  ]



# PyObject_p PyUnicode_DecodeMBCS( char_pstring, Py_ssize_t length, char_perrors )
PyUnicode_DecodeMBCS = _dll.PyUnicode_DecodeMBCS
PyUnicode_DecodeMBCS.restype = PyObject_p
PyUnicode_DecodeMBCS.argtypes = [  char_pstring, Py_ssize_t length, char_perrors  ]



# PyObject_p PyUnicode_DecodeMBCSStateful( char_pstring, Py_ssize_t length, char_perrors, Py_ssize_t_pconsumed )
PyUnicode_DecodeMBCSStateful = _dll.PyUnicode_DecodeMBCSStateful
PyUnicode_DecodeMBCSStateful.restype = PyObject_p
PyUnicode_DecodeMBCSStateful.argtypes = [  char_pstring, Py_ssize_t length, char_perrors, Py_ssize_t_pconsumed  ]



# PyObject_p PyUnicode_AsMBCSString( PyObject_punicode )
PyUnicode_AsMBCSString = _dll.PyUnicode_AsMBCSString
PyUnicode_AsMBCSString.restype = PyObject_p
PyUnicode_AsMBCSString.argtypes = [  PyObject_punicode  ]



# PyObject_p PyUnicode_EncodeMBCS( Py_UNICODE_pdata, Py_ssize_t length, char_perrors )
PyUnicode_EncodeMBCS = _dll.PyUnicode_EncodeMBCS
PyUnicode_EncodeMBCS.restype = PyObject_p
PyUnicode_EncodeMBCS.argtypes = [  Py_UNICODE_pdata, Py_ssize_t length, char_perrors  ]



# c_int PyUnicodeUCS2_EncodeDecimal( Py_UNICODE_ps, Py_ssize_t length, char_poutput, char_perrors )
PyUnicodeUCS2_EncodeDecimal = _dll.PyUnicodeUCS2_EncodeDecimal
PyUnicodeUCS2_EncodeDecimal.restype = c_int
PyUnicodeUCS2_EncodeDecimal.argtypes = [  Py_UNICODE_ps, Py_ssize_t length, char_poutput, char_perrors  ]



# PyObject_p PyUnicodeUCS2_Concat( PyObject_pleft, PyObject_pright )
PyUnicodeUCS2_Concat = _dll.PyUnicodeUCS2_Concat
PyUnicodeUCS2_Concat.restype = PyObject_p
PyUnicodeUCS2_Concat.argtypes = [  PyObject_pleft, PyObject_pright  ]



# PyObject_p PyUnicodeUCS2_Split( PyObject_ps, PyObject_psep, Py_ssize_t maxsplit )
PyUnicodeUCS2_Split = _dll.PyUnicodeUCS2_Split
PyUnicodeUCS2_Split.restype = PyObject_p
PyUnicodeUCS2_Split.argtypes = [  PyObject_ps, PyObject_psep, Py_ssize_t maxsplit  ]



# PyObject_p PyUnicodeUCS2_Splitlines( PyObject_ps, c_int keepends )
PyUnicodeUCS2_Splitlines = _dll.PyUnicodeUCS2_Splitlines
PyUnicodeUCS2_Splitlines.restype = PyObject_p
PyUnicodeUCS2_Splitlines.argtypes = [  PyObject_ps, c_int keepends  ]



# PyObject_p PyUnicodeUCS2_Partition( PyObject_ps, PyObject_psep )
PyUnicodeUCS2_Partition = _dll.PyUnicodeUCS2_Partition
PyUnicodeUCS2_Partition.restype = PyObject_p
PyUnicodeUCS2_Partition.argtypes = [  PyObject_ps, PyObject_psep  ]



# PyObject_p PyUnicodeUCS2_RPartition( PyObject_ps, PyObject_psep )
PyUnicodeUCS2_RPartition = _dll.PyUnicodeUCS2_RPartition
PyUnicodeUCS2_RPartition.restype = PyObject_p
PyUnicodeUCS2_RPartition.argtypes = [  PyObject_ps, PyObject_psep  ]



# PyObject_p PyUnicodeUCS2_RSplit( PyObject_ps, PyObject_psep, Py_ssize_t maxsplit )
PyUnicodeUCS2_RSplit = _dll.PyUnicodeUCS2_RSplit
PyUnicodeUCS2_RSplit.restype = PyObject_p
PyUnicodeUCS2_RSplit.argtypes = [  PyObject_ps, PyObject_psep, Py_ssize_t maxsplit  ]



# PyObject_p PyUnicodeUCS2_Translate( PyObject_pstr, PyObject_ptable, char_perrors )
PyUnicodeUCS2_Translate = _dll.PyUnicodeUCS2_Translate
PyUnicodeUCS2_Translate.restype = PyObject_p
PyUnicodeUCS2_Translate.argtypes = [  PyObject_pstr, PyObject_ptable, char_perrors  ]



# PyObject_p PyUnicodeUCS2_Join( PyObject_pseparator, PyObject_pseq )
PyUnicodeUCS2_Join = _dll.PyUnicodeUCS2_Join
PyUnicodeUCS2_Join.restype = PyObject_p
PyUnicodeUCS2_Join.argtypes = [  PyObject_pseparator, PyObject_pseq  ]



# Py_ssize_t PyUnicodeUCS2_Tailmatch( PyObject_pstr, PyObject_psubstr, Py_ssize_t start, Py_ssize_t end, c_int direction )
PyUnicodeUCS2_Tailmatch = _dll.PyUnicodeUCS2_Tailmatch
PyUnicodeUCS2_Tailmatch.restype = Py_ssize_t
PyUnicodeUCS2_Tailmatch.argtypes = [  PyObject_pstr, PyObject_psubstr, Py_ssize_t start, Py_ssize_t end, c_int direction  ]



# Py_ssize_t PyUnicodeUCS2_Find( PyObject_pstr, PyObject_psubstr, Py_ssize_t start, Py_ssize_t end, c_int direction )
PyUnicodeUCS2_Find = _dll.PyUnicodeUCS2_Find
PyUnicodeUCS2_Find.restype = Py_ssize_t
PyUnicodeUCS2_Find.argtypes = [  PyObject_pstr, PyObject_psubstr, Py_ssize_t start, Py_ssize_t end, c_int direction  ]



# Py_ssize_t PyUnicodeUCS2_Count( PyObject_pstr, PyObject_psubstr, Py_ssize_t start, Py_ssize_t end )
PyUnicodeUCS2_Count = _dll.PyUnicodeUCS2_Count
PyUnicodeUCS2_Count.restype = Py_ssize_t
PyUnicodeUCS2_Count.argtypes = [  PyObject_pstr, PyObject_psubstr, Py_ssize_t start, Py_ssize_t end  ]



# PyObject_p PyUnicodeUCS2_Replace( PyObject_pstr, PyObject_psubstr, PyObject_preplstr, Py_ssize_t maxcount )
PyUnicodeUCS2_Replace = _dll.PyUnicodeUCS2_Replace
PyUnicodeUCS2_Replace.restype = PyObject_p
PyUnicodeUCS2_Replace.argtypes = [  PyObject_pstr, PyObject_psubstr, PyObject_preplstr, Py_ssize_t maxcount  ]



# c_int PyUnicodeUCS2_Compare( PyObject_pleft, PyObject_pright )
PyUnicodeUCS2_Compare = _dll.PyUnicodeUCS2_Compare
PyUnicodeUCS2_Compare.restype = c_int
PyUnicodeUCS2_Compare.argtypes = [  PyObject_pleft, PyObject_pright  ]



# PyObject_p PyUnicodeUCS2_RichCompare( PyObject_pleft, PyObject_pright, c_int op )
PyUnicodeUCS2_RichCompare = _dll.PyUnicodeUCS2_RichCompare
PyUnicodeUCS2_RichCompare.restype = PyObject_p
PyUnicodeUCS2_RichCompare.argtypes = [  PyObject_pleft, PyObject_pright, c_int op  ]



# PyObject_p PyUnicodeUCS2_Format( PyObject_pformat, PyObject_pargs )
PyUnicodeUCS2_Format = _dll.PyUnicodeUCS2_Format
PyUnicodeUCS2_Format.restype = PyObject_p
PyUnicodeUCS2_Format.argtypes = [  PyObject_pformat, PyObject_pargs  ]



# c_int PyUnicodeUCS2_Contains( PyObject_pcontainer, PyObject_pelement )
PyUnicodeUCS2_Contains = _dll.PyUnicodeUCS2_Contains
PyUnicodeUCS2_Contains.restype = c_int
PyUnicodeUCS2_Contains.argtypes = [  PyObject_pcontainer, PyObject_pelement  ]



# PyObject_p _PyUnicode_XStrip( PyUnicodeObject_pself, c_int striptype, PyObject_psepobj )
_PyUnicode_XStrip = _dll._PyUnicode_XStrip
_PyUnicode_XStrip.restype = PyObject_p
_PyUnicode_XStrip.argtypes = [  PyUnicodeObject_pself, c_int striptype, PyObject_psepobj  ]



# c_int _PyUnicodeUCS2_IsLowercase( Py_UNICODE ch )
_PyUnicodeUCS2_IsLowercase = _dll._PyUnicodeUCS2_IsLowercase
_PyUnicodeUCS2_IsLowercase.restype = c_int
_PyUnicodeUCS2_IsLowercase.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsUppercase( Py_UNICODE ch )
_PyUnicodeUCS2_IsUppercase = _dll._PyUnicodeUCS2_IsUppercase
_PyUnicodeUCS2_IsUppercase.restype = c_int
_PyUnicodeUCS2_IsUppercase.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsTitlecase( Py_UNICODE ch )
_PyUnicodeUCS2_IsTitlecase = _dll._PyUnicodeUCS2_IsTitlecase
_PyUnicodeUCS2_IsTitlecase.restype = c_int
_PyUnicodeUCS2_IsTitlecase.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsWhitespace( Py_UNICODE ch )
_PyUnicodeUCS2_IsWhitespace = _dll._PyUnicodeUCS2_IsWhitespace
_PyUnicodeUCS2_IsWhitespace.restype = c_int
_PyUnicodeUCS2_IsWhitespace.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsLinebreak( Py_UNICODE ch )
_PyUnicodeUCS2_IsLinebreak = _dll._PyUnicodeUCS2_IsLinebreak
_PyUnicodeUCS2_IsLinebreak.restype = c_int
_PyUnicodeUCS2_IsLinebreak.argtypes = [  Py_UNICODE ch  ]



# Py_UNICODE _PyUnicodeUCS2_ToLowercase( Py_UNICODE ch )
_PyUnicodeUCS2_ToLowercase = _dll._PyUnicodeUCS2_ToLowercase
_PyUnicodeUCS2_ToLowercase.restype = Py_UNICODE
_PyUnicodeUCS2_ToLowercase.argtypes = [  Py_UNICODE ch  ]



# Py_UNICODE _PyUnicodeUCS2_ToUppercase( Py_UNICODE ch )
_PyUnicodeUCS2_ToUppercase = _dll._PyUnicodeUCS2_ToUppercase
_PyUnicodeUCS2_ToUppercase.restype = Py_UNICODE
_PyUnicodeUCS2_ToUppercase.argtypes = [  Py_UNICODE ch  ]



# Py_UNICODE _PyUnicodeUCS2_ToTitlecase( Py_UNICODE ch )
_PyUnicodeUCS2_ToTitlecase = _dll._PyUnicodeUCS2_ToTitlecase
_PyUnicodeUCS2_ToTitlecase.restype = Py_UNICODE
_PyUnicodeUCS2_ToTitlecase.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_ToDecimalDigit( Py_UNICODE ch )
_PyUnicodeUCS2_ToDecimalDigit = _dll._PyUnicodeUCS2_ToDecimalDigit
_PyUnicodeUCS2_ToDecimalDigit.restype = c_int
_PyUnicodeUCS2_ToDecimalDigit.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_ToDigit( Py_UNICODE ch )
_PyUnicodeUCS2_ToDigit = _dll._PyUnicodeUCS2_ToDigit
_PyUnicodeUCS2_ToDigit.restype = c_int
_PyUnicodeUCS2_ToDigit.argtypes = [  Py_UNICODE ch  ]



# double _PyUnicodeUCS2_ToNumeric( Py_UNICODE ch )
_PyUnicodeUCS2_ToNumeric = _dll._PyUnicodeUCS2_ToNumeric
_PyUnicodeUCS2_ToNumeric.restype = double
_PyUnicodeUCS2_ToNumeric.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsDecimalDigit( Py_UNICODE ch )
_PyUnicodeUCS2_IsDecimalDigit = _dll._PyUnicodeUCS2_IsDecimalDigit
_PyUnicodeUCS2_IsDecimalDigit.restype = c_int
_PyUnicodeUCS2_IsDecimalDigit.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsDigit( Py_UNICODE ch )
_PyUnicodeUCS2_IsDigit = _dll._PyUnicodeUCS2_IsDigit
_PyUnicodeUCS2_IsDigit.restype = c_int
_PyUnicodeUCS2_IsDigit.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsNumeric( Py_UNICODE ch )
_PyUnicodeUCS2_IsNumeric = _dll._PyUnicodeUCS2_IsNumeric
_PyUnicodeUCS2_IsNumeric.restype = c_int
_PyUnicodeUCS2_IsNumeric.argtypes = [  Py_UNICODE ch  ]



# c_int _PyUnicodeUCS2_IsAlpha( Py_UNICODE ch )
_PyUnicodeUCS2_IsAlpha = _dll._PyUnicodeUCS2_IsAlpha
_PyUnicodeUCS2_IsAlpha.restype = c_int
_PyUnicodeUCS2_IsAlpha.argtypes = [  Py_UNICODE ch  ]



# extern PyTypeObject Pyc_int_Type
Pyc_int_Type = PyTypeObject.from_address(_dll.Pyc_int_Type)



# PyObject_p Pyc_int_FromString(char_p, char_p_p, c_int)
Pyc_int_FromString = _dll.Pyc_int_FromString
Pyc_int_FromString.restype = PyObject_p
Pyc_int_FromString.argtypes = [ char_p, char_p_p, c_int ]



# PyObject_p Pyc_int_FromUnicode(Py_UNICODE_p, Py_ssize_t, c_int)
Pyc_int_FromUnicode = _dll.Pyc_int_FromUnicode
Pyc_int_FromUnicode.restype = PyObject_p
Pyc_int_FromUnicode.argtypes = [ Py_UNICODE_p, Py_ssize_t, c_int ]



# PyObject_p Pyc_int_FromLong(c_long)
Pyc_int_FromLong = _dll.Pyc_int_FromLong
Pyc_int_FromLong.restype = PyObject_p
Pyc_int_FromLong.argtypes = [ c_long ]



# PyObject_p Pyc_int_FromSize_t(c_size_t)
Pyc_int_FromSize_t = _dll.Pyc_int_FromSize_t
Pyc_int_FromSize_t.restype = PyObject_p
Pyc_int_FromSize_t.argtypes = [ c_size_t ]



# PyObject_p Pyc_int_FromSsize_t(Py_ssize_t)
Pyc_int_FromSsize_t = _dll.Pyc_int_FromSsize_t
Pyc_int_FromSsize_t.restype = PyObject_p
Pyc_int_FromSsize_t.argtypes = [ Py_ssize_t ]



# c_long Pyc_int_AsLong(PyObject_p)
Pyc_int_AsLong = _dll.Pyc_int_AsLong
Pyc_int_AsLong.restype = c_long
Pyc_int_AsLong.argtypes = [ PyObject_p ]



# Py_ssize_t Pyc_int_AsSsize_t(PyObject_p)
Pyc_int_AsSsize_t = _dll.Pyc_int_AsSsize_t
Pyc_int_AsSsize_t.restype = Py_ssize_t
Pyc_int_AsSsize_t.argtypes = [ PyObject_p ]



# c_ulong Pyc_int_AsUnsignedLongMask(PyObject_p)
Pyc_int_AsUnsignedLongMask = _dll.Pyc_int_AsUnsignedLongMask
Pyc_int_AsUnsignedLongMask.restype = c_ulong
Pyc_int_AsUnsignedLongMask.argtypes = [ PyObject_p ]



# unsigned __c_int64 Pyc_int_AsUnsignedLongLongMask(PyObject_p)
Pyc_int_AsUnsignedLongLongMask = _dll.Pyc_int_AsUnsignedLongLongMask
Pyc_int_AsUnsignedLongLongMask.restype = unsigned __c_int64
Pyc_int_AsUnsignedLongLongMask.argtypes = [ PyObject_p ]



# c_long Pyc_int_GetMax(c_void)
Pyc_int_GetMax = _dll.Pyc_int_GetMax
Pyc_int_GetMax.restype = c_long
Pyc_int_GetMax.argtypes = [ c_void ]



# c_ulong PyOS_strtoul(char_p, char_p_p, c_int)
PyOS_strtoul = _dll.PyOS_strtoul
PyOS_strtoul.restype = c_ulong
PyOS_strtoul.argtypes = [ char_p, char_p_p, c_int ]



# c_long PyOS_strtol(char_p, char_p_p, c_int)
PyOS_strtol = _dll.PyOS_strtol
PyOS_strtol.restype = c_long
PyOS_strtol.argtypes = [ char_p, char_p_p, c_int ]



# c_int Pyc_int_ClearFreeList(c_void)
Pyc_int_ClearFreeList = _dll.Pyc_int_ClearFreeList
Pyc_int_ClearFreeList.restype = c_int
Pyc_int_ClearFreeList.argtypes = [ c_void ]



# PyObject_p _Pyc_int_Format(Pyc_intObject_p v, c_int base, c_int newstyle)
_Pyc_int_Format = _dll._Pyc_int_Format
_Pyc_int_Format.restype = PyObject_p
_Pyc_int_Format.argtypes = [ Pyc_intObject_p v, c_int base, c_int newstyle ]



# PyObject_p _Pyc_int_FormatAdvanced(PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len)
_Pyc_int_FormatAdvanced = _dll._Pyc_int_FormatAdvanced
_Pyc_int_FormatAdvanced.restype = PyObject_p
_Pyc_int_FormatAdvanced.argtypes = [ PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len ]



# extern PyTypeObject PyBool_Type
PyBool_Type = PyTypeObject.from_address(_dll.PyBool_Type)



# extern Pyc_intObject _Py_ZeroStruct
_Py_ZeroStruct = Pyc_intObject.from_address(_dll._Py_ZeroStruct)



# extern Pyc_intObject _Py_TrueStruct
_Py_TrueStruct = Pyc_intObject.from_address(_dll._Py_TrueStruct)



# PyObject_p PyBool_FromLong(c_long)
PyBool_FromLong = _dll.PyBool_FromLong
PyBool_FromLong.restype = PyObject_p
PyBool_FromLong.argtypes = [ c_long ]



# extern PyTypeObject PyLong_Type
PyLong_Type = PyTypeObject.from_address(_dll.PyLong_Type)



# PyObject_p PyLong_FromLong(c_long)
PyLong_FromLong = _dll.PyLong_FromLong
PyLong_FromLong.restype = PyObject_p
PyLong_FromLong.argtypes = [ c_long ]



# PyObject_p PyLong_FromUnsignedLong(c_ulong)
PyLong_FromUnsignedLong = _dll.PyLong_FromUnsignedLong
PyLong_FromUnsignedLong.restype = PyObject_p
PyLong_FromUnsignedLong.argtypes = [ c_ulong ]



# PyObject_p PyLong_FromDouble(double)
PyLong_FromDouble = _dll.PyLong_FromDouble
PyLong_FromDouble.restype = PyObject_p
PyLong_FromDouble.argtypes = [ double ]



# PyObject_p PyLong_FromSize_t(c_size_t)
PyLong_FromSize_t = _dll.PyLong_FromSize_t
PyLong_FromSize_t.restype = PyObject_p
PyLong_FromSize_t.argtypes = [ c_size_t ]



# PyObject_p PyLong_FromSsize_t(Py_ssize_t)
PyLong_FromSsize_t = _dll.PyLong_FromSsize_t
PyLong_FromSsize_t.restype = PyObject_p
PyLong_FromSsize_t.argtypes = [ Py_ssize_t ]



# c_long PyLong_AsLong(PyObject_p)
PyLong_AsLong = _dll.PyLong_AsLong
PyLong_AsLong.restype = c_long
PyLong_AsLong.argtypes = [ PyObject_p ]



# c_long PyLong_AsLongAndOverflow(PyObject_p, c_int_p)
PyLong_AsLongAndOverflow = _dll.PyLong_AsLongAndOverflow
PyLong_AsLongAndOverflow.restype = c_long
PyLong_AsLongAndOverflow.argtypes = [ PyObject_p, c_int_p ]



# c_ulong PyLong_AsUnsignedLong(PyObject_p)
PyLong_AsUnsignedLong = _dll.PyLong_AsUnsignedLong
PyLong_AsUnsignedLong.restype = c_ulong
PyLong_AsUnsignedLong.argtypes = [ PyObject_p ]



# c_ulong PyLong_AsUnsignedLongMask(PyObject_p)
PyLong_AsUnsignedLongMask = _dll.PyLong_AsUnsignedLongMask
PyLong_AsUnsignedLongMask.restype = c_ulong
PyLong_AsUnsignedLongMask.argtypes = [ PyObject_p ]



# Py_ssize_t PyLong_AsSsize_t(PyObject_p)
PyLong_AsSsize_t = _dll.PyLong_AsSsize_t
PyLong_AsSsize_t.restype = Py_ssize_t
PyLong_AsSsize_t.argtypes = [ PyObject_p ]



# PyObject_p PyLong_GetInfo(c_void)
PyLong_GetInfo = _dll.PyLong_GetInfo
PyLong_GetInfo.restype = PyObject_p
PyLong_GetInfo.argtypes = [ c_void ]



# double _PyLong_Frexp(PyLongObject_pa, Py_ssize_t_pe)
_PyLong_Frexp = _dll._PyLong_Frexp
_PyLong_Frexp.restype = double
_PyLong_Frexp.argtypes = [ PyLongObject_pa, Py_ssize_t_pe ]



# double PyLong_AsDouble(PyObject_p)
PyLong_AsDouble = _dll.PyLong_AsDouble
PyLong_AsDouble.restype = double
PyLong_AsDouble.argtypes = [ PyObject_p ]



# PyObject_p PyLong_Fromc_voidPtr(c_void_p)
PyLong_Fromc_voidPtr = _dll.PyLong_Fromc_voidPtr
PyLong_Fromc_voidPtr.restype = PyObject_p
PyLong_Fromc_voidPtr.argtypes = [ c_void_p ]



# c_void_p PyLong_Asc_voidPtr(PyObject_p)
PyLong_Asc_voidPtr = _dll.PyLong_Asc_voidPtr
PyLong_Asc_voidPtr.restype = c_void_p
PyLong_Asc_voidPtr.argtypes = [ PyObject_p ]



# PyObject_p PyLong_FromLongLong(__c_int64)
PyLong_FromLongLong = _dll.PyLong_FromLongLong
PyLong_FromLongLong.restype = PyObject_p
PyLong_FromLongLong.argtypes = [ __c_int64 ]



# PyObject_p PyLong_FromUnsignedLongLong(unsigned __c_int64)
PyLong_FromUnsignedLongLong = _dll.PyLong_FromUnsignedLongLong
PyLong_FromUnsignedLongLong.restype = PyObject_p
PyLong_FromUnsignedLongLong.argtypes = [ unsigned __c_int64 ]



# __c_int64 PyLong_AsLongLong(PyObject_p)
PyLong_AsLongLong = _dll.PyLong_AsLongLong
PyLong_AsLongLong.restype = __c_int64
PyLong_AsLongLong.argtypes = [ PyObject_p ]



# unsigned __c_int64 PyLong_AsUnsignedLongLong(PyObject_p)
PyLong_AsUnsignedLongLong = _dll.PyLong_AsUnsignedLongLong
PyLong_AsUnsignedLongLong.restype = unsigned __c_int64
PyLong_AsUnsignedLongLong.argtypes = [ PyObject_p ]



# unsigned __c_int64 PyLong_AsUnsignedLongLongMask(PyObject_p)
PyLong_AsUnsignedLongLongMask = _dll.PyLong_AsUnsignedLongLongMask
PyLong_AsUnsignedLongLongMask.restype = unsigned __c_int64
PyLong_AsUnsignedLongLongMask.argtypes = [ PyObject_p ]



# __c_int64 PyLong_AsLongLongAndOverflow(PyObject_p, c_int_p)
PyLong_AsLongLongAndOverflow = _dll.PyLong_AsLongLongAndOverflow
PyLong_AsLongLongAndOverflow.restype = __c_int64
PyLong_AsLongLongAndOverflow.argtypes = [ PyObject_p, c_int_p ]



# PyObject_p PyLong_FromString(char_p, char_p_p, c_int)
PyLong_FromString = _dll.PyLong_FromString
PyLong_FromString.restype = PyObject_p
PyLong_FromString.argtypes = [ char_p, char_p_p, c_int ]



# PyObject_p PyLong_FromUnicode(Py_UNICODE_p, Py_ssize_t, c_int)
PyLong_FromUnicode = _dll.PyLong_FromUnicode
PyLong_FromUnicode.restype = PyObject_p
PyLong_FromUnicode.argtypes = [ Py_UNICODE_p, Py_ssize_t, c_int ]



# c_int _PyLong_Sign(PyObject_pv)
_PyLong_Sign = _dll._PyLong_Sign
_PyLong_Sign.restype = c_int
_PyLong_Sign.argtypes = [ PyObject_pv ]



# c_size_t _PyLong_NumBits(PyObject_pv)
_PyLong_NumBits = _dll._PyLong_NumBits
_PyLong_NumBits.restype = c_size_t
_PyLong_NumBits.argtypes = [ PyObject_pv ]



# PyObject_p _PyLong_FromByteArray( unsigned char_p bytes, c_size_t n, c_int little_endian, c_int is_signed)
_PyLong_FromByteArray = _dll._PyLong_FromByteArray
_PyLong_FromByteArray.restype = PyObject_p
_PyLong_FromByteArray.argtypes = [  unsigned char_p bytes, c_size_t n, c_int little_endian, c_int is_signed ]



# c_int _PyLong_AsByteArray(PyLongObject_p v, unsigned char_p bytes, c_size_t n, c_int little_endian, c_int is_signed)
_PyLong_AsByteArray = _dll._PyLong_AsByteArray
_PyLong_AsByteArray.restype = c_int
_PyLong_AsByteArray.argtypes = [ PyLongObject_p v, unsigned char_p bytes, c_size_t n, c_int little_endian, c_int is_signed ]



# PyObject_p _PyLong_Format(PyObject_paa, c_int base, c_int addL, c_int newstyle)
_PyLong_Format = _dll._PyLong_Format
_PyLong_Format.restype = PyObject_p
_PyLong_Format.argtypes = [ PyObject_paa, c_int base, c_int addL, c_int newstyle ]



# PyObject_p _PyLong_FormatAdvanced(PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len)
_PyLong_FormatAdvanced = _dll._PyLong_FormatAdvanced
_PyLong_FormatAdvanced.restype = PyObject_p
_PyLong_FormatAdvanced.argtypes = [ PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len ]



# extern PyTypeObject PyFloat_Type
PyFloat_Type = PyTypeObject.from_address(_dll.PyFloat_Type)



# double PyFloat_GetMax(c_void)
PyFloat_GetMax = _dll.PyFloat_GetMax
PyFloat_GetMax.restype = double
PyFloat_GetMax.argtypes = [ c_void ]



# double PyFloat_GetMin(c_void)
PyFloat_GetMin = _dll.PyFloat_GetMin
PyFloat_GetMin.restype = double
PyFloat_GetMin.argtypes = [ c_void ]



# PyObject_p PyFloat_GetInfo(c_void)
PyFloat_GetInfo = _dll.PyFloat_GetInfo
PyFloat_GetInfo.restype = PyObject_p
PyFloat_GetInfo.argtypes = [ c_void ]



# PyObject_p PyFloat_FromString(PyObject_p, char_p_p junk)
PyFloat_FromString = _dll.PyFloat_FromString
PyFloat_FromString.restype = PyObject_p
PyFloat_FromString.argtypes = [ PyObject_p, char_p_p junk ]



# PyObject_p PyFloat_FromDouble(double)
PyFloat_FromDouble = _dll.PyFloat_FromDouble
PyFloat_FromDouble.restype = PyObject_p
PyFloat_FromDouble.argtypes = [ double ]



# double PyFloat_AsDouble(PyObject_p)
PyFloat_AsDouble = _dll.PyFloat_AsDouble
PyFloat_AsDouble.restype = double
PyFloat_AsDouble.argtypes = [ PyObject_p ]



# c_void PyFloat_AsReprString(char_p, PyFloatObject_pv)
PyFloat_AsReprString = _dll.PyFloat_AsReprString
PyFloat_AsReprString.restype = c_void
PyFloat_AsReprString.argtypes = [ char_p, PyFloatObject_pv ]



# c_void PyFloat_AsString(char_p, PyFloatObject_pv)
PyFloat_AsString = _dll.PyFloat_AsString
PyFloat_AsString.restype = c_void
PyFloat_AsString.argtypes = [ char_p, PyFloatObject_pv ]



# c_int _PyFloat_Pack4(double x, unsigned char_pp, c_int le)
_PyFloat_Pack4 = _dll._PyFloat_Pack4
_PyFloat_Pack4.restype = c_int
_PyFloat_Pack4.argtypes = [ double x, unsigned char_pp, c_int le ]



# c_int _PyFloat_Pack8(double x, unsigned char_pp, c_int le)
_PyFloat_Pack8 = _dll._PyFloat_Pack8
_PyFloat_Pack8.restype = c_int
_PyFloat_Pack8.argtypes = [ double x, unsigned char_pp, c_int le ]



# double _PyFloat_Unpack4(unsigned char_pp, c_int le)
_PyFloat_Unpack4 = _dll._PyFloat_Unpack4
_PyFloat_Unpack4.restype = double
_PyFloat_Unpack4.argtypes = [ unsigned char_pp, c_int le ]



# double _PyFloat_Unpack8(unsigned char_pp, c_int le)
_PyFloat_Unpack8 = _dll._PyFloat_Unpack8
_PyFloat_Unpack8.restype = double
_PyFloat_Unpack8.argtypes = [ unsigned char_pp, c_int le ]



# c_int PyFloat_ClearFreeList(c_void)
PyFloat_ClearFreeList = _dll.PyFloat_ClearFreeList
PyFloat_ClearFreeList.restype = c_int
PyFloat_ClearFreeList.argtypes = [ c_void ]



# PyObject_p _PyFloat_FormatAdvanced(PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len)
_PyFloat_FormatAdvanced = _dll._PyFloat_FormatAdvanced
_PyFloat_FormatAdvanced.restype = PyObject_p
_PyFloat_FormatAdvanced.argtypes = [ PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len ]



# PyObject_p _Py_double_round(double x, c_int ndigits)
_Py_double_round = _dll._Py_double_round
_Py_double_round.restype = PyObject_p
_Py_double_round.argtypes = [ double x, c_int ndigits ]



# Py_complex _Py_c_sum(Py_complex, Py_complex)
_Py_c_sum = _dll._Py_c_sum
_Py_c_sum.restype = Py_complex
_Py_c_sum.argtypes = [ Py_complex, Py_complex ]



# Py_complex _Py_c_diff(Py_complex, Py_complex)
_Py_c_diff = _dll._Py_c_diff
_Py_c_diff.restype = Py_complex
_Py_c_diff.argtypes = [ Py_complex, Py_complex ]



# Py_complex _Py_c_neg(Py_complex)
_Py_c_neg = _dll._Py_c_neg
_Py_c_neg.restype = Py_complex
_Py_c_neg.argtypes = [ Py_complex ]



# Py_complex _Py_c_prod(Py_complex, Py_complex)
_Py_c_prod = _dll._Py_c_prod
_Py_c_prod.restype = Py_complex
_Py_c_prod.argtypes = [ Py_complex, Py_complex ]



# Py_complex _Py_c_quot(Py_complex, Py_complex)
_Py_c_quot = _dll._Py_c_quot
_Py_c_quot.restype = Py_complex
_Py_c_quot.argtypes = [ Py_complex, Py_complex ]



# Py_complex _Py_c_pow(Py_complex, Py_complex)
_Py_c_pow = _dll._Py_c_pow
_Py_c_pow.restype = Py_complex
_Py_c_pow.argtypes = [ Py_complex, Py_complex ]



# double _Py_c_abs(Py_complex)
_Py_c_abs = _dll._Py_c_abs
_Py_c_abs.restype = double
_Py_c_abs.argtypes = [ Py_complex ]



# extern PyTypeObject PyComplex_Type
PyComplex_Type = PyTypeObject.from_address(_dll.PyComplex_Type)



# PyObject_p PyComplex_FromCComplex(Py_complex)
PyComplex_FromCComplex = _dll.PyComplex_FromCComplex
PyComplex_FromCComplex.restype = PyObject_p
PyComplex_FromCComplex.argtypes = [ Py_complex ]



# PyObject_p PyComplex_FromDoubles(double real, double imag)
PyComplex_FromDoubles = _dll.PyComplex_FromDoubles
PyComplex_FromDoubles.restype = PyObject_p
PyComplex_FromDoubles.argtypes = [ double real, double imag ]



# double PyComplex_RealAsDouble(PyObject_pop)
PyComplex_RealAsDouble = _dll.PyComplex_RealAsDouble
PyComplex_RealAsDouble.restype = double
PyComplex_RealAsDouble.argtypes = [ PyObject_pop ]



# double PyComplex_ImagAsDouble(PyObject_pop)
PyComplex_ImagAsDouble = _dll.PyComplex_ImagAsDouble
PyComplex_ImagAsDouble.restype = double
PyComplex_ImagAsDouble.argtypes = [ PyObject_pop ]



# Py_complex PyComplex_AsCComplex(PyObject_pop)
PyComplex_AsCComplex = _dll.PyComplex_AsCComplex
PyComplex_AsCComplex.restype = Py_complex
PyComplex_AsCComplex.argtypes = [ PyObject_pop ]



# PyObject_p _PyComplex_FormatAdvanced(PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len)
_PyComplex_FormatAdvanced = _dll._PyComplex_FormatAdvanced
_PyComplex_FormatAdvanced.restype = PyObject_p
_PyComplex_FormatAdvanced.argtypes = [ PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len ]



# extern PyTypeObject PyRange_Type
PyRange_Type = PyTypeObject.from_address(_dll.PyRange_Type)



# extern PyTypeObject PyBaseString_Type
PyBaseString_Type = PyTypeObject.from_address(_dll.PyBaseString_Type)



# extern PyTypeObject PyString_Type
PyString_Type = PyTypeObject.from_address(_dll.PyString_Type)



# PyObject_p PyString_FromStringAndSize(char_p, Py_ssize_t)
PyString_FromStringAndSize = _dll.PyString_FromStringAndSize
PyString_FromStringAndSize.restype = PyObject_p
PyString_FromStringAndSize.argtypes = [ char_p, Py_ssize_t ]



# PyObject_p PyString_FromString(char_p)
PyString_FromString = _dll.PyString_FromString
PyString_FromString.restype = PyObject_p
PyString_FromString.argtypes = [ char_p ]



# PyObject_p PyString_FromFormatV(char_p, va_list)
PyString_FromFormatV = _dll.PyString_FromFormatV
PyString_FromFormatV.restype = PyObject_p
PyString_FromFormatV.argtypes = [ char_p, va_list ]



# PyObject_p PyString_FromFormat(char_p, ...)
PyString_FromFormat = _dll.PyString_FromFormat
PyString_FromFormat.restype = PyObject_p
PyString_FromFormat.argtypes = [ char_p, ... ]



# Py_ssize_t PyString_Size(PyObject_p)
PyString_Size = _dll.PyString_Size
PyString_Size.restype = Py_ssize_t
PyString_Size.argtypes = [ PyObject_p ]



# char_p PyString_AsString(PyObject_p)
PyString_AsString = _dll.PyString_AsString
PyString_AsString.restype = char_p
PyString_AsString.argtypes = [ PyObject_p ]



# PyObject_p PyString_Repr(PyObject_p, c_int)
PyString_Repr = _dll.PyString_Repr
PyString_Repr.restype = PyObject_p
PyString_Repr.argtypes = [ PyObject_p, c_int ]



# c_void PyString_Concat(PyObject_p_p, PyObject_p)
PyString_Concat = _dll.PyString_Concat
PyString_Concat.restype = c_void
PyString_Concat.argtypes = [ PyObject_p_p, PyObject_p ]



# c_void PyString_ConcatAndDel(PyObject_p_p, PyObject_p)
PyString_ConcatAndDel = _dll.PyString_ConcatAndDel
PyString_ConcatAndDel.restype = c_void
PyString_ConcatAndDel.argtypes = [ PyObject_p_p, PyObject_p ]



# c_int _PyString_Resize(PyObject_p_p, Py_ssize_t)
_PyString_Resize = _dll._PyString_Resize
_PyString_Resize.restype = c_int
_PyString_Resize.argtypes = [ PyObject_p_p, Py_ssize_t ]



# c_int _PyString_Eq(PyObject_p, PyObject_p)
_PyString_Eq = _dll._PyString_Eq
_PyString_Eq.restype = c_int
_PyString_Eq.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyString_Format(PyObject_p, PyObject_p)
PyString_Format = _dll.PyString_Format
PyString_Format.restype = PyObject_p
PyString_Format.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p _PyString_FormatLong(PyObject_p, c_int, c_int, c_int, char_p_p, c_int_p)
_PyString_FormatLong = _dll._PyString_FormatLong
_PyString_FormatLong.restype = PyObject_p
_PyString_FormatLong.argtypes = [ PyObject_p, c_int, c_int, c_int, char_p_p, c_int_p ]



# PyObject_p PyString_DecodeEscape(char_p, Py_ssize_t, char_p, Py_ssize_t, char_p)
PyString_DecodeEscape = _dll.PyString_DecodeEscape
PyString_DecodeEscape.restype = PyObject_p
PyString_DecodeEscape.argtypes = [ char_p, Py_ssize_t, char_p, Py_ssize_t, char_p ]



# c_void PyString_c_internInPlace(PyObject_p_p)
PyString_c_internInPlace = _dll.PyString_c_internInPlace
PyString_c_internInPlace.restype = c_void
PyString_c_internInPlace.argtypes = [ PyObject_p_p ]



# c_void PyString_c_internImmortal(PyObject_p_p)
PyString_c_internImmortal = _dll.PyString_c_internImmortal
PyString_c_internImmortal.restype = c_void
PyString_c_internImmortal.argtypes = [ PyObject_p_p ]



# PyObject_p PyString_c_internFromString(char_p)
PyString_c_internFromString = _dll.PyString_c_internFromString
PyString_c_internFromString.restype = PyObject_p
PyString_c_internFromString.argtypes = [ char_p ]



# c_void _Py_Releasec_internedStrings(c_void)
_Py_Releasec_internedStrings = _dll._Py_Releasec_internedStrings
_Py_Releasec_internedStrings.restype = c_void
_Py_Releasec_internedStrings.argtypes = [ c_void ]



# PyObject_p _PyString_Join(PyObject_psep, PyObject_px)
_PyString_Join = _dll._PyString_Join
_PyString_Join.restype = PyObject_p
_PyString_Join.argtypes = [ PyObject_psep, PyObject_px ]



# PyObject_p PyString_Decode( char_ps, Py_ssize_t size, char_pencoding, char_perrors )
PyString_Decode = _dll.PyString_Decode
PyString_Decode.restype = PyObject_p
PyString_Decode.argtypes = [  char_ps, Py_ssize_t size, char_pencoding, char_perrors  ]



# PyObject_p PyString_Encode( char_ps, Py_ssize_t size, char_pencoding, char_perrors )
PyString_Encode = _dll.PyString_Encode
PyString_Encode.restype = PyObject_p
PyString_Encode.argtypes = [  char_ps, Py_ssize_t size, char_pencoding, char_perrors  ]



# PyObject_p PyString_AsEncodedObject( PyObject_pstr, char_pencoding, char_perrors )
PyString_AsEncodedObject = _dll.PyString_AsEncodedObject
PyString_AsEncodedObject.restype = PyObject_p
PyString_AsEncodedObject.argtypes = [  PyObject_pstr, char_pencoding, char_perrors  ]



# PyObject_p PyString_AsEncodedString( PyObject_pstr, char_pencoding, char_perrors )
PyString_AsEncodedString = _dll.PyString_AsEncodedString
PyString_AsEncodedString.restype = PyObject_p
PyString_AsEncodedString.argtypes = [  PyObject_pstr, char_pencoding, char_perrors  ]



# PyObject_p PyString_AsDecodedObject( PyObject_pstr, char_pencoding, char_perrors )
PyString_AsDecodedObject = _dll.PyString_AsDecodedObject
PyString_AsDecodedObject.restype = PyObject_p
PyString_AsDecodedObject.argtypes = [  PyObject_pstr, char_pencoding, char_perrors  ]



# PyObject_p PyString_AsDecodedString( PyObject_pstr, char_pencoding, char_perrors )
PyString_AsDecodedString = _dll.PyString_AsDecodedString
PyString_AsDecodedString.restype = PyObject_p
PyString_AsDecodedString.argtypes = [  PyObject_pstr, char_pencoding, char_perrors  ]



# c_int PyString_AsStringAndSize( register PyObject_pobj, register char_p_ps, register Py_ssize_t_plen )
PyString_AsStringAndSize = _dll.PyString_AsStringAndSize
PyString_AsStringAndSize.restype = c_int
PyString_AsStringAndSize.argtypes = [  register PyObject_pobj, register char_p_ps, register Py_ssize_t_plen  ]



# Py_ssize_t _PyString_InsertThousandsGrouping(char_pbuffer, Py_ssize_t n_buffer, char_pdigits, Py_ssize_t n_digits, Py_ssize_t min_width, char_pgrouping, char_pthousands_sep)
_PyString_InsertThousandsGrouping = _dll._PyString_InsertThousandsGrouping
_PyString_InsertThousandsGrouping.restype = Py_ssize_t
_PyString_InsertThousandsGrouping.argtypes = [ char_pbuffer, Py_ssize_t n_buffer, char_pdigits, Py_ssize_t n_digits, Py_ssize_t min_width, char_pgrouping, char_pthousands_sep ]



# PyObject_p _PyBytes_FormatAdvanced(PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len)
_PyBytes_FormatAdvanced = _dll._PyBytes_FormatAdvanced
_PyBytes_FormatAdvanced.restype = PyObject_p
_PyBytes_FormatAdvanced.argtypes = [ PyObject_pobj, char_pformat_spec, Py_ssize_t format_spec_len ]



# extern PyTypeObject PyMemoryView_Type
PyMemoryView_Type = PyTypeObject.from_address(_dll.PyMemoryView_Type)



# PyObject_p PyMemoryView_GetContiguous(PyObject_pbase, c_int buffertype, char fort)
PyMemoryView_GetContiguous = _dll.PyMemoryView_GetContiguous
PyMemoryView_GetContiguous.restype = PyObject_p
PyMemoryView_GetContiguous.argtypes = [ PyObject_pbase, c_int buffertype, char fort ]



# PyObject_p PyMemoryView_FromObject(PyObject_pbase)
PyMemoryView_FromObject = _dll.PyMemoryView_FromObject
PyMemoryView_FromObject.restype = PyObject_p
PyMemoryView_FromObject.argtypes = [ PyObject_pbase ]



# PyObject_p PyMemoryView_FromBuffer(Py_buffer_pinfo)
PyMemoryView_FromBuffer = _dll.PyMemoryView_FromBuffer
PyMemoryView_FromBuffer.restype = PyObject_p
PyMemoryView_FromBuffer.argtypes = [ Py_buffer_pinfo ]



# extern PyTypeObject PyBuffer_Type
PyBuffer_Type = PyTypeObject.from_address(_dll.PyBuffer_Type)



# PyObject_p PyBuffer_FromObject(PyObject_pbase, Py_ssize_t offset, Py_ssize_t size)
PyBuffer_FromObject = _dll.PyBuffer_FromObject
PyBuffer_FromObject.restype = PyObject_p
PyBuffer_FromObject.argtypes = [ PyObject_pbase, Py_ssize_t offset, Py_ssize_t size ]



# PyObject_p PyBuffer_FromReadWriteObject(PyObject_pbase, Py_ssize_t offset, Py_ssize_t size)
PyBuffer_FromReadWriteObject = _dll.PyBuffer_FromReadWriteObject
PyBuffer_FromReadWriteObject.restype = PyObject_p
PyBuffer_FromReadWriteObject.argtypes = [ PyObject_pbase, Py_ssize_t offset, Py_ssize_t size ]



# PyObject_p PyBuffer_FromMemory(c_void_pptr, Py_ssize_t size)
PyBuffer_FromMemory = _dll.PyBuffer_FromMemory
PyBuffer_FromMemory.restype = PyObject_p
PyBuffer_FromMemory.argtypes = [ c_void_pptr, Py_ssize_t size ]



# PyObject_p PyBuffer_FromReadWriteMemory(c_void_pptr, Py_ssize_t size)
PyBuffer_FromReadWriteMemory = _dll.PyBuffer_FromReadWriteMemory
PyBuffer_FromReadWriteMemory.restype = PyObject_p
PyBuffer_FromReadWriteMemory.argtypes = [ c_void_pptr, Py_ssize_t size ]



# PyObject_p PyBuffer_New(Py_ssize_t size)
PyBuffer_New = _dll.PyBuffer_New
PyBuffer_New.restype = PyObject_p
PyBuffer_New.argtypes = [ Py_ssize_t size ]



# extern PyTypeObject PyByteArray_Type
PyByteArray_Type = PyTypeObject.from_address(_dll.PyByteArray_Type)



# extern PyTypeObject PyByteArrayIter_Type
PyByteArrayIter_Type = PyTypeObject.from_address(_dll.PyByteArrayIter_Type)



# PyObject_p PyByteArray_FromObject(PyObject_p)
PyByteArray_FromObject = _dll.PyByteArray_FromObject
PyByteArray_FromObject.restype = PyObject_p
PyByteArray_FromObject.argtypes = [ PyObject_p ]



# PyObject_p PyByteArray_Concat(PyObject_p, PyObject_p)
PyByteArray_Concat = _dll.PyByteArray_Concat
PyByteArray_Concat.restype = PyObject_p
PyByteArray_Concat.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyByteArray_FromStringAndSize(char_p, Py_ssize_t)
PyByteArray_FromStringAndSize = _dll.PyByteArray_FromStringAndSize
PyByteArray_FromStringAndSize.restype = PyObject_p
PyByteArray_FromStringAndSize.argtypes = [ char_p, Py_ssize_t ]



# Py_ssize_t PyByteArray_Size(PyObject_p)
PyByteArray_Size = _dll.PyByteArray_Size
PyByteArray_Size.restype = Py_ssize_t
PyByteArray_Size.argtypes = [ PyObject_p ]



# char_p PyByteArray_AsString(PyObject_p)
PyByteArray_AsString = _dll.PyByteArray_AsString
PyByteArray_AsString.restype = char_p
PyByteArray_AsString.argtypes = [ PyObject_p ]



# c_int PyByteArray_Resize(PyObject_p, Py_ssize_t)
PyByteArray_Resize = _dll.PyByteArray_Resize
PyByteArray_Resize.restype = c_int
PyByteArray_Resize.argtypes = [ PyObject_p, Py_ssize_t ]



# extern PyTypeObject PyTuple_Type
PyTuple_Type = PyTypeObject.from_address(_dll.PyTuple_Type)



# PyObject_p PyTuple_New(Py_ssize_t size)
PyTuple_New = _dll.PyTuple_New
PyTuple_New.restype = PyObject_p
PyTuple_New.argtypes = [ Py_ssize_t size ]



# Py_ssize_t PyTuple_Size(PyObject_p)
PyTuple_Size = _dll.PyTuple_Size
PyTuple_Size.restype = Py_ssize_t
PyTuple_Size.argtypes = [ PyObject_p ]



# PyObject_p PyTuple_GetItem(PyObject_p, Py_ssize_t)
PyTuple_GetItem = _dll.PyTuple_GetItem
PyTuple_GetItem.restype = PyObject_p
PyTuple_GetItem.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyTuple_SetItem(PyObject_p, Py_ssize_t, PyObject_p)
PyTuple_SetItem = _dll.PyTuple_SetItem
PyTuple_SetItem.restype = c_int
PyTuple_SetItem.argtypes = [ PyObject_p, Py_ssize_t, PyObject_p ]



# PyObject_p PyTuple_GetSlice(PyObject_p, Py_ssize_t, Py_ssize_t)
PyTuple_GetSlice = _dll.PyTuple_GetSlice
PyTuple_GetSlice.restype = PyObject_p
PyTuple_GetSlice.argtypes = [ PyObject_p, Py_ssize_t, Py_ssize_t ]



# c_int _PyTuple_Resize(PyObject_p_p, Py_ssize_t)
_PyTuple_Resize = _dll._PyTuple_Resize
_PyTuple_Resize.restype = c_int
_PyTuple_Resize.argtypes = [ PyObject_p_p, Py_ssize_t ]



# PyObject_p PyTuple_Pack(Py_ssize_t, ...)
PyTuple_Pack = _dll.PyTuple_Pack
PyTuple_Pack.restype = PyObject_p
PyTuple_Pack.argtypes = [ Py_ssize_t, ... ]



# c_void _PyTuple_MaybeUntrack(PyObject_p)
_PyTuple_MaybeUntrack = _dll._PyTuple_MaybeUntrack
_PyTuple_MaybeUntrack.restype = c_void
_PyTuple_MaybeUntrack.argtypes = [ PyObject_p ]



# c_int PyTuple_ClearFreeList(c_void)
PyTuple_ClearFreeList = _dll.PyTuple_ClearFreeList
PyTuple_ClearFreeList.restype = c_int
PyTuple_ClearFreeList.argtypes = [ c_void ]



# extern PyTypeObject PyList_Type
PyList_Type = PyTypeObject.from_address(_dll.PyList_Type)



# PyObject_p PyList_New(Py_ssize_t size)
PyList_New = _dll.PyList_New
PyList_New.restype = PyObject_p
PyList_New.argtypes = [ Py_ssize_t size ]



# Py_ssize_t PyList_Size(PyObject_p)
PyList_Size = _dll.PyList_Size
PyList_Size.restype = Py_ssize_t
PyList_Size.argtypes = [ PyObject_p ]



# PyObject_p PyList_GetItem(PyObject_p, Py_ssize_t)
PyList_GetItem = _dll.PyList_GetItem
PyList_GetItem.restype = PyObject_p
PyList_GetItem.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyList_SetItem(PyObject_p, Py_ssize_t, PyObject_p)
PyList_SetItem = _dll.PyList_SetItem
PyList_SetItem.restype = c_int
PyList_SetItem.argtypes = [ PyObject_p, Py_ssize_t, PyObject_p ]



# c_int PyList_Insert(PyObject_p, Py_ssize_t, PyObject_p)
PyList_Insert = _dll.PyList_Insert
PyList_Insert.restype = c_int
PyList_Insert.argtypes = [ PyObject_p, Py_ssize_t, PyObject_p ]



# c_int PyList_Append(PyObject_p, PyObject_p)
PyList_Append = _dll.PyList_Append
PyList_Append.restype = c_int
PyList_Append.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyList_GetSlice(PyObject_p, Py_ssize_t, Py_ssize_t)
PyList_GetSlice = _dll.PyList_GetSlice
PyList_GetSlice.restype = PyObject_p
PyList_GetSlice.argtypes = [ PyObject_p, Py_ssize_t, Py_ssize_t ]



# c_int PyList_SetSlice(PyObject_p, Py_ssize_t, Py_ssize_t, PyObject_p)
PyList_SetSlice = _dll.PyList_SetSlice
PyList_SetSlice.restype = c_int
PyList_SetSlice.argtypes = [ PyObject_p, Py_ssize_t, Py_ssize_t, PyObject_p ]



# c_int PyList_Sort(PyObject_p)
PyList_Sort = _dll.PyList_Sort
PyList_Sort.restype = c_int
PyList_Sort.argtypes = [ PyObject_p ]



# c_int PyList_Reverse(PyObject_p)
PyList_Reverse = _dll.PyList_Reverse
PyList_Reverse.restype = c_int
PyList_Reverse.argtypes = [ PyObject_p ]



# PyObject_p PyList_AsTuple(PyObject_p)
PyList_AsTuple = _dll.PyList_AsTuple
PyList_AsTuple.restype = PyObject_p
PyList_AsTuple.argtypes = [ PyObject_p ]



# PyObject_p _PyList_Extend(PyListObject_p, PyObject_p)
_PyList_Extend = _dll._PyList_Extend
_PyList_Extend.restype = PyObject_p
_PyList_Extend.argtypes = [ PyListObject_p, PyObject_p ]



# extern PyTypeObject PyDict_Type
PyDict_Type = PyTypeObject.from_address(_dll.PyDict_Type)



# extern PyTypeObject PyDictIterKey_Type
PyDictIterKey_Type = PyTypeObject.from_address(_dll.PyDictIterKey_Type)



# extern PyTypeObject PyDictIterValue_Type
PyDictIterValue_Type = PyTypeObject.from_address(_dll.PyDictIterValue_Type)



# extern PyTypeObject PyDictIterItem_Type
PyDictIterItem_Type = PyTypeObject.from_address(_dll.PyDictIterItem_Type)



# extern PyTypeObject PyDictKeys_Type
PyDictKeys_Type = PyTypeObject.from_address(_dll.PyDictKeys_Type)



# extern PyTypeObject PyDictItems_Type
PyDictItems_Type = PyTypeObject.from_address(_dll.PyDictItems_Type)



# extern PyTypeObject PyDictValues_Type
PyDictValues_Type = PyTypeObject.from_address(_dll.PyDictValues_Type)



# PyObject_p PyDict_New(c_void)
PyDict_New = _dll.PyDict_New
PyDict_New.restype = PyObject_p
PyDict_New.argtypes = [ c_void ]



# PyObject_p PyDict_GetItem(PyObject_pmp, PyObject_pkey)
PyDict_GetItem = _dll.PyDict_GetItem
PyDict_GetItem.restype = PyObject_p
PyDict_GetItem.argtypes = [ PyObject_pmp, PyObject_pkey ]



# c_int PyDict_SetItem(PyObject_pmp, PyObject_pkey, PyObject_pitem)
PyDict_SetItem = _dll.PyDict_SetItem
PyDict_SetItem.restype = c_int
PyDict_SetItem.argtypes = [ PyObject_pmp, PyObject_pkey, PyObject_pitem ]



# c_int PyDict_DelItem(PyObject_pmp, PyObject_pkey)
PyDict_DelItem = _dll.PyDict_DelItem
PyDict_DelItem.restype = c_int
PyDict_DelItem.argtypes = [ PyObject_pmp, PyObject_pkey ]



# c_void PyDict_Clear(PyObject_pmp)
PyDict_Clear = _dll.PyDict_Clear
PyDict_Clear.restype = c_void
PyDict_Clear.argtypes = [ PyObject_pmp ]



# c_int PyDict_Next( PyObject_pmp, Py_ssize_t_ppos, PyObject_p_pkey, PyObject_p_pvalue)
PyDict_Next = _dll.PyDict_Next
PyDict_Next.restype = c_int
PyDict_Next.argtypes = [  PyObject_pmp, Py_ssize_t_ppos, PyObject_p_pkey, PyObject_p_pvalue ]



# c_int _PyDict_Next( PyObject_pmp, Py_ssize_t_ppos, PyObject_p_pkey, PyObject_p_pvalue, c_long_phash)
_PyDict_Next = _dll._PyDict_Next
_PyDict_Next.restype = c_int
_PyDict_Next.argtypes = [  PyObject_pmp, Py_ssize_t_ppos, PyObject_p_pkey, PyObject_p_pvalue, c_long_phash ]



# PyObject_p PyDict_Keys(PyObject_pmp)
PyDict_Keys = _dll.PyDict_Keys
PyDict_Keys.restype = PyObject_p
PyDict_Keys.argtypes = [ PyObject_pmp ]



# PyObject_p PyDict_Values(PyObject_pmp)
PyDict_Values = _dll.PyDict_Values
PyDict_Values.restype = PyObject_p
PyDict_Values.argtypes = [ PyObject_pmp ]



# PyObject_p PyDict_Items(PyObject_pmp)
PyDict_Items = _dll.PyDict_Items
PyDict_Items.restype = PyObject_p
PyDict_Items.argtypes = [ PyObject_pmp ]



# Py_ssize_t PyDict_Size(PyObject_pmp)
PyDict_Size = _dll.PyDict_Size
PyDict_Size.restype = Py_ssize_t
PyDict_Size.argtypes = [ PyObject_pmp ]



# PyObject_p PyDict_Copy(PyObject_pmp)
PyDict_Copy = _dll.PyDict_Copy
PyDict_Copy.restype = PyObject_p
PyDict_Copy.argtypes = [ PyObject_pmp ]



# c_int PyDict_Contains(PyObject_pmp, PyObject_pkey)
PyDict_Contains = _dll.PyDict_Contains
PyDict_Contains.restype = c_int
PyDict_Contains.argtypes = [ PyObject_pmp, PyObject_pkey ]



# c_int _PyDict_Contains(PyObject_pmp, PyObject_pkey, c_long hash)
_PyDict_Contains = _dll._PyDict_Contains
_PyDict_Contains.restype = c_int
_PyDict_Contains.argtypes = [ PyObject_pmp, PyObject_pkey, c_long hash ]



# PyObject_p _PyDict_NewPresized(Py_ssize_t minused)
_PyDict_NewPresized = _dll._PyDict_NewPresized
_PyDict_NewPresized.restype = PyObject_p
_PyDict_NewPresized.argtypes = [ Py_ssize_t minused ]



# c_void _PyDict_MaybeUntrack(PyObject_pmp)
_PyDict_MaybeUntrack = _dll._PyDict_MaybeUntrack
_PyDict_MaybeUntrack.restype = c_void
_PyDict_MaybeUntrack.argtypes = [ PyObject_pmp ]



# c_int PyDict_Update(PyObject_pmp, PyObject_pother)
PyDict_Update = _dll.PyDict_Update
PyDict_Update.restype = c_int
PyDict_Update.argtypes = [ PyObject_pmp, PyObject_pother ]



# c_int PyDict_Merge(PyObject_pmp, PyObject_pother, c_int override)
PyDict_Merge = _dll.PyDict_Merge
PyDict_Merge.restype = c_int
PyDict_Merge.argtypes = [ PyObject_pmp, PyObject_pother, c_int override ]



# c_int PyDict_MergeFromSeq2(PyObject_pd, PyObject_pseq2, c_int override)
PyDict_MergeFromSeq2 = _dll.PyDict_MergeFromSeq2
PyDict_MergeFromSeq2.restype = c_int
PyDict_MergeFromSeq2.argtypes = [ PyObject_pd, PyObject_pseq2, c_int override ]



# PyObject_p PyDict_GetItemString(PyObject_pdp, char_pkey)
PyDict_GetItemString = _dll.PyDict_GetItemString
PyDict_GetItemString.restype = PyObject_p
PyDict_GetItemString.argtypes = [ PyObject_pdp, char_pkey ]



# c_int PyDict_SetItemString(PyObject_pdp, char_pkey, PyObject_pitem)
PyDict_SetItemString = _dll.PyDict_SetItemString
PyDict_SetItemString.restype = c_int
PyDict_SetItemString.argtypes = [ PyObject_pdp, char_pkey, PyObject_pitem ]



# c_int PyDict_DelItemString(PyObject_pdp, char_pkey)
PyDict_DelItemString = _dll.PyDict_DelItemString
PyDict_DelItemString.restype = c_int
PyDict_DelItemString.argtypes = [ PyObject_pdp, char_pkey ]



# extern PyTypeObject PyEnum_Type
PyEnum_Type = PyTypeObject.from_address(_dll.PyEnum_Type)



# extern PyTypeObject PyReversed_Type
PyReversed_Type = PyTypeObject.from_address(_dll.PyReversed_Type)



# extern PyTypeObject PySet_Type
PySet_Type = PyTypeObject.from_address(_dll.PySet_Type)



# extern PyTypeObject PyFrozenSet_Type
PyFrozenSet_Type = PyTypeObject.from_address(_dll.PyFrozenSet_Type)



# PyObject_p PySet_New(PyObject_p)
PySet_New = _dll.PySet_New
PySet_New.restype = PyObject_p
PySet_New.argtypes = [ PyObject_p ]



# PyObject_p PyFrozenSet_New(PyObject_p)
PyFrozenSet_New = _dll.PyFrozenSet_New
PyFrozenSet_New.restype = PyObject_p
PyFrozenSet_New.argtypes = [ PyObject_p ]



# Py_ssize_t PySet_Size(PyObject_panyset)
PySet_Size = _dll.PySet_Size
PySet_Size.restype = Py_ssize_t
PySet_Size.argtypes = [ PyObject_panyset ]



# c_int PySet_Clear(PyObject_pset)
PySet_Clear = _dll.PySet_Clear
PySet_Clear.restype = c_int
PySet_Clear.argtypes = [ PyObject_pset ]



# c_int PySet_Contains(PyObject_panyset, PyObject_pkey)
PySet_Contains = _dll.PySet_Contains
PySet_Contains.restype = c_int
PySet_Contains.argtypes = [ PyObject_panyset, PyObject_pkey ]



# c_int PySet_Discard(PyObject_pset, PyObject_pkey)
PySet_Discard = _dll.PySet_Discard
PySet_Discard.restype = c_int
PySet_Discard.argtypes = [ PyObject_pset, PyObject_pkey ]



# c_int PySet_Add(PyObject_pset, PyObject_pkey)
PySet_Add = _dll.PySet_Add
PySet_Add.restype = c_int
PySet_Add.argtypes = [ PyObject_pset, PyObject_pkey ]



# c_int _PySet_Next(PyObject_pset, Py_ssize_t_ppos, PyObject_p_pkey)
_PySet_Next = _dll._PySet_Next
_PySet_Next.restype = c_int
_PySet_Next.argtypes = [ PyObject_pset, Py_ssize_t_ppos, PyObject_p_pkey ]



# c_int _PySet_NextEntry(PyObject_pset, Py_ssize_t_ppos, PyObject_p_pkey, c_long_phash)
_PySet_NextEntry = _dll._PySet_NextEntry
_PySet_NextEntry.restype = c_int
_PySet_NextEntry.argtypes = [ PyObject_pset, Py_ssize_t_ppos, PyObject_p_pkey, c_long_phash ]



# PyObject_p PySet_Pop(PyObject_pset)
PySet_Pop = _dll.PySet_Pop
PySet_Pop.restype = PyObject_p
PySet_Pop.argtypes = [ PyObject_pset ]



# c_int _PySet_Update(PyObject_pset, PyObject_piterable)
_PySet_Update = _dll._PySet_Update
_PySet_Update.restype = c_int
_PySet_Update.argtypes = [ PyObject_pset, PyObject_piterable ]



# extern PyTypeObject PyCFunction_Type
PyCFunction_Type = PyTypeObject.from_address(_dll.PyCFunction_Type)



# PyCFunction PyCFunction_GetFunction(PyObject_p)
PyCFunction_GetFunction = _dll.PyCFunction_GetFunction
PyCFunction_GetFunction.restype = PyCFunction
PyCFunction_GetFunction.argtypes = [ PyObject_p ]



# PyObject_p PyCFunction_GetSelf(PyObject_p)
PyCFunction_GetSelf = _dll.PyCFunction_GetSelf
PyCFunction_GetSelf.restype = PyObject_p
PyCFunction_GetSelf.argtypes = [ PyObject_p ]



# c_int PyCFunction_GetFlags(PyObject_p)
PyCFunction_GetFlags = _dll.PyCFunction_GetFlags
PyCFunction_GetFlags.restype = c_int
PyCFunction_GetFlags.argtypes = [ PyObject_p ]



# PyObject_p PyCFunction_Call(PyObject_p, PyObject_p, PyObject_p)
PyCFunction_Call = _dll.PyCFunction_Call
PyCFunction_Call.restype = PyObject_p
PyCFunction_Call.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# PyObject_p Py_FindMethod(PyMethodDef[], PyObject_p, char_p)
Py_FindMethod = _dll.Py_FindMethod
Py_FindMethod.restype = PyObject_p
Py_FindMethod.argtypes = [ PyMethodDef[], PyObject_p, char_p ]



# PyObject_p PyCFunction_NewEx(PyMethodDef_p, PyObject_p, PyObject_p)
PyCFunction_NewEx = _dll.PyCFunction_NewEx
PyCFunction_NewEx.restype = PyObject_p
PyCFunction_NewEx.argtypes = [ PyMethodDef_p, PyObject_p, PyObject_p ]



# PyObject_p Py_FindMethodInChain(PyMethodChain_p, PyObject_p, char_p)
Py_FindMethodInChain = _dll.Py_FindMethodInChain
Py_FindMethodInChain.restype = PyObject_p
Py_FindMethodInChain.argtypes = [ PyMethodChain_p, PyObject_p, char_p ]



# c_int PyCFunction_ClearFreeList(c_void)
PyCFunction_ClearFreeList = _dll.PyCFunction_ClearFreeList
PyCFunction_ClearFreeList.restype = c_int
PyCFunction_ClearFreeList.argtypes = [ c_void ]



# extern PyTypeObject PyModule_Type
PyModule_Type = PyTypeObject.from_address(_dll.PyModule_Type)



# PyObject_p PyModule_New(char_p)
PyModule_New = _dll.PyModule_New
PyModule_New.restype = PyObject_p
PyModule_New.argtypes = [ char_p ]



# PyObject_p PyModule_GetDict(PyObject_p)
PyModule_GetDict = _dll.PyModule_GetDict
PyModule_GetDict.restype = PyObject_p
PyModule_GetDict.argtypes = [ PyObject_p ]



# char_p PyModule_GetName(PyObject_p)
PyModule_GetName = _dll.PyModule_GetName
PyModule_GetName.restype = char_p
PyModule_GetName.argtypes = [ PyObject_p ]



# char_p PyModule_GetFilename(PyObject_p)
PyModule_GetFilename = _dll.PyModule_GetFilename
PyModule_GetFilename.restype = char_p
PyModule_GetFilename.argtypes = [ PyObject_p ]



# c_void _PyModule_Clear(PyObject_p)
_PyModule_Clear = _dll._PyModule_Clear
_PyModule_Clear.restype = c_void
_PyModule_Clear.argtypes = [ PyObject_p ]



# extern PyTypeObject PyFunction_Type
PyFunction_Type = PyTypeObject.from_address(_dll.PyFunction_Type)



# PyObject_p PyFunction_New(PyObject_p, PyObject_p)
PyFunction_New = _dll.PyFunction_New
PyFunction_New.restype = PyObject_p
PyFunction_New.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyFunction_GetCode(PyObject_p)
PyFunction_GetCode = _dll.PyFunction_GetCode
PyFunction_GetCode.restype = PyObject_p
PyFunction_GetCode.argtypes = [ PyObject_p ]



# PyObject_p PyFunction_GetGlobals(PyObject_p)
PyFunction_GetGlobals = _dll.PyFunction_GetGlobals
PyFunction_GetGlobals.restype = PyObject_p
PyFunction_GetGlobals.argtypes = [ PyObject_p ]



# PyObject_p PyFunction_GetModule(PyObject_p)
PyFunction_GetModule = _dll.PyFunction_GetModule
PyFunction_GetModule.restype = PyObject_p
PyFunction_GetModule.argtypes = [ PyObject_p ]



# PyObject_p PyFunction_GetDefaults(PyObject_p)
PyFunction_GetDefaults = _dll.PyFunction_GetDefaults
PyFunction_GetDefaults.restype = PyObject_p
PyFunction_GetDefaults.argtypes = [ PyObject_p ]



# c_int PyFunction_SetDefaults(PyObject_p, PyObject_p)
PyFunction_SetDefaults = _dll.PyFunction_SetDefaults
PyFunction_SetDefaults.restype = c_int
PyFunction_SetDefaults.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyFunction_GetClosure(PyObject_p)
PyFunction_GetClosure = _dll.PyFunction_GetClosure
PyFunction_GetClosure.restype = PyObject_p
PyFunction_GetClosure.argtypes = [ PyObject_p ]



# c_int PyFunction_SetClosure(PyObject_p, PyObject_p)
PyFunction_SetClosure = _dll.PyFunction_SetClosure
PyFunction_SetClosure.restype = c_int
PyFunction_SetClosure.argtypes = [ PyObject_p, PyObject_p ]



# extern PyTypeObject PyClassMethod_Type
PyClassMethod_Type = PyTypeObject.from_address(_dll.PyClassMethod_Type)



# extern PyTypeObject PyStaticMethod_Type
PyStaticMethod_Type = PyTypeObject.from_address(_dll.PyStaticMethod_Type)



# PyObject_p PyClassMethod_New(PyObject_p)
PyClassMethod_New = _dll.PyClassMethod_New
PyClassMethod_New.restype = PyObject_p
PyClassMethod_New.argtypes = [ PyObject_p ]



# PyObject_p PyStaticMethod_New(PyObject_p)
PyStaticMethod_New = _dll.PyStaticMethod_New
PyStaticMethod_New.restype = PyObject_p
PyStaticMethod_New.argtypes = [ PyObject_p ]



# extern PyTypeObject PyClass_Type
PyClass_Type = PyTypeObject.from_address(_dll.PyClass_Type)



# extern PyTypeObject PyInstance_Type
PyInstance_Type = PyTypeObject.from_address(_dll.PyInstance_Type)



# extern PyTypeObject PyMethod_Type
PyMethod_Type = PyTypeObject.from_address(_dll.PyMethod_Type)



# PyObject_p PyClass_New(PyObject_p, PyObject_p, PyObject_p)
PyClass_New = _dll.PyClass_New
PyClass_New.restype = PyObject_p
PyClass_New.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# PyObject_p PyInstance_New(PyObject_p, PyObject_p, PyObject_p)
PyInstance_New = _dll.PyInstance_New
PyInstance_New.restype = PyObject_p
PyInstance_New.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# PyObject_p PyInstance_NewRaw(PyObject_p, PyObject_p)
PyInstance_NewRaw = _dll.PyInstance_NewRaw
PyInstance_NewRaw.restype = PyObject_p
PyInstance_NewRaw.argtypes = [ PyObject_p, PyObject_p ]



# PyObject_p PyMethod_New(PyObject_p, PyObject_p, PyObject_p)
PyMethod_New = _dll.PyMethod_New
PyMethod_New.restype = PyObject_p
PyMethod_New.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# PyObject_p PyMethod_Function(PyObject_p)
PyMethod_Function = _dll.PyMethod_Function
PyMethod_Function.restype = PyObject_p
PyMethod_Function.argtypes = [ PyObject_p ]



# PyObject_p PyMethod_Self(PyObject_p)
PyMethod_Self = _dll.PyMethod_Self
PyMethod_Self.restype = PyObject_p
PyMethod_Self.argtypes = [ PyObject_p ]



# PyObject_p PyMethod_Class(PyObject_p)
PyMethod_Class = _dll.PyMethod_Class
PyMethod_Class.restype = PyObject_p
PyMethod_Class.argtypes = [ PyObject_p ]



# PyObject_p _PyInstance_Lookup(PyObject_ppinst, PyObject_pname)
_PyInstance_Lookup = _dll._PyInstance_Lookup
_PyInstance_Lookup.restype = PyObject_p
_PyInstance_Lookup.argtypes = [ PyObject_ppinst, PyObject_pname ]



# c_int PyClass_IsSubclass(PyObject_p, PyObject_p)
PyClass_IsSubclass = _dll.PyClass_IsSubclass
PyClass_IsSubclass.restype = c_int
PyClass_IsSubclass.argtypes = [ PyObject_p, PyObject_p ]



# c_int PyMethod_ClearFreeList(c_void)
PyMethod_ClearFreeList = _dll.PyMethod_ClearFreeList
PyMethod_ClearFreeList.restype = c_int
PyMethod_ClearFreeList.argtypes = [ c_void ]



# extern PyTypeObject PyFile_Type
PyFile_Type = PyTypeObject.from_address(_dll.PyFile_Type)



# PyObject_p PyFile_FromString(char_p, char_p)
PyFile_FromString = _dll.PyFile_FromString
PyFile_FromString.restype = PyObject_p
PyFile_FromString.argtypes = [ char_p, char_p ]



# c_void PyFile_SetBufSize(PyObject_p, c_int)
PyFile_SetBufSize = _dll.PyFile_SetBufSize
PyFile_SetBufSize.restype = c_void
PyFile_SetBufSize.argtypes = [ PyObject_p, c_int ]



# c_int PyFile_SetEncoding(PyObject_p, char_p)
PyFile_SetEncoding = _dll.PyFile_SetEncoding
PyFile_SetEncoding.restype = c_int
PyFile_SetEncoding.argtypes = [ PyObject_p, char_p ]



# c_int PyFile_SetEncodingAndErrors(PyObject_p, char_p, char_perrors)
PyFile_SetEncodingAndErrors = _dll.PyFile_SetEncodingAndErrors
PyFile_SetEncodingAndErrors.restype = c_int
PyFile_SetEncodingAndErrors.argtypes = [ PyObject_p, char_p, char_perrors ]



# PyObject_p PyFile_FromFile(FILE_p, char_p, char_p, c_int (_p)
PyFile_FromFile = _dll.PyFile_FromFile
PyFile_FromFile.restype = PyObject_p
PyFile_FromFile.argtypes = [ FILE_p, char_p, char_p, c_int (_p ]



# FILE_p PyFile_AsFile(PyObject_p)
PyFile_AsFile = _dll.PyFile_AsFile
PyFile_AsFile.restype = FILE_p
PyFile_AsFile.argtypes = [ PyObject_p ]



# c_void PyFile_IncUseCount(PyFileObject_p)
PyFile_IncUseCount = _dll.PyFile_IncUseCount
PyFile_IncUseCount.restype = c_void
PyFile_IncUseCount.argtypes = [ PyFileObject_p ]



# c_void PyFile_DecUseCount(PyFileObject_p)
PyFile_DecUseCount = _dll.PyFile_DecUseCount
PyFile_DecUseCount.restype = c_void
PyFile_DecUseCount.argtypes = [ PyFileObject_p ]



# PyObject_p PyFile_Name(PyObject_p)
PyFile_Name = _dll.PyFile_Name
PyFile_Name.restype = PyObject_p
PyFile_Name.argtypes = [ PyObject_p ]



# PyObject_p PyFile_GetLine(PyObject_p, c_int)
PyFile_GetLine = _dll.PyFile_GetLine
PyFile_GetLine.restype = PyObject_p
PyFile_GetLine.argtypes = [ PyObject_p, c_int ]



# c_int PyFile_WriteObject(PyObject_p, PyObject_p, c_int)
PyFile_WriteObject = _dll.PyFile_WriteObject
PyFile_WriteObject.restype = c_int
PyFile_WriteObject.argtypes = [ PyObject_p, PyObject_p, c_int ]



# c_int PyFile_SoftSpace(PyObject_p, c_int)
PyFile_SoftSpace = _dll.PyFile_SoftSpace
PyFile_SoftSpace.restype = c_int
PyFile_SoftSpace.argtypes = [ PyObject_p, c_int ]



# c_int PyFile_WriteString(char_p, PyObject_p)
PyFile_WriteString = _dll.PyFile_WriteString
PyFile_WriteString.restype = c_int
PyFile_WriteString.argtypes = [ char_p, PyObject_p ]



# c_int PyObject_AsFileDescriptor(PyObject_p)
PyObject_AsFileDescriptor = _dll.PyObject_AsFileDescriptor
PyObject_AsFileDescriptor.restype = c_int
PyObject_AsFileDescriptor.argtypes = [ PyObject_p ]



# extern char_p Py_FileSystemDefaultEncoding
Py_FileSystemDefaultEncoding = char_p.from_address(_dll.Py_FileSystemDefaultEncoding)



# extern PyTypeObject PyCObject_Type
PyCObject_Type = PyTypeObject.from_address(_dll.PyCObject_Type)



# PyObject_p PyCObject_Fromc_voidPtr( c_void_pcobj, c_void (_pdestruct)
PyCObject_Fromc_voidPtr = _dll.PyCObject_Fromc_voidPtr
PyCObject_Fromc_voidPtr.restype = PyObject_p
PyCObject_Fromc_voidPtr.argtypes = [  c_void_pcobj, c_void (_pdestruct ]



# PyObject_p PyCObject_Fromc_voidPtrAndDesc( c_void_pcobj, c_void_pdesc, c_void (_pdestruct)
PyCObject_Fromc_voidPtrAndDesc = _dll.PyCObject_Fromc_voidPtrAndDesc
PyCObject_Fromc_voidPtrAndDesc.restype = PyObject_p
PyCObject_Fromc_voidPtrAndDesc.argtypes = [  c_void_pcobj, c_void_pdesc, c_void (_pdestruct ]



# c_void_p PyCObject_Asc_voidPtr(PyObject_p)
PyCObject_Asc_voidPtr = _dll.PyCObject_Asc_voidPtr
PyCObject_Asc_voidPtr.restype = c_void_p
PyCObject_Asc_voidPtr.argtypes = [ PyObject_p ]



# c_void_p PyCObject_GetDesc(PyObject_p)
PyCObject_GetDesc = _dll.PyCObject_GetDesc
PyCObject_GetDesc.restype = c_void_p
PyCObject_GetDesc.argtypes = [ PyObject_p ]



# c_void_p PyCObject_Import(char_pmodule_name, char_pcobject_name)
PyCObject_Import = _dll.PyCObject_Import
PyCObject_Import.restype = c_void_p
PyCObject_Import.argtypes = [ char_pmodule_name, char_pcobject_name ]



# c_int PyCObject_Setc_voidPtr(PyObject_pself, c_void_pcobj)
PyCObject_Setc_voidPtr = _dll.PyCObject_Setc_voidPtr
PyCObject_Setc_voidPtr.restype = c_int
PyCObject_Setc_voidPtr.argtypes = [ PyObject_pself, c_void_pcobj ]



# extern PyTypeObject PyCapsule_Type
PyCapsule_Type = PyTypeObject.from_address(_dll.PyCapsule_Type)



# PyObject_p PyCapsule_New( c_void_ppoc_inter, char_pname, PyCapsule_Destructor destructor)
PyCapsule_New = _dll.PyCapsule_New
PyCapsule_New.restype = PyObject_p
PyCapsule_New.argtypes = [  c_void_ppoc_inter, char_pname, PyCapsule_Destructor destructor ]



# c_void_p PyCapsule_GetPoc_inter(PyObject_pcapsule, char_pname)
PyCapsule_GetPoc_inter = _dll.PyCapsule_GetPoc_inter
PyCapsule_GetPoc_inter.restype = c_void_p
PyCapsule_GetPoc_inter.argtypes = [ PyObject_pcapsule, char_pname ]



# PyCapsule_Destructor PyCapsule_GetDestructor(PyObject_pcapsule)
PyCapsule_GetDestructor = _dll.PyCapsule_GetDestructor
PyCapsule_GetDestructor.restype = PyCapsule_Destructor
PyCapsule_GetDestructor.argtypes = [ PyObject_pcapsule ]



# char_p PyCapsule_GetName(PyObject_pcapsule)
PyCapsule_GetName = _dll.PyCapsule_GetName
PyCapsule_GetName.restype = char_p
PyCapsule_GetName.argtypes = [ PyObject_pcapsule ]



# c_void_p PyCapsule_GetContext(PyObject_pcapsule)
PyCapsule_GetContext = _dll.PyCapsule_GetContext
PyCapsule_GetContext.restype = c_void_p
PyCapsule_GetContext.argtypes = [ PyObject_pcapsule ]



# c_int PyCapsule_IsValid(PyObject_pcapsule, char_pname)
PyCapsule_IsValid = _dll.PyCapsule_IsValid
PyCapsule_IsValid.restype = c_int
PyCapsule_IsValid.argtypes = [ PyObject_pcapsule, char_pname ]



# c_int PyCapsule_SetPoc_inter(PyObject_pcapsule, c_void_ppoc_inter)
PyCapsule_SetPoc_inter = _dll.PyCapsule_SetPoc_inter
PyCapsule_SetPoc_inter.restype = c_int
PyCapsule_SetPoc_inter.argtypes = [ PyObject_pcapsule, c_void_ppoc_inter ]



# c_int PyCapsule_SetDestructor(PyObject_pcapsule, PyCapsule_Destructor destructor)
PyCapsule_SetDestructor = _dll.PyCapsule_SetDestructor
PyCapsule_SetDestructor.restype = c_int
PyCapsule_SetDestructor.argtypes = [ PyObject_pcapsule, PyCapsule_Destructor destructor ]



# c_int PyCapsule_SetName(PyObject_pcapsule, char_pname)
PyCapsule_SetName = _dll.PyCapsule_SetName
PyCapsule_SetName.restype = c_int
PyCapsule_SetName.argtypes = [ PyObject_pcapsule, char_pname ]



# c_int PyCapsule_SetContext(PyObject_pcapsule, c_void_pcontext)
PyCapsule_SetContext = _dll.PyCapsule_SetContext
PyCapsule_SetContext.restype = c_int
PyCapsule_SetContext.argtypes = [ PyObject_pcapsule, c_void_pcontext ]



# c_void_p PyCapsule_Import(char_pname, c_int no_block)
PyCapsule_Import = _dll.PyCapsule_Import
PyCapsule_Import.restype = c_void_p
PyCapsule_Import.argtypes = [ char_pname, c_int no_block ]



# c_int PyTraceBack_Here(struct _frame_p)
PyTraceBack_Here = _dll.PyTraceBack_Here
PyTraceBack_Here.restype = c_int
PyTraceBack_Here.argtypes = [ struct _frame_p ]



# c_int PyTraceBack_Prc_int(PyObject_p, PyObject_p)
PyTraceBack_Prc_int = _dll.PyTraceBack_Prc_int
PyTraceBack_Prc_int.restype = c_int
PyTraceBack_Prc_int.argtypes = [ PyObject_p, PyObject_p ]



# c_int _Py_DisplaySourceLine(PyObject_p, char_p, c_int, c_int)
_Py_DisplaySourceLine = _dll._Py_DisplaySourceLine
_Py_DisplaySourceLine.restype = c_int
_Py_DisplaySourceLine.argtypes = [ PyObject_p, char_p, c_int, c_int ]



# extern PyTypeObject PyTraceBack_Type
PyTraceBack_Type = PyTypeObject.from_address(_dll.PyTraceBack_Type)



# extern PyObject _Py_EllipsisObject
_Py_EllipsisObject = PyObject.from_address(_dll._Py_EllipsisObject)



# extern PyTypeObject PySlice_Type
PySlice_Type = PyTypeObject.from_address(_dll.PySlice_Type)



# extern PyTypeObject PyEllipsis_Type
PyEllipsis_Type = PyTypeObject.from_address(_dll.PyEllipsis_Type)



# PyObject_p PySlice_New(PyObject_p start, PyObject_p stop, PyObject_p step)
PySlice_New = _dll.PySlice_New
PySlice_New.restype = PyObject_p
PySlice_New.argtypes = [ PyObject_p start, PyObject_p stop, PyObject_p step ]



# PyObject_p _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop)
_PySlice_FromIndices = _dll._PySlice_FromIndices
_PySlice_FromIndices.restype = PyObject_p
_PySlice_FromIndices.argtypes = [ Py_ssize_t start, Py_ssize_t stop ]



# c_int PySlice_GetIndices(PySliceObject_pr, Py_ssize_t length, Py_ssize_t_pstart, Py_ssize_t_pstop, Py_ssize_t_pstep)
PySlice_GetIndices = _dll.PySlice_GetIndices
PySlice_GetIndices.restype = c_int
PySlice_GetIndices.argtypes = [ PySliceObject_pr, Py_ssize_t length, Py_ssize_t_pstart, Py_ssize_t_pstop, Py_ssize_t_pstep ]



# c_int PySlice_GetIndicesEx(PySliceObject_pr, Py_ssize_t length, Py_ssize_t_pstart, Py_ssize_t_pstop, Py_ssize_t_pstep, Py_ssize_t_pslicelength)
PySlice_GetIndicesEx = _dll.PySlice_GetIndicesEx
PySlice_GetIndicesEx.restype = c_int
PySlice_GetIndicesEx.argtypes = [ PySliceObject_pr, Py_ssize_t length, Py_ssize_t_pstart, Py_ssize_t_pstop, Py_ssize_t_pstep, Py_ssize_t_pslicelength ]



# extern PyTypeObject PyCell_Type
PyCell_Type = PyTypeObject.from_address(_dll.PyCell_Type)



# PyObject_p PyCell_New(PyObject_p)
PyCell_New = _dll.PyCell_New
PyCell_New.restype = PyObject_p
PyCell_New.argtypes = [ PyObject_p ]



# PyObject_p PyCell_Get(PyObject_p)
PyCell_Get = _dll.PyCell_Get
PyCell_Get.restype = PyObject_p
PyCell_Get.argtypes = [ PyObject_p ]



# c_int PyCell_Set(PyObject_p, PyObject_p)
PyCell_Set = _dll.PyCell_Set
PyCell_Set.restype = c_int
PyCell_Set.argtypes = [ PyObject_p, PyObject_p ]



# extern PyTypeObject PySeqIter_Type
PySeqIter_Type = PyTypeObject.from_address(_dll.PySeqIter_Type)



# PyObject_p PySeqIter_New(PyObject_p)
PySeqIter_New = _dll.PySeqIter_New
PySeqIter_New.restype = PyObject_p
PySeqIter_New.argtypes = [ PyObject_p ]



# extern PyTypeObject PyCallIter_Type
PyCallIter_Type = PyTypeObject.from_address(_dll.PyCallIter_Type)



# PyObject_p PyCallIter_New(PyObject_p, PyObject_p)
PyCallIter_New = _dll.PyCallIter_New
PyCallIter_New.restype = PyObject_p
PyCallIter_New.argtypes = [ PyObject_p, PyObject_p ]



# extern PyTypeObject PyGen_Type
PyGen_Type = PyTypeObject.from_address(_dll.PyGen_Type)



# PyObject_p PyGen_New(struct _frame_p)
PyGen_New = _dll.PyGen_New
PyGen_New.restype = PyObject_p
PyGen_New.argtypes = [ struct _frame_p ]



# c_int PyGen_NeedsFinalizing(PyGenObject_p)
PyGen_NeedsFinalizing = _dll.PyGen_NeedsFinalizing
PyGen_NeedsFinalizing.restype = c_int
PyGen_NeedsFinalizing.argtypes = [ PyGenObject_p ]



# extern PyTypeObject PyWrapperDescr_Type
PyWrapperDescr_Type = PyTypeObject.from_address(_dll.PyWrapperDescr_Type)



# extern PyTypeObject PyDictProxy_Type
PyDictProxy_Type = PyTypeObject.from_address(_dll.PyDictProxy_Type)



# extern PyTypeObject PyGetSetDescr_Type
PyGetSetDescr_Type = PyTypeObject.from_address(_dll.PyGetSetDescr_Type)



# extern PyTypeObject PyMemberDescr_Type
PyMemberDescr_Type = PyTypeObject.from_address(_dll.PyMemberDescr_Type)



# PyObject_p PyDescr_NewMethod(PyTypeObject_p, PyMethodDef_p)
PyDescr_NewMethod = _dll.PyDescr_NewMethod
PyDescr_NewMethod.restype = PyObject_p
PyDescr_NewMethod.argtypes = [ PyTypeObject_p, PyMethodDef_p ]



# PyObject_p PyDescr_NewClassMethod(PyTypeObject_p, PyMethodDef_p)
PyDescr_NewClassMethod = _dll.PyDescr_NewClassMethod
PyDescr_NewClassMethod.restype = PyObject_p
PyDescr_NewClassMethod.argtypes = [ PyTypeObject_p, PyMethodDef_p ]



# PyObject_p PyDescr_NewMember(PyTypeObject_p, struct PyMemberDef_p)
PyDescr_NewMember = _dll.PyDescr_NewMember
PyDescr_NewMember.restype = PyObject_p
PyDescr_NewMember.argtypes = [ PyTypeObject_p, struct PyMemberDef_p ]



# PyObject_p PyDescr_NewGetSet(PyTypeObject_p, struct PyGetSetDef_p)
PyDescr_NewGetSet = _dll.PyDescr_NewGetSet
PyDescr_NewGetSet.restype = PyObject_p
PyDescr_NewGetSet.argtypes = [ PyTypeObject_p, struct PyGetSetDef_p ]



# PyObject_p PyDescr_NewWrapper(PyTypeObject_p, struct wrapperbase_p, c_void_p)
PyDescr_NewWrapper = _dll.PyDescr_NewWrapper
PyDescr_NewWrapper.restype = PyObject_p
PyDescr_NewWrapper.argtypes = [ PyTypeObject_p, struct wrapperbase_p, c_void_p ]



# PyObject_p PyDictProxy_New(PyObject_p)
PyDictProxy_New = _dll.PyDictProxy_New
PyDictProxy_New.restype = PyObject_p
PyDictProxy_New.argtypes = [ PyObject_p ]



# PyObject_p PyWrapper_New(PyObject_p, PyObject_p)
PyWrapper_New = _dll.PyWrapper_New
PyWrapper_New.restype = PyObject_p
PyWrapper_New.argtypes = [ PyObject_p, PyObject_p ]



# extern PyTypeObject PyProperty_Type
PyProperty_Type = PyTypeObject.from_address(_dll.PyProperty_Type)



# c_void _PyWarnings_Init(c_void)
_PyWarnings_Init = _dll._PyWarnings_Init
_PyWarnings_Init.restype = c_void
_PyWarnings_Init.argtypes = [ c_void ]



# c_int PyErr_WarnEx(PyObject_p, char_p, Py_ssize_t)
PyErr_WarnEx = _dll.PyErr_WarnEx
PyErr_WarnEx.restype = c_int
PyErr_WarnEx.argtypes = [ PyObject_p, char_p, Py_ssize_t ]



# c_int PyErr_WarnExplicit(PyObject_p, char_p, char_p, c_int, char_p, PyObject_p)
PyErr_WarnExplicit = _dll.PyErr_WarnExplicit
PyErr_WarnExplicit.restype = c_int
PyErr_WarnExplicit.argtypes = [ PyObject_p, char_p, char_p, c_int, char_p, PyObject_p ]



# extern PyTypeObject _PyWeakref_RefType
_PyWeakref_RefType = PyTypeObject.from_address(_dll._PyWeakref_RefType)



# extern PyTypeObject _PyWeakref_ProxyType
_PyWeakref_ProxyType = PyTypeObject.from_address(_dll._PyWeakref_ProxyType)



# extern PyTypeObject _PyWeakref_CallableProxyType
_PyWeakref_CallableProxyType = PyTypeObject.from_address(_dll._PyWeakref_CallableProxyType)



# PyObject_p PyWeakref_NewRef(PyObject_pob, PyObject_pcallback)
PyWeakref_NewRef = _dll.PyWeakref_NewRef
PyWeakref_NewRef.restype = PyObject_p
PyWeakref_NewRef.argtypes = [ PyObject_pob, PyObject_pcallback ]



# PyObject_p PyWeakref_NewProxy(PyObject_pob, PyObject_pcallback)
PyWeakref_NewProxy = _dll.PyWeakref_NewProxy
PyWeakref_NewProxy.restype = PyObject_p
PyWeakref_NewProxy.argtypes = [ PyObject_pob, PyObject_pcallback ]



# PyObject_p PyWeakref_GetObject(PyObject_pref)
PyWeakref_GetObject = _dll.PyWeakref_GetObject
PyWeakref_GetObject.restype = PyObject_p
PyWeakref_GetObject.argtypes = [ PyObject_pref ]



# Py_ssize_t _PyWeakref_GetWeakrefCount(PyWeakReference_phead)
_PyWeakref_GetWeakrefCount = _dll._PyWeakref_GetWeakrefCount
_PyWeakref_GetWeakrefCount.restype = Py_ssize_t
_PyWeakref_GetWeakrefCount.argtypes = [ PyWeakReference_phead ]



# c_void _PyWeakref_ClearRef(PyWeakReference_pself)
_PyWeakref_ClearRef = _dll._PyWeakref_ClearRef
_PyWeakref_ClearRef.restype = c_void
_PyWeakref_ClearRef.argtypes = [ PyWeakReference_pself ]



# c_int PyCodec_Register( PyObject_psearch_function )
PyCodec_Register = _dll.PyCodec_Register
PyCodec_Register.restype = c_int
PyCodec_Register.argtypes = [  PyObject_psearch_function  ]



# PyObject_p _PyCodec_Lookup( char_pencoding )
_PyCodec_Lookup = _dll._PyCodec_Lookup
_PyCodec_Lookup.restype = PyObject_p
_PyCodec_Lookup.argtypes = [  char_pencoding  ]



# PyObject_p PyCodec_Encode( PyObject_pobject, char_pencoding, char_perrors )
PyCodec_Encode = _dll.PyCodec_Encode
PyCodec_Encode.restype = PyObject_p
PyCodec_Encode.argtypes = [  PyObject_pobject, char_pencoding, char_perrors  ]



# PyObject_p PyCodec_Decode( PyObject_pobject, char_pencoding, char_perrors )
PyCodec_Decode = _dll.PyCodec_Decode
PyCodec_Decode.restype = PyObject_p
PyCodec_Decode.argtypes = [  PyObject_pobject, char_pencoding, char_perrors  ]



# PyObject_p PyCodec_Encoder( char_pencoding )
PyCodec_Encoder = _dll.PyCodec_Encoder
PyCodec_Encoder.restype = PyObject_p
PyCodec_Encoder.argtypes = [  char_pencoding  ]



# PyObject_p PyCodec_Decoder( char_pencoding )
PyCodec_Decoder = _dll.PyCodec_Decoder
PyCodec_Decoder.restype = PyObject_p
PyCodec_Decoder.argtypes = [  char_pencoding  ]



# PyObject_p PyCodec_IncrementalEncoder( char_pencoding, char_perrors )
PyCodec_IncrementalEncoder = _dll.PyCodec_IncrementalEncoder
PyCodec_IncrementalEncoder.restype = PyObject_p
PyCodec_IncrementalEncoder.argtypes = [  char_pencoding, char_perrors  ]



# PyObject_p PyCodec_IncrementalDecoder( char_pencoding, char_perrors )
PyCodec_IncrementalDecoder = _dll.PyCodec_IncrementalDecoder
PyCodec_IncrementalDecoder.restype = PyObject_p
PyCodec_IncrementalDecoder.argtypes = [  char_pencoding, char_perrors  ]



# PyObject_p PyCodec_StreamReader( char_pencoding, PyObject_pstream, char_perrors )
PyCodec_StreamReader = _dll.PyCodec_StreamReader
PyCodec_StreamReader.restype = PyObject_p
PyCodec_StreamReader.argtypes = [  char_pencoding, PyObject_pstream, char_perrors  ]



# PyObject_p PyCodec_StreamWriter( char_pencoding, PyObject_pstream, char_perrors )
PyCodec_StreamWriter = _dll.PyCodec_StreamWriter
PyCodec_StreamWriter.restype = PyObject_p
PyCodec_StreamWriter.argtypes = [  char_pencoding, PyObject_pstream, char_perrors  ]



# c_int PyCodec_RegisterError(char_pname, PyObject_perror)
PyCodec_RegisterError = _dll.PyCodec_RegisterError
PyCodec_RegisterError.restype = c_int
PyCodec_RegisterError.argtypes = [ char_pname, PyObject_perror ]



# PyObject_p PyCodec_LookupError(char_pname)
PyCodec_LookupError = _dll.PyCodec_LookupError
PyCodec_LookupError.restype = PyObject_p
PyCodec_LookupError.argtypes = [ char_pname ]



# PyObject_p PyCodec_StrictErrors(PyObject_pexc)
PyCodec_StrictErrors = _dll.PyCodec_StrictErrors
PyCodec_StrictErrors.restype = PyObject_p
PyCodec_StrictErrors.argtypes = [ PyObject_pexc ]



# PyObject_p PyCodec_IgnoreErrors(PyObject_pexc)
PyCodec_IgnoreErrors = _dll.PyCodec_IgnoreErrors
PyCodec_IgnoreErrors.restype = PyObject_p
PyCodec_IgnoreErrors.argtypes = [ PyObject_pexc ]



# PyObject_p PyCodec_ReplaceErrors(PyObject_pexc)
PyCodec_ReplaceErrors = _dll.PyCodec_ReplaceErrors
PyCodec_ReplaceErrors.restype = PyObject_p
PyCodec_ReplaceErrors.argtypes = [ PyObject_pexc ]



# PyObject_p PyCodec_XMLCharRefReplaceErrors(PyObject_pexc)
PyCodec_XMLCharRefReplaceErrors = _dll.PyCodec_XMLCharRefReplaceErrors
PyCodec_XMLCharRefReplaceErrors.restype = PyObject_p
PyCodec_XMLCharRefReplaceErrors.argtypes = [ PyObject_pexc ]



# PyObject_p PyCodec_BackslashReplaceErrors(PyObject_pexc)
PyCodec_BackslashReplaceErrors = _dll.PyCodec_BackslashReplaceErrors
PyCodec_BackslashReplaceErrors.restype = PyObject_p
PyCodec_BackslashReplaceErrors.argtypes = [ PyObject_pexc ]



# c_void PyErr_SetNone(PyObject_p)
PyErr_SetNone = _dll.PyErr_SetNone
PyErr_SetNone.restype = c_void
PyErr_SetNone.argtypes = [ PyObject_p ]



# c_void PyErr_SetObject(PyObject_p, PyObject_p)
PyErr_SetObject = _dll.PyErr_SetObject
PyErr_SetObject.restype = c_void
PyErr_SetObject.argtypes = [ PyObject_p, PyObject_p ]



# c_void PyErr_SetString(PyObject_p, char_p)
PyErr_SetString = _dll.PyErr_SetString
PyErr_SetString.restype = c_void
PyErr_SetString.argtypes = [ PyObject_p, char_p ]



# PyObject_p PyErr_Occurred(c_void)
PyErr_Occurred = _dll.PyErr_Occurred
PyErr_Occurred.restype = PyObject_p
PyErr_Occurred.argtypes = [ c_void ]



# c_void PyErr_Clear(c_void)
PyErr_Clear = _dll.PyErr_Clear
PyErr_Clear.restype = c_void
PyErr_Clear.argtypes = [ c_void ]



# c_void PyErr_Fetch(PyObject_p_p, PyObject_p_p, PyObject_p_p)
PyErr_Fetch = _dll.PyErr_Fetch
PyErr_Fetch.restype = c_void
PyErr_Fetch.argtypes = [ PyObject_p_p, PyObject_p_p, PyObject_p_p ]



# c_void PyErr_Restore(PyObject_p, PyObject_p, PyObject_p)
PyErr_Restore = _dll.PyErr_Restore
PyErr_Restore.restype = c_void
PyErr_Restore.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# c_int PyErr_GivenExceptionMatches(PyObject_p, PyObject_p)
PyErr_GivenExceptionMatches = _dll.PyErr_GivenExceptionMatches
PyErr_GivenExceptionMatches.restype = c_int
PyErr_GivenExceptionMatches.argtypes = [ PyObject_p, PyObject_p ]



# c_int PyErr_ExceptionMatches(PyObject_p)
PyErr_ExceptionMatches = _dll.PyErr_ExceptionMatches
PyErr_ExceptionMatches.restype = c_int
PyErr_ExceptionMatches.argtypes = [ PyObject_p ]



# c_void PyErr_NormalizeException(PyObject_p_p, PyObject_p_p, PyObject_p_p)
PyErr_NormalizeException = _dll.PyErr_NormalizeException
PyErr_NormalizeException.restype = c_void
PyErr_NormalizeException.argtypes = [ PyObject_p_p, PyObject_p_p, PyObject_p_p ]



# extern PyObject_p PyExc_BaseException
PyExc_BaseException = PyObject_p.from_address(_dll.PyExc_BaseException)



# extern PyObject_p PyExc_Exception
PyExc_Exception = PyObject_p.from_address(_dll.PyExc_Exception)



# extern PyObject_p PyExc_StopIteration
PyExc_StopIteration = PyObject_p.from_address(_dll.PyExc_StopIteration)



# extern PyObject_p PyExc_GeneratorExit
PyExc_GeneratorExit = PyObject_p.from_address(_dll.PyExc_GeneratorExit)



# extern PyObject_p PyExc_StandardError
PyExc_StandardError = PyObject_p.from_address(_dll.PyExc_StandardError)



# extern PyObject_p PyExc_ArithmeticError
PyExc_ArithmeticError = PyObject_p.from_address(_dll.PyExc_ArithmeticError)



# extern PyObject_p PyExc_LookupError
PyExc_LookupError = PyObject_p.from_address(_dll.PyExc_LookupError)



# extern PyObject_p PyExc_AssertionError
PyExc_AssertionError = PyObject_p.from_address(_dll.PyExc_AssertionError)



# extern PyObject_p PyExc_AttributeError
PyExc_AttributeError = PyObject_p.from_address(_dll.PyExc_AttributeError)



# extern PyObject_p PyExc_EOFError
PyExc_EOFError = PyObject_p.from_address(_dll.PyExc_EOFError)



# extern PyObject_p PyExc_FloatingPoc_intError
PyExc_FloatingPoc_intError = PyObject_p.from_address(_dll.PyExc_FloatingPoc_intError)



# extern PyObject_p PyExc_EnvironmentError
PyExc_EnvironmentError = PyObject_p.from_address(_dll.PyExc_EnvironmentError)



# extern PyObject_p PyExc_IOError
PyExc_IOError = PyObject_p.from_address(_dll.PyExc_IOError)



# extern PyObject_p PyExc_OSError
PyExc_OSError = PyObject_p.from_address(_dll.PyExc_OSError)



# extern PyObject_p PyExc_ImportError
PyExc_ImportError = PyObject_p.from_address(_dll.PyExc_ImportError)



# extern PyObject_p PyExc_IndexError
PyExc_IndexError = PyObject_p.from_address(_dll.PyExc_IndexError)



# extern PyObject_p PyExc_KeyError
PyExc_KeyError = PyObject_p.from_address(_dll.PyExc_KeyError)



# extern PyObject_p PyExc_Keyboardc_interrupt
PyExc_Keyboardc_interrupt = PyObject_p.from_address(_dll.PyExc_Keyboardc_interrupt)



# extern PyObject_p PyExc_MemoryError
PyExc_MemoryError = PyObject_p.from_address(_dll.PyExc_MemoryError)



# extern PyObject_p PyExc_NameError
PyExc_NameError = PyObject_p.from_address(_dll.PyExc_NameError)



# extern PyObject_p PyExc_OverflowError
PyExc_OverflowError = PyObject_p.from_address(_dll.PyExc_OverflowError)



# extern PyObject_p PyExc_RuntimeError
PyExc_RuntimeError = PyObject_p.from_address(_dll.PyExc_RuntimeError)



# extern PyObject_p PyExc_NotImplementedError
PyExc_NotImplementedError = PyObject_p.from_address(_dll.PyExc_NotImplementedError)



# extern PyObject_p PyExc_SyntaxError
PyExc_SyntaxError = PyObject_p.from_address(_dll.PyExc_SyntaxError)



# extern PyObject_p PyExc_IndentationError
PyExc_IndentationError = PyObject_p.from_address(_dll.PyExc_IndentationError)



# extern PyObject_p PyExc_TabError
PyExc_TabError = PyObject_p.from_address(_dll.PyExc_TabError)



# extern PyObject_p PyExc_ReferenceError
PyExc_ReferenceError = PyObject_p.from_address(_dll.PyExc_ReferenceError)



# extern PyObject_p PyExc_SystemError
PyExc_SystemError = PyObject_p.from_address(_dll.PyExc_SystemError)



# extern PyObject_p PyExc_SystemExit
PyExc_SystemExit = PyObject_p.from_address(_dll.PyExc_SystemExit)



# extern PyObject_p PyExc_TypeError
PyExc_TypeError = PyObject_p.from_address(_dll.PyExc_TypeError)



# extern PyObject_p PyExc_UnboundLocalError
PyExc_UnboundLocalError = PyObject_p.from_address(_dll.PyExc_UnboundLocalError)



# extern PyObject_p PyExc_UnicodeError
PyExc_UnicodeError = PyObject_p.from_address(_dll.PyExc_UnicodeError)



# extern PyObject_p PyExc_UnicodeEncodeError
PyExc_UnicodeEncodeError = PyObject_p.from_address(_dll.PyExc_UnicodeEncodeError)



# extern PyObject_p PyExc_UnicodeDecodeError
PyExc_UnicodeDecodeError = PyObject_p.from_address(_dll.PyExc_UnicodeDecodeError)



# extern PyObject_p PyExc_UnicodeTranslateError
PyExc_UnicodeTranslateError = PyObject_p.from_address(_dll.PyExc_UnicodeTranslateError)



# extern PyObject_p PyExc_ValueError
PyExc_ValueError = PyObject_p.from_address(_dll.PyExc_ValueError)



# extern PyObject_p PyExc_ZeroDivisionError
PyExc_ZeroDivisionError = PyObject_p.from_address(_dll.PyExc_ZeroDivisionError)



# extern PyObject_p PyExc_WindowsError
PyExc_WindowsError = PyObject_p.from_address(_dll.PyExc_WindowsError)



# extern PyObject_p PyExc_BufferError
PyExc_BufferError = PyObject_p.from_address(_dll.PyExc_BufferError)



# extern PyObject_p PyExc_MemoryErrorInst
PyExc_MemoryErrorInst = PyObject_p.from_address(_dll.PyExc_MemoryErrorInst)



# extern PyObject_p PyExc_RecursionErrorInst
PyExc_RecursionErrorInst = PyObject_p.from_address(_dll.PyExc_RecursionErrorInst)



# extern PyObject_p PyExc_Warning
PyExc_Warning = PyObject_p.from_address(_dll.PyExc_Warning)



# extern PyObject_p PyExc_UserWarning
PyExc_UserWarning = PyObject_p.from_address(_dll.PyExc_UserWarning)



# extern PyObject_p PyExc_DeprecationWarning
PyExc_DeprecationWarning = PyObject_p.from_address(_dll.PyExc_DeprecationWarning)



# extern PyObject_p PyExc_PendingDeprecationWarning
PyExc_PendingDeprecationWarning = PyObject_p.from_address(_dll.PyExc_PendingDeprecationWarning)



# extern PyObject_p PyExc_SyntaxWarning
PyExc_SyntaxWarning = PyObject_p.from_address(_dll.PyExc_SyntaxWarning)



# extern PyObject_p PyExc_RuntimeWarning
PyExc_RuntimeWarning = PyObject_p.from_address(_dll.PyExc_RuntimeWarning)



# extern PyObject_p PyExc_FutureWarning
PyExc_FutureWarning = PyObject_p.from_address(_dll.PyExc_FutureWarning)



# extern PyObject_p PyExc_ImportWarning
PyExc_ImportWarning = PyObject_p.from_address(_dll.PyExc_ImportWarning)



# extern PyObject_p PyExc_UnicodeWarning
PyExc_UnicodeWarning = PyObject_p.from_address(_dll.PyExc_UnicodeWarning)



# extern PyObject_p PyExc_BytesWarning
PyExc_BytesWarning = PyObject_p.from_address(_dll.PyExc_BytesWarning)



# c_int PyErr_BadArgument(c_void)
PyErr_BadArgument = _dll.PyErr_BadArgument
PyErr_BadArgument.restype = c_int
PyErr_BadArgument.argtypes = [ c_void ]



# PyObject_p PyErr_NoMemory(c_void)
PyErr_NoMemory = _dll.PyErr_NoMemory
PyErr_NoMemory.restype = PyObject_p
PyErr_NoMemory.argtypes = [ c_void ]



# PyObject_p PyErr_SetFromErrno(PyObject_p)
PyErr_SetFromErrno = _dll.PyErr_SetFromErrno
PyErr_SetFromErrno.restype = PyObject_p
PyErr_SetFromErrno.argtypes = [ PyObject_p ]



# PyObject_p PyErr_SetFromErrnoWithFilenameObject( PyObject_p, PyObject_p)
PyErr_SetFromErrnoWithFilenameObject = _dll.PyErr_SetFromErrnoWithFilenameObject
PyErr_SetFromErrnoWithFilenameObject.restype = PyObject_p
PyErr_SetFromErrnoWithFilenameObject.argtypes = [  PyObject_p, PyObject_p ]



# PyObject_p PyErr_SetFromErrnoWithFilename( PyObject_p, char_p)
PyErr_SetFromErrnoWithFilename = _dll.PyErr_SetFromErrnoWithFilename
PyErr_SetFromErrnoWithFilename.restype = PyObject_p
PyErr_SetFromErrnoWithFilename.argtypes = [  PyObject_p, char_p ]



# PyObject_p PyErr_SetFromErrnoWithUnicodeFilename( PyObject_p, Py_UNICODE_p)
PyErr_SetFromErrnoWithUnicodeFilename = _dll.PyErr_SetFromErrnoWithUnicodeFilename
PyErr_SetFromErrnoWithUnicodeFilename.restype = PyObject_p
PyErr_SetFromErrnoWithUnicodeFilename.argtypes = [  PyObject_p, Py_UNICODE_p ]



# PyObject_p PyErr_Format(PyObject_p, char_p, ...)
PyErr_Format = _dll.PyErr_Format
PyErr_Format.restype = PyObject_p
PyErr_Format.argtypes = [ PyObject_p, char_p, ... ]



# PyObject_p PyErr_SetFromWindowsErrWithFilename( c_int, char_p)
PyErr_SetFromWindowsErrWithFilename = _dll.PyErr_SetFromWindowsErrWithFilename
PyErr_SetFromWindowsErrWithFilename.restype = PyObject_p
PyErr_SetFromWindowsErrWithFilename.argtypes = [  c_int, char_p ]



# PyObject_p PyErr_SetFromWindowsErrWithUnicodeFilename( c_int, Py_UNICODE_p)
PyErr_SetFromWindowsErrWithUnicodeFilename = _dll.PyErr_SetFromWindowsErrWithUnicodeFilename
PyErr_SetFromWindowsErrWithUnicodeFilename.restype = PyObject_p
PyErr_SetFromWindowsErrWithUnicodeFilename.argtypes = [  c_int, Py_UNICODE_p ]



# PyObject_p PyErr_SetFromWindowsErr(c_int)
PyErr_SetFromWindowsErr = _dll.PyErr_SetFromWindowsErr
PyErr_SetFromWindowsErr.restype = PyObject_p
PyErr_SetFromWindowsErr.argtypes = [ c_int ]



# PyObject_p PyErr_SetExcFromWindowsErrWithFilenameObject( PyObject_p,c_int, PyObject_p)
PyErr_SetExcFromWindowsErrWithFilenameObject = _dll.PyErr_SetExcFromWindowsErrWithFilenameObject
PyErr_SetExcFromWindowsErrWithFilenameObject.restype = PyObject_p
PyErr_SetExcFromWindowsErrWithFilenameObject.argtypes = [  PyObject_p,c_int, PyObject_p ]



# PyObject_p PyErr_SetExcFromWindowsErrWithFilename( PyObject_p,c_int, char_p)
PyErr_SetExcFromWindowsErrWithFilename = _dll.PyErr_SetExcFromWindowsErrWithFilename
PyErr_SetExcFromWindowsErrWithFilename.restype = PyObject_p
PyErr_SetExcFromWindowsErrWithFilename.argtypes = [  PyObject_p,c_int, char_p ]



# PyObject_p PyErr_SetExcFromWindowsErrWithUnicodeFilename( PyObject_p,c_int, Py_UNICODE_p)
PyErr_SetExcFromWindowsErrWithUnicodeFilename = _dll.PyErr_SetExcFromWindowsErrWithUnicodeFilename
PyErr_SetExcFromWindowsErrWithUnicodeFilename.restype = PyObject_p
PyErr_SetExcFromWindowsErrWithUnicodeFilename.argtypes = [  PyObject_p,c_int, Py_UNICODE_p ]



# PyObject_p PyErr_SetExcFromWindowsErr(PyObject_p, c_int)
PyErr_SetExcFromWindowsErr = _dll.PyErr_SetExcFromWindowsErr
PyErr_SetExcFromWindowsErr.restype = PyObject_p
PyErr_SetExcFromWindowsErr.argtypes = [ PyObject_p, c_int ]



# c_void _PyErr_Badc_internalCall(char_pfilename, c_int lineno)
_PyErr_Badc_internalCall = _dll._PyErr_Badc_internalCall
_PyErr_Badc_internalCall.restype = c_void
_PyErr_Badc_internalCall.argtypes = [ char_pfilename, c_int lineno ]



# PyObject_p PyErr_NewException( char_pname, PyObject_pbase, PyObject_pdict)
PyErr_NewException = _dll.PyErr_NewException
PyErr_NewException.restype = PyObject_p
PyErr_NewException.argtypes = [  char_pname, PyObject_pbase, PyObject_pdict ]



# PyObject_p PyErr_NewExceptionWithDoc( char_pname, char_pdoc, PyObject_pbase, PyObject_pdict)
PyErr_NewExceptionWithDoc = _dll.PyErr_NewExceptionWithDoc
PyErr_NewExceptionWithDoc.restype = PyObject_p
PyErr_NewExceptionWithDoc.argtypes = [  char_pname, char_pdoc, PyObject_pbase, PyObject_pdict ]



# c_void PyErr_WriteUnraisable(PyObject_p)
PyErr_WriteUnraisable = _dll.PyErr_WriteUnraisable
PyErr_WriteUnraisable.restype = c_void
PyErr_WriteUnraisable.argtypes = [ PyObject_p ]



# c_int PyErr_CheckSignals(c_void)
PyErr_CheckSignals = _dll.PyErr_CheckSignals
PyErr_CheckSignals.restype = c_int
PyErr_CheckSignals.argtypes = [ c_void ]



# c_void PyErr_Setc_interrupt(c_void)
PyErr_Setc_interrupt = _dll.PyErr_Setc_interrupt
PyErr_Setc_interrupt.restype = c_void
PyErr_Setc_interrupt.argtypes = [ c_void ]



# c_void PyErr_SyntaxLocation(char_p, c_int)
PyErr_SyntaxLocation = _dll.PyErr_SyntaxLocation
PyErr_SyntaxLocation.restype = c_void
PyErr_SyntaxLocation.argtypes = [ char_p, c_int ]



# PyObject_p PyErr_ProgramText(char_p, c_int)
PyErr_ProgramText = _dll.PyErr_ProgramText
PyErr_ProgramText.restype = PyObject_p
PyErr_ProgramText.argtypes = [ char_p, c_int ]



# PyObject_p PyUnicodeDecodeError_Create( char_p, char_p, Py_ssize_t, Py_ssize_t, Py_ssize_t, char_p)
PyUnicodeDecodeError_Create = _dll.PyUnicodeDecodeError_Create
PyUnicodeDecodeError_Create.restype = PyObject_p
PyUnicodeDecodeError_Create.argtypes = [  char_p, char_p, Py_ssize_t, Py_ssize_t, Py_ssize_t, char_p ]



# PyObject_p PyUnicodeEncodeError_Create( char_p, Py_UNICODE_p, Py_ssize_t, Py_ssize_t, Py_ssize_t, char_p)
PyUnicodeEncodeError_Create = _dll.PyUnicodeEncodeError_Create
PyUnicodeEncodeError_Create.restype = PyObject_p
PyUnicodeEncodeError_Create.argtypes = [  char_p, Py_UNICODE_p, Py_ssize_t, Py_ssize_t, Py_ssize_t, char_p ]



# PyObject_p PyUnicodeTranslateError_Create( Py_UNICODE_p, Py_ssize_t, Py_ssize_t, Py_ssize_t, char_p)
PyUnicodeTranslateError_Create = _dll.PyUnicodeTranslateError_Create
PyUnicodeTranslateError_Create.restype = PyObject_p
PyUnicodeTranslateError_Create.argtypes = [  Py_UNICODE_p, Py_ssize_t, Py_ssize_t, Py_ssize_t, char_p ]



# PyObject_p PyUnicodeEncodeError_GetEncoding(PyObject_p)
PyUnicodeEncodeError_GetEncoding = _dll.PyUnicodeEncodeError_GetEncoding
PyUnicodeEncodeError_GetEncoding.restype = PyObject_p
PyUnicodeEncodeError_GetEncoding.argtypes = [ PyObject_p ]



# PyObject_p PyUnicodeDecodeError_GetEncoding(PyObject_p)
PyUnicodeDecodeError_GetEncoding = _dll.PyUnicodeDecodeError_GetEncoding
PyUnicodeDecodeError_GetEncoding.restype = PyObject_p
PyUnicodeDecodeError_GetEncoding.argtypes = [ PyObject_p ]



# PyObject_p PyUnicodeEncodeError_GetObject(PyObject_p)
PyUnicodeEncodeError_GetObject = _dll.PyUnicodeEncodeError_GetObject
PyUnicodeEncodeError_GetObject.restype = PyObject_p
PyUnicodeEncodeError_GetObject.argtypes = [ PyObject_p ]



# PyObject_p PyUnicodeDecodeError_GetObject(PyObject_p)
PyUnicodeDecodeError_GetObject = _dll.PyUnicodeDecodeError_GetObject
PyUnicodeDecodeError_GetObject.restype = PyObject_p
PyUnicodeDecodeError_GetObject.argtypes = [ PyObject_p ]



# PyObject_p PyUnicodeTranslateError_GetObject(PyObject_p)
PyUnicodeTranslateError_GetObject = _dll.PyUnicodeTranslateError_GetObject
PyUnicodeTranslateError_GetObject.restype = PyObject_p
PyUnicodeTranslateError_GetObject.argtypes = [ PyObject_p ]



# c_int PyUnicodeEncodeError_GetStart(PyObject_p, Py_ssize_t_p)
PyUnicodeEncodeError_GetStart = _dll.PyUnicodeEncodeError_GetStart
PyUnicodeEncodeError_GetStart.restype = c_int
PyUnicodeEncodeError_GetStart.argtypes = [ PyObject_p, Py_ssize_t_p ]



# c_int PyUnicodeDecodeError_GetStart(PyObject_p, Py_ssize_t_p)
PyUnicodeDecodeError_GetStart = _dll.PyUnicodeDecodeError_GetStart
PyUnicodeDecodeError_GetStart.restype = c_int
PyUnicodeDecodeError_GetStart.argtypes = [ PyObject_p, Py_ssize_t_p ]



# c_int PyUnicodeTranslateError_GetStart(PyObject_p, Py_ssize_t_p)
PyUnicodeTranslateError_GetStart = _dll.PyUnicodeTranslateError_GetStart
PyUnicodeTranslateError_GetStart.restype = c_int
PyUnicodeTranslateError_GetStart.argtypes = [ PyObject_p, Py_ssize_t_p ]



# c_int PyUnicodeEncodeError_SetStart(PyObject_p, Py_ssize_t)
PyUnicodeEncodeError_SetStart = _dll.PyUnicodeEncodeError_SetStart
PyUnicodeEncodeError_SetStart.restype = c_int
PyUnicodeEncodeError_SetStart.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyUnicodeDecodeError_SetStart(PyObject_p, Py_ssize_t)
PyUnicodeDecodeError_SetStart = _dll.PyUnicodeDecodeError_SetStart
PyUnicodeDecodeError_SetStart.restype = c_int
PyUnicodeDecodeError_SetStart.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyUnicodeTranslateError_SetStart(PyObject_p, Py_ssize_t)
PyUnicodeTranslateError_SetStart = _dll.PyUnicodeTranslateError_SetStart
PyUnicodeTranslateError_SetStart.restype = c_int
PyUnicodeTranslateError_SetStart.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyUnicodeEncodeError_GetEnd(PyObject_p, Py_ssize_t_p)
PyUnicodeEncodeError_GetEnd = _dll.PyUnicodeEncodeError_GetEnd
PyUnicodeEncodeError_GetEnd.restype = c_int
PyUnicodeEncodeError_GetEnd.argtypes = [ PyObject_p, Py_ssize_t_p ]



# c_int PyUnicodeDecodeError_GetEnd(PyObject_p, Py_ssize_t_p)
PyUnicodeDecodeError_GetEnd = _dll.PyUnicodeDecodeError_GetEnd
PyUnicodeDecodeError_GetEnd.restype = c_int
PyUnicodeDecodeError_GetEnd.argtypes = [ PyObject_p, Py_ssize_t_p ]



# c_int PyUnicodeTranslateError_GetEnd(PyObject_p, Py_ssize_t_p)
PyUnicodeTranslateError_GetEnd = _dll.PyUnicodeTranslateError_GetEnd
PyUnicodeTranslateError_GetEnd.restype = c_int
PyUnicodeTranslateError_GetEnd.argtypes = [ PyObject_p, Py_ssize_t_p ]



# c_int PyUnicodeEncodeError_SetEnd(PyObject_p, Py_ssize_t)
PyUnicodeEncodeError_SetEnd = _dll.PyUnicodeEncodeError_SetEnd
PyUnicodeEncodeError_SetEnd.restype = c_int
PyUnicodeEncodeError_SetEnd.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyUnicodeDecodeError_SetEnd(PyObject_p, Py_ssize_t)
PyUnicodeDecodeError_SetEnd = _dll.PyUnicodeDecodeError_SetEnd
PyUnicodeDecodeError_SetEnd.restype = c_int
PyUnicodeDecodeError_SetEnd.argtypes = [ PyObject_p, Py_ssize_t ]



# c_int PyUnicodeTranslateError_SetEnd(PyObject_p, Py_ssize_t)
PyUnicodeTranslateError_SetEnd = _dll.PyUnicodeTranslateError_SetEnd
PyUnicodeTranslateError_SetEnd.restype = c_int
PyUnicodeTranslateError_SetEnd.argtypes = [ PyObject_p, Py_ssize_t ]



# PyObject_p PyUnicodeEncodeError_GetReason(PyObject_p)
PyUnicodeEncodeError_GetReason = _dll.PyUnicodeEncodeError_GetReason
PyUnicodeEncodeError_GetReason.restype = PyObject_p
PyUnicodeEncodeError_GetReason.argtypes = [ PyObject_p ]



# PyObject_p PyUnicodeDecodeError_GetReason(PyObject_p)
PyUnicodeDecodeError_GetReason = _dll.PyUnicodeDecodeError_GetReason
PyUnicodeDecodeError_GetReason.restype = PyObject_p
PyUnicodeDecodeError_GetReason.argtypes = [ PyObject_p ]



# PyObject_p PyUnicodeTranslateError_GetReason(PyObject_p)
PyUnicodeTranslateError_GetReason = _dll.PyUnicodeTranslateError_GetReason
PyUnicodeTranslateError_GetReason.restype = PyObject_p
PyUnicodeTranslateError_GetReason.argtypes = [ PyObject_p ]



# c_int PyUnicodeEncodeError_SetReason( PyObject_p, char_p)
PyUnicodeEncodeError_SetReason = _dll.PyUnicodeEncodeError_SetReason
PyUnicodeEncodeError_SetReason.restype = c_int
PyUnicodeEncodeError_SetReason.argtypes = [  PyObject_p, char_p ]



# c_int PyUnicodeDecodeError_SetReason( PyObject_p, char_p)
PyUnicodeDecodeError_SetReason = _dll.PyUnicodeDecodeError_SetReason
PyUnicodeDecodeError_SetReason.restype = c_int
PyUnicodeDecodeError_SetReason.argtypes = [  PyObject_p, char_p ]



# c_int PyUnicodeTranslateError_SetReason( PyObject_p, char_p)
PyUnicodeTranslateError_SetReason = _dll.PyUnicodeTranslateError_SetReason
PyUnicodeTranslateError_SetReason.restype = c_int
PyUnicodeTranslateError_SetReason.argtypes = [  PyObject_p, char_p ]



# c_int PyOS_snprc_intf(char_pstr, c_size_t size, char_pformat, ...)
PyOS_snprc_intf = _dll.PyOS_snprc_intf
PyOS_snprc_intf.restype = c_int
PyOS_snprc_intf.argtypes = [ char_pstr, c_size_t size, char_pformat, ... ]



# c_int PyOS_vsnprc_intf(char_pstr, c_size_t size, char_pformat, va_list va)
PyOS_vsnprc_intf = _dll.PyOS_vsnprc_intf
PyOS_vsnprc_intf.restype = c_int
PyOS_vsnprc_intf.argtypes = [ char_pstr, c_size_t size, char_pformat, va_list va ]



# Pyc_interpreterState_p Pyc_interpreterState_New(c_void)
Pyc_interpreterState_New = _dll.Pyc_interpreterState_New
Pyc_interpreterState_New.restype = Pyc_interpreterState_p
Pyc_interpreterState_New.argtypes = [ c_void ]



# c_void Pyc_interpreterState_Clear(Pyc_interpreterState_p)
Pyc_interpreterState_Clear = _dll.Pyc_interpreterState_Clear
Pyc_interpreterState_Clear.restype = c_void
Pyc_interpreterState_Clear.argtypes = [ Pyc_interpreterState_p ]



# c_void Pyc_interpreterState_Delete(Pyc_interpreterState_p)
Pyc_interpreterState_Delete = _dll.Pyc_interpreterState_Delete
Pyc_interpreterState_Delete.restype = c_void
Pyc_interpreterState_Delete.argtypes = [ Pyc_interpreterState_p ]



# PyThreadState_p PyThreadState_New(Pyc_interpreterState_p)
PyThreadState_New = _dll.PyThreadState_New
PyThreadState_New.restype = PyThreadState_p
PyThreadState_New.argtypes = [ Pyc_interpreterState_p ]



# PyThreadState_p _PyThreadState_Prealloc(Pyc_interpreterState_p)
_PyThreadState_Prealloc = _dll._PyThreadState_Prealloc
_PyThreadState_Prealloc.restype = PyThreadState_p
_PyThreadState_Prealloc.argtypes = [ Pyc_interpreterState_p ]



# c_void _PyThreadState_Init(PyThreadState_p)
_PyThreadState_Init = _dll._PyThreadState_Init
_PyThreadState_Init.restype = c_void
_PyThreadState_Init.argtypes = [ PyThreadState_p ]



# c_void PyThreadState_Clear(PyThreadState_p)
PyThreadState_Clear = _dll.PyThreadState_Clear
PyThreadState_Clear.restype = c_void
PyThreadState_Clear.argtypes = [ PyThreadState_p ]



# c_void PyThreadState_Delete(PyThreadState_p)
PyThreadState_Delete = _dll.PyThreadState_Delete
PyThreadState_Delete.restype = c_void
PyThreadState_Delete.argtypes = [ PyThreadState_p ]



# c_void PyThreadState_DeleteCurrent(c_void)
PyThreadState_DeleteCurrent = _dll.PyThreadState_DeleteCurrent
PyThreadState_DeleteCurrent.restype = c_void
PyThreadState_DeleteCurrent.argtypes = [ c_void ]



# c_void _PyGILState_Reinit(c_void)
_PyGILState_Reinit = _dll._PyGILState_Reinit
_PyGILState_Reinit.restype = c_void
_PyGILState_Reinit.argtypes = [ c_void ]



# PyThreadState_p PyThreadState_Get(c_void)
PyThreadState_Get = _dll.PyThreadState_Get
PyThreadState_Get.restype = PyThreadState_p
PyThreadState_Get.argtypes = [ c_void ]



# PyThreadState_p PyThreadState_Swap(PyThreadState_p)
PyThreadState_Swap = _dll.PyThreadState_Swap
PyThreadState_Swap.restype = PyThreadState_p
PyThreadState_Swap.argtypes = [ PyThreadState_p ]



# PyObject_p PyThreadState_GetDict(c_void)
PyThreadState_GetDict = _dll.PyThreadState_GetDict
PyThreadState_GetDict.restype = PyObject_p
PyThreadState_GetDict.argtypes = [ c_void ]



# c_int PyThreadState_SetAsyncExc(c_long, PyObject_p)
PyThreadState_SetAsyncExc = _dll.PyThreadState_SetAsyncExc
PyThreadState_SetAsyncExc.restype = c_int
PyThreadState_SetAsyncExc.argtypes = [ c_long, PyObject_p ]



# extern PyThreadState_p _PyThreadState_Current
_PyThreadState_Current = PyThreadState_p.from_address(_dll._PyThreadState_Current)



# PyGILState_STATE PyGILState_Ensure(c_void)
PyGILState_Ensure = _dll.PyGILState_Ensure
PyGILState_Ensure.restype = PyGILState_STATE
PyGILState_Ensure.argtypes = [ c_void ]



# c_void PyGILState_Release(PyGILState_STATE)
PyGILState_Release = _dll.PyGILState_Release
PyGILState_Release.restype = c_void
PyGILState_Release.argtypes = [ PyGILState_STATE ]



# PyThreadState_p PyGILState_GetThisThreadState(c_void)
PyGILState_GetThisThreadState = _dll.PyGILState_GetThisThreadState
PyGILState_GetThisThreadState.restype = PyThreadState_p
PyGILState_GetThisThreadState.argtypes = [ c_void ]



# PyObject_p _PyThread_CurrentFrames(c_void)
_PyThread_CurrentFrames = _dll._PyThread_CurrentFrames
_PyThread_CurrentFrames.restype = PyObject_p
_PyThread_CurrentFrames.argtypes = [ c_void ]



# Pyc_interpreterState_p Pyc_interpreterState_Head(c_void)
Pyc_interpreterState_Head = _dll.Pyc_interpreterState_Head
Pyc_interpreterState_Head.restype = Pyc_interpreterState_p
Pyc_interpreterState_Head.argtypes = [ c_void ]



# Pyc_interpreterState_p Pyc_interpreterState_Next(Pyc_interpreterState_p)
Pyc_interpreterState_Next = _dll.Pyc_interpreterState_Next
Pyc_interpreterState_Next.restype = Pyc_interpreterState_p
Pyc_interpreterState_Next.argtypes = [ Pyc_interpreterState_p ]



# PyThreadState_p Pyc_interpreterState_ThreadHead(Pyc_interpreterState_p)
Pyc_interpreterState_ThreadHead = _dll.Pyc_interpreterState_ThreadHead
Pyc_interpreterState_ThreadHead.restype = PyThreadState_p
Pyc_interpreterState_ThreadHead.argtypes = [ Pyc_interpreterState_p ]



# PyThreadState_p PyThreadState_Next(PyThreadState_p)
PyThreadState_Next = _dll.PyThreadState_Next
PyThreadState_Next.restype = PyThreadState_p
PyThreadState_Next.argtypes = [ PyThreadState_p ]



# extern PyThreadFrameGetter _PyThreadState_GetFrame
_PyThreadState_GetFrame = PyThreadFrameGetter.from_address(_dll._PyThreadState_GetFrame)



# PyArena_p PyArena_New(c_void)
PyArena_New = _dll.PyArena_New
PyArena_New.restype = PyArena_p
PyArena_New.argtypes = [ c_void ]



# c_void PyArena_Free(PyArena_p)
PyArena_Free = _dll.PyArena_Free
PyArena_Free.restype = c_void
PyArena_Free.argtypes = [ PyArena_p ]



# c_void_p PyArena_Malloc(PyArena_p, c_size_t size)
PyArena_Malloc = _dll.PyArena_Malloc
PyArena_Malloc.restype = c_void_p
PyArena_Malloc.argtypes = [ PyArena_p, c_size_t size ]



# c_int PyArena_AddPyObject(PyArena_p, PyObject_p)
PyArena_AddPyObject = _dll.PyArena_AddPyObject
PyArena_AddPyObject.restype = c_int
PyArena_AddPyObject.argtypes = [ PyArena_p, PyObject_p ]



# PyObject_p _Py_VaBuildValue_SizeT(char_p, va_list)
_Py_VaBuildValue_SizeT = _dll._Py_VaBuildValue_SizeT
_Py_VaBuildValue_SizeT.restype = PyObject_p
_Py_VaBuildValue_SizeT.argtypes = [ char_p, va_list ]



# c_int PyArg_Parse(PyObject_p, char_p, ...)
PyArg_Parse = _dll.PyArg_Parse
PyArg_Parse.restype = c_int
PyArg_Parse.argtypes = [ PyObject_p, char_p, ... ]



# c_int PyArg_ParseTuple(PyObject_p, char_p, ...)
PyArg_ParseTuple = _dll.PyArg_ParseTuple
PyArg_ParseTuple.restype = c_int
PyArg_ParseTuple.argtypes = [ PyObject_p, char_p, ... ]



# c_int PyArg_ParseTupleAndKeywords(PyObject_p, PyObject_p, char_p, char_p_p, ...)
PyArg_ParseTupleAndKeywords = _dll.PyArg_ParseTupleAndKeywords
PyArg_ParseTupleAndKeywords.restype = c_int
PyArg_ParseTupleAndKeywords.argtypes = [ PyObject_p, PyObject_p, char_p, char_p_p, ... ]



# c_int PyArg_UnpackTuple(PyObject_p, char_p, Py_ssize_t, Py_ssize_t, ...)
PyArg_UnpackTuple = _dll.PyArg_UnpackTuple
PyArg_UnpackTuple.restype = c_int
PyArg_UnpackTuple.argtypes = [ PyObject_p, char_p, Py_ssize_t, Py_ssize_t, ... ]



# PyObject_p Py_BuildValue(char_p, ...)
Py_BuildValue = _dll.Py_BuildValue
Py_BuildValue.restype = PyObject_p
Py_BuildValue.argtypes = [ char_p, ... ]



# PyObject_p _Py_BuildValue_SizeT(char_p, ...)
_Py_BuildValue_SizeT = _dll._Py_BuildValue_SizeT
_Py_BuildValue_SizeT.restype = PyObject_p
_Py_BuildValue_SizeT.argtypes = [ char_p, ... ]



# c_int _PyArg_NoKeywords(char_pfuncname, PyObject_pkw)
_PyArg_NoKeywords = _dll._PyArg_NoKeywords
_PyArg_NoKeywords.restype = c_int
_PyArg_NoKeywords.argtypes = [ char_pfuncname, PyObject_pkw ]



# c_int PyArg_VaParse(PyObject_p, char_p, va_list)
PyArg_VaParse = _dll.PyArg_VaParse
PyArg_VaParse.restype = c_int
PyArg_VaParse.argtypes = [ PyObject_p, char_p, va_list ]



# c_int PyArg_VaParseTupleAndKeywords(PyObject_p, PyObject_p, char_p, char_p_p, va_list)
PyArg_VaParseTupleAndKeywords = _dll.PyArg_VaParseTupleAndKeywords
PyArg_VaParseTupleAndKeywords.restype = c_int
PyArg_VaParseTupleAndKeywords.argtypes = [ PyObject_p, PyObject_p, char_p, char_p_p, va_list ]



# PyObject_p Py_VaBuildValue(char_p, va_list)
Py_VaBuildValue = _dll.Py_VaBuildValue
Py_VaBuildValue.restype = PyObject_p
Py_VaBuildValue.argtypes = [ char_p, va_list ]



# c_int PyModule_AddObject(PyObject_p, char_p, PyObject_p)
PyModule_AddObject = _dll.PyModule_AddObject
PyModule_AddObject.restype = c_int
PyModule_AddObject.argtypes = [ PyObject_p, char_p, PyObject_p ]



# c_int PyModule_Addc_intConstant(PyObject_p, char_p, c_long)
PyModule_Addc_intConstant = _dll.PyModule_Addc_intConstant
PyModule_Addc_intConstant.restype = c_int
PyModule_Addc_intConstant.argtypes = [ PyObject_p, char_p, c_long ]



# c_int PyModule_AddStringConstant(PyObject_p, char_p, char_p)
PyModule_AddStringConstant = _dll.PyModule_AddStringConstant
PyModule_AddStringConstant.restype = c_int
PyModule_AddStringConstant.argtypes = [ PyObject_p, char_p, char_p ]



# PyObject_p Py_InitModule4(char_pname, PyMethodDef_pmethods, char_pdoc, PyObject_pself, c_int apiver)
Py_InitModule4 = _dll.Py_InitModule4
Py_InitModule4.restype = PyObject_p
Py_InitModule4.argtypes = [ char_pname, PyMethodDef_pmethods, char_pdoc, PyObject_pself, c_int apiver ]



# extern char_p _Py_PackageContext
_Py_PackageContext = char_p.from_address(_dll._Py_PackageContext)



# c_void Py_SetProgramName(char_p)
Py_SetProgramName = _dll.Py_SetProgramName
Py_SetProgramName.restype = c_void
Py_SetProgramName.argtypes = [ char_p ]



# char_p Py_GetProgramName(c_void)
Py_GetProgramName = _dll.Py_GetProgramName
Py_GetProgramName.restype = char_p
Py_GetProgramName.argtypes = [ c_void ]



# c_void Py_SetPythonHome(char_p)
Py_SetPythonHome = _dll.Py_SetPythonHome
Py_SetPythonHome.restype = c_void
Py_SetPythonHome.argtypes = [ char_p ]



# char_p Py_GetPythonHome(c_void)
Py_GetPythonHome = _dll.Py_GetPythonHome
Py_GetPythonHome.restype = char_p
Py_GetPythonHome.argtypes = [ c_void ]



# c_void Py_Initialize(c_void)
Py_Initialize = _dll.Py_Initialize
Py_Initialize.restype = c_void
Py_Initialize.argtypes = [ c_void ]



# c_void Py_InitializeEx(c_int)
Py_InitializeEx = _dll.Py_InitializeEx
Py_InitializeEx.restype = c_void
Py_InitializeEx.argtypes = [ c_int ]



# c_void Py_Finalize(c_void)
Py_Finalize = _dll.Py_Finalize
Py_Finalize.restype = c_void
Py_Finalize.argtypes = [ c_void ]



# c_int Py_IsInitialized(c_void)
Py_IsInitialized = _dll.Py_IsInitialized
Py_IsInitialized.restype = c_int
Py_IsInitialized.argtypes = [ c_void ]



# PyThreadState_p Py_Newc_interpreter(c_void)
Py_Newc_interpreter = _dll.Py_Newc_interpreter
Py_Newc_interpreter.restype = PyThreadState_p
Py_Newc_interpreter.argtypes = [ c_void ]



# c_void Py_Endc_interpreter(PyThreadState_p)
Py_Endc_interpreter = _dll.Py_Endc_interpreter
Py_Endc_interpreter.restype = c_void
Py_Endc_interpreter.argtypes = [ PyThreadState_p ]



# c_int PyRun_AnyFileFlags(FILE_p, char_p, PyCompilerFlags_p)
PyRun_AnyFileFlags = _dll.PyRun_AnyFileFlags
PyRun_AnyFileFlags.restype = c_int
PyRun_AnyFileFlags.argtypes = [ FILE_p, char_p, PyCompilerFlags_p ]



# c_int PyRun_AnyFileExFlags(FILE_p, char_p, c_int, PyCompilerFlags_p)
PyRun_AnyFileExFlags = _dll.PyRun_AnyFileExFlags
PyRun_AnyFileExFlags.restype = c_int
PyRun_AnyFileExFlags.argtypes = [ FILE_p, char_p, c_int, PyCompilerFlags_p ]



# c_int PyRun_SimpleStringFlags(char_p, PyCompilerFlags_p)
PyRun_SimpleStringFlags = _dll.PyRun_SimpleStringFlags
PyRun_SimpleStringFlags.restype = c_int
PyRun_SimpleStringFlags.argtypes = [ char_p, PyCompilerFlags_p ]



# c_int PyRun_SimpleFileExFlags(FILE_p, char_p, c_int, PyCompilerFlags_p)
PyRun_SimpleFileExFlags = _dll.PyRun_SimpleFileExFlags
PyRun_SimpleFileExFlags.restype = c_int
PyRun_SimpleFileExFlags.argtypes = [ FILE_p, char_p, c_int, PyCompilerFlags_p ]



# c_int PyRun_c_interactiveOneFlags(FILE_p, char_p, PyCompilerFlags_p)
PyRun_c_interactiveOneFlags = _dll.PyRun_c_interactiveOneFlags
PyRun_c_interactiveOneFlags.restype = c_int
PyRun_c_interactiveOneFlags.argtypes = [ FILE_p, char_p, PyCompilerFlags_p ]



# c_int PyRun_c_interactiveLoopFlags(FILE_p, char_p, PyCompilerFlags_p)
PyRun_c_interactiveLoopFlags = _dll.PyRun_c_interactiveLoopFlags
PyRun_c_interactiveLoopFlags.restype = c_int
PyRun_c_interactiveLoopFlags.argtypes = [ FILE_p, char_p, PyCompilerFlags_p ]



# struct _mod_p PyParser_ASTFromString(char_p, char_p, c_int, PyCompilerFlags_pflags, PyArena_p)
PyParser_ASTFromString = _dll.PyParser_ASTFromString
PyParser_ASTFromString.restype = struct _mod_p
PyParser_ASTFromString.argtypes = [ char_p, char_p, c_int, PyCompilerFlags_pflags, PyArena_p ]



# struct _mod_p PyParser_ASTFromFile(FILE_p, char_p, c_int, char_p, char_p, PyCompilerFlags_p, c_int_p, PyArena_p)
PyParser_ASTFromFile = _dll.PyParser_ASTFromFile
PyParser_ASTFromFile.restype = struct _mod_p
PyParser_ASTFromFile.argtypes = [ FILE_p, char_p, c_int, char_p, char_p, PyCompilerFlags_p, c_int_p, PyArena_p ]



# struct _node_p PyParser_SimpleParseStringFlags(char_p, c_int, c_int)
PyParser_SimpleParseStringFlags = _dll.PyParser_SimpleParseStringFlags
PyParser_SimpleParseStringFlags.restype = struct _node_p
PyParser_SimpleParseStringFlags.argtypes = [ char_p, c_int, c_int ]



# struct _node_p PyParser_SimpleParseFileFlags(FILE_p, char_p, c_int, c_int)
PyParser_SimpleParseFileFlags = _dll.PyParser_SimpleParseFileFlags
PyParser_SimpleParseFileFlags.restype = struct _node_p
PyParser_SimpleParseFileFlags.argtypes = [ FILE_p, char_p, c_int, c_int ]



# PyObject_p PyRun_StringFlags(char_p, c_int, PyObject_p, PyObject_p, PyCompilerFlags_p)
PyRun_StringFlags = _dll.PyRun_StringFlags
PyRun_StringFlags.restype = PyObject_p
PyRun_StringFlags.argtypes = [ char_p, c_int, PyObject_p, PyObject_p, PyCompilerFlags_p ]



# PyObject_p PyRun_FileExFlags(FILE_p, char_p, c_int, PyObject_p, PyObject_p, c_int, PyCompilerFlags_p)
PyRun_FileExFlags = _dll.PyRun_FileExFlags
PyRun_FileExFlags.restype = PyObject_p
PyRun_FileExFlags.argtypes = [ FILE_p, char_p, c_int, PyObject_p, PyObject_p, c_int, PyCompilerFlags_p ]



# PyObject_p Py_CompileStringFlags(char_p, char_p, c_int, PyCompilerFlags_p)
Py_CompileStringFlags = _dll.Py_CompileStringFlags
Py_CompileStringFlags.restype = PyObject_p
Py_CompileStringFlags.argtypes = [ char_p, char_p, c_int, PyCompilerFlags_p ]



# struct symtable_p Py_SymtableString(char_p, char_p, c_int)
Py_SymtableString = _dll.Py_SymtableString
Py_SymtableString.restype = struct symtable_p
Py_SymtableString.argtypes = [ char_p, char_p, c_int ]



# c_void PyErr_Prc_int(c_void)
PyErr_Prc_int = _dll.PyErr_Prc_int
PyErr_Prc_int.restype = c_void
PyErr_Prc_int.argtypes = [ c_void ]



# c_void PyErr_Prc_intEx(c_int)
PyErr_Prc_intEx = _dll.PyErr_Prc_intEx
PyErr_Prc_intEx.restype = c_void
PyErr_Prc_intEx.argtypes = [ c_int ]



# c_void PyErr_Display(PyObject_p, PyObject_p, PyObject_p)
PyErr_Display = _dll.PyErr_Display
PyErr_Display.restype = c_void
PyErr_Display.argtypes = [ PyObject_p, PyObject_p, PyObject_p ]



# c_int Py_AtExit(c_void (_pfunc)
Py_AtExit = _dll.Py_AtExit
Py_AtExit.restype = c_int
Py_AtExit.argtypes = [ c_void (_pfunc ]



# c_void Py_Exit(c_int)
Py_Exit = _dll.Py_Exit
Py_Exit.restype = c_void
Py_Exit.argtypes = [ c_int ]



# c_int Py_FdIsc_interactive(FILE_p, char_p)
Py_FdIsc_interactive = _dll.Py_FdIsc_interactive
Py_FdIsc_interactive.restype = c_int
Py_FdIsc_interactive.argtypes = [ FILE_p, char_p ]



# c_int Py_Main(c_int argc, char_p_pargv)
Py_Main = _dll.Py_Main
Py_Main.restype = c_int
Py_Main.argtypes = [ c_int argc, char_p_pargv ]



# char_p Py_GetProgramFullPath(c_void)
Py_GetProgramFullPath = _dll.Py_GetProgramFullPath
Py_GetProgramFullPath.restype = char_p
Py_GetProgramFullPath.argtypes = [ c_void ]



# char_p Py_GetPrefix(c_void)
Py_GetPrefix = _dll.Py_GetPrefix
Py_GetPrefix.restype = char_p
Py_GetPrefix.argtypes = [ c_void ]



# char_p Py_GetExecPrefix(c_void)
Py_GetExecPrefix = _dll.Py_GetExecPrefix
Py_GetExecPrefix.restype = char_p
Py_GetExecPrefix.argtypes = [ c_void ]



# char_p Py_GetPath(c_void)
Py_GetPath = _dll.Py_GetPath
Py_GetPath.restype = char_p
Py_GetPath.argtypes = [ c_void ]



# char_p Py_GetVersion(c_void)
Py_GetVersion = _dll.Py_GetVersion
Py_GetVersion.restype = char_p
Py_GetVersion.argtypes = [ c_void ]



# char_p Py_GetPlatform(c_void)
Py_GetPlatform = _dll.Py_GetPlatform
Py_GetPlatform.restype = char_p
Py_GetPlatform.argtypes = [ c_void ]



# char_p Py_GetCopyright(c_void)
Py_GetCopyright = _dll.Py_GetCopyright
Py_GetCopyright.restype = char_p
Py_GetCopyright.argtypes = [ c_void ]



# char_p Py_GetCompiler(c_void)
Py_GetCompiler = _dll.Py_GetCompiler
Py_GetCompiler.restype = char_p
Py_GetCompiler.argtypes = [ c_void ]



# char_p Py_GetBuildInfo(c_void)
Py_GetBuildInfo = _dll.Py_GetBuildInfo
Py_GetBuildInfo.restype = char_p
Py_GetBuildInfo.argtypes = [ c_void ]



# char_p _Py_svnversion(c_void)
_Py_svnversion = _dll._Py_svnversion
_Py_svnversion.restype = char_p
_Py_svnversion.argtypes = [ c_void ]



# char_p Py_SubversionRevision(c_void)
Py_SubversionRevision = _dll.Py_SubversionRevision
Py_SubversionRevision.restype = char_p
Py_SubversionRevision.argtypes = [ c_void ]



# char_p Py_SubversionShortBranch(c_void)
Py_SubversionShortBranch = _dll.Py_SubversionShortBranch
Py_SubversionShortBranch.restype = char_p
Py_SubversionShortBranch.argtypes = [ c_void ]



# char_p _Py_hgidentifier(c_void)
_Py_hgidentifier = _dll._Py_hgidentifier
_Py_hgidentifier.restype = char_p
_Py_hgidentifier.argtypes = [ c_void ]



# char_p _Py_hgversion(c_void)
_Py_hgversion = _dll._Py_hgversion
_Py_hgversion.restype = char_p
_Py_hgversion.argtypes = [ c_void ]



# PyObject_p _PyBuiltin_Init(c_void)
_PyBuiltin_Init = _dll._PyBuiltin_Init
_PyBuiltin_Init.restype = PyObject_p
_PyBuiltin_Init.argtypes = [ c_void ]



# PyObject_p _PySys_Init(c_void)
_PySys_Init = _dll._PySys_Init
_PySys_Init.restype = PyObject_p
_PySys_Init.argtypes = [ c_void ]



# c_void _PyImport_Init(c_void)
_PyImport_Init = _dll._PyImport_Init
_PyImport_Init.restype = c_void
_PyImport_Init.argtypes = [ c_void ]



# c_void _PyExc_Init(c_void)
_PyExc_Init = _dll._PyExc_Init
_PyExc_Init.restype = c_void
_PyExc_Init.argtypes = [ c_void ]



# c_void _PyImportHooks_Init(c_void)
_PyImportHooks_Init = _dll._PyImportHooks_Init
_PyImportHooks_Init.restype = c_void
_PyImportHooks_Init.argtypes = [ c_void ]



# c_int _PyFrame_Init(c_void)
_PyFrame_Init = _dll._PyFrame_Init
_PyFrame_Init.restype = c_int
_PyFrame_Init.argtypes = [ c_void ]



# c_int _Pyc_int_Init(c_void)
_Pyc_int_Init = _dll._Pyc_int_Init
_Pyc_int_Init.restype = c_int
_Pyc_int_Init.argtypes = [ c_void ]



# c_int _PyLong_Init(c_void)
_PyLong_Init = _dll._PyLong_Init
_PyLong_Init.restype = c_int
_PyLong_Init.argtypes = [ c_void ]



# c_void _PyFloat_Init(c_void)
_PyFloat_Init = _dll._PyFloat_Init
_PyFloat_Init.restype = c_void
_PyFloat_Init.argtypes = [ c_void ]



# c_int PyByteArray_Init(c_void)
PyByteArray_Init = _dll.PyByteArray_Init
PyByteArray_Init.restype = c_int
PyByteArray_Init.argtypes = [ c_void ]



# c_void _PyExc_Fini(c_void)
_PyExc_Fini = _dll._PyExc_Fini
_PyExc_Fini.restype = c_void
_PyExc_Fini.argtypes = [ c_void ]



# c_void _PyImport_Fini(c_void)
_PyImport_Fini = _dll._PyImport_Fini
_PyImport_Fini.restype = c_void
_PyImport_Fini.argtypes = [ c_void ]



# c_void PyMethod_Fini(c_void)
PyMethod_Fini = _dll.PyMethod_Fini
PyMethod_Fini.restype = c_void
PyMethod_Fini.argtypes = [ c_void ]



# c_void PyFrame_Fini(c_void)
PyFrame_Fini = _dll.PyFrame_Fini
PyFrame_Fini.restype = c_void
PyFrame_Fini.argtypes = [ c_void ]



# c_void PyCFunction_Fini(c_void)
PyCFunction_Fini = _dll.PyCFunction_Fini
PyCFunction_Fini.restype = c_void
PyCFunction_Fini.argtypes = [ c_void ]



# c_void PyDict_Fini(c_void)
PyDict_Fini = _dll.PyDict_Fini
PyDict_Fini.restype = c_void
PyDict_Fini.argtypes = [ c_void ]



# c_void PyTuple_Fini(c_void)
PyTuple_Fini = _dll.PyTuple_Fini
PyTuple_Fini.restype = c_void
PyTuple_Fini.argtypes = [ c_void ]



# c_void PyList_Fini(c_void)
PyList_Fini = _dll.PyList_Fini
PyList_Fini.restype = c_void
PyList_Fini.argtypes = [ c_void ]



# c_void PySet_Fini(c_void)
PySet_Fini = _dll.PySet_Fini
PySet_Fini.restype = c_void
PySet_Fini.argtypes = [ c_void ]



# c_void PyString_Fini(c_void)
PyString_Fini = _dll.PyString_Fini
PyString_Fini.restype = c_void
PyString_Fini.argtypes = [ c_void ]



# c_void Pyc_int_Fini(c_void)
Pyc_int_Fini = _dll.Pyc_int_Fini
Pyc_int_Fini.restype = c_void
Pyc_int_Fini.argtypes = [ c_void ]



# c_void PyFloat_Fini(c_void)
PyFloat_Fini = _dll.PyFloat_Fini
PyFloat_Fini.restype = c_void
PyFloat_Fini.argtypes = [ c_void ]



# c_void PyOS_Finic_interrupts(c_void)
PyOS_Finic_interrupts = _dll.PyOS_Finic_interrupts
PyOS_Finic_interrupts.restype = c_void
PyOS_Finic_interrupts.argtypes = [ c_void ]



# c_void PyByteArray_Fini(c_void)
PyByteArray_Fini = _dll.PyByteArray_Fini
PyByteArray_Fini.restype = c_void
PyByteArray_Fini.argtypes = [ c_void ]



# char_p PyOS_Readline(FILE_p, FILE_p, char_p)
PyOS_Readline = _dll.PyOS_Readline
PyOS_Readline.restype = char_p
PyOS_Readline.argtypes = [ FILE_p, FILE_p, char_p ]



# extern PyThreadState_p _PyOS_ReadlineTState
_PyOS_ReadlineTState = PyThreadState_p.from_address(_dll._PyOS_ReadlineTState)



# c_int PyOS_CheckStack(c_void)
PyOS_CheckStack = _dll.PyOS_CheckStack
PyOS_CheckStack.restype = c_int
PyOS_CheckStack.argtypes = [ c_void ]



# PyOS_sighandler_t PyOS_getsig(c_int)
PyOS_getsig = _dll.PyOS_getsig
PyOS_getsig.restype = PyOS_sighandler_t
PyOS_getsig.argtypes = [ c_int ]



# PyOS_sighandler_t PyOS_setsig(c_int, PyOS_sighandler_t)
PyOS_setsig = _dll.PyOS_setsig
PyOS_setsig.restype = PyOS_sighandler_t
PyOS_setsig.argtypes = [ c_int, PyOS_sighandler_t ]



# PyObject_p PyEval_CallObjectWithKeywords( PyObject_p, PyObject_p, PyObject_p)
PyEval_CallObjectWithKeywords = _dll.PyEval_CallObjectWithKeywords
PyEval_CallObjectWithKeywords.restype = PyObject_p
PyEval_CallObjectWithKeywords.argtypes = [  PyObject_p, PyObject_p, PyObject_p ]



# PyObject_p PyEval_CallFunction(PyObject_pobj, char_pformat, ...)
PyEval_CallFunction = _dll.PyEval_CallFunction
PyEval_CallFunction.restype = PyObject_p
PyEval_CallFunction.argtypes = [ PyObject_pobj, char_pformat, ... ]



# PyObject_p PyEval_CallMethod(PyObject_pobj, char_pmethodname, char_pformat, ...)
PyEval_CallMethod = _dll.PyEval_CallMethod
PyEval_CallMethod.restype = PyObject_p
PyEval_CallMethod.argtypes = [ PyObject_pobj, char_pmethodname, char_pformat, ... ]



# c_void PyEval_SetProfile(Py_tracefunc, PyObject_p)
PyEval_SetProfile = _dll.PyEval_SetProfile
PyEval_SetProfile.restype = c_void
PyEval_SetProfile.argtypes = [ Py_tracefunc, PyObject_p ]



# c_void PyEval_SetTrace(Py_tracefunc, PyObject_p)
PyEval_SetTrace = _dll.PyEval_SetTrace
PyEval_SetTrace.restype = c_void
PyEval_SetTrace.argtypes = [ Py_tracefunc, PyObject_p ]



# PyObject_p PyEval_GetBuiltins(c_void)
PyEval_GetBuiltins = _dll.PyEval_GetBuiltins
PyEval_GetBuiltins.restype = PyObject_p
PyEval_GetBuiltins.argtypes = [ c_void ]



# PyObject_p PyEval_GetGlobals(c_void)
PyEval_GetGlobals = _dll.PyEval_GetGlobals
PyEval_GetGlobals.restype = PyObject_p
PyEval_GetGlobals.argtypes = [ c_void ]



# PyObject_p PyEval_GetLocals(c_void)
PyEval_GetLocals = _dll.PyEval_GetLocals
PyEval_GetLocals.restype = PyObject_p
PyEval_GetLocals.argtypes = [ c_void ]



# struct _frame_p PyEval_GetFrame(c_void)
PyEval_GetFrame = _dll.PyEval_GetFrame
PyEval_GetFrame.restype = struct _frame_p
PyEval_GetFrame.argtypes = [ c_void ]



# c_int PyEval_GetRestricted(c_void)
PyEval_GetRestricted = _dll.PyEval_GetRestricted
PyEval_GetRestricted.restype = c_int
PyEval_GetRestricted.argtypes = [ c_void ]



# c_int PyEval_MergeCompilerFlags(PyCompilerFlags_pcf)
PyEval_MergeCompilerFlags = _dll.PyEval_MergeCompilerFlags
PyEval_MergeCompilerFlags.restype = c_int
PyEval_MergeCompilerFlags.argtypes = [ PyCompilerFlags_pcf ]



# c_int Py_FlushLine(c_void)
Py_FlushLine = _dll.Py_FlushLine
Py_FlushLine.restype = c_int
Py_FlushLine.argtypes = [ c_void ]



# c_int Py_AddPendingCall(c_int (_pfunc)
Py_AddPendingCall = _dll.Py_AddPendingCall
Py_AddPendingCall.restype = c_int
Py_AddPendingCall.argtypes = [ c_int (_pfunc ]



# c_int Py_MakePendingCalls(c_void)
Py_MakePendingCalls = _dll.Py_MakePendingCalls
Py_MakePendingCalls.restype = c_int
Py_MakePendingCalls.argtypes = [ c_void ]



# c_void Py_SetRecursionLimit(c_int)
Py_SetRecursionLimit = _dll.Py_SetRecursionLimit
Py_SetRecursionLimit.restype = c_void
Py_SetRecursionLimit.argtypes = [ c_int ]



# c_int Py_GetRecursionLimit(c_void)
Py_GetRecursionLimit = _dll.Py_GetRecursionLimit
Py_GetRecursionLimit.restype = c_int
Py_GetRecursionLimit.argtypes = [ c_void ]



# c_int _Py_CheckRecursiveCall(char_pwhere)
_Py_CheckRecursiveCall = _dll._Py_CheckRecursiveCall
_Py_CheckRecursiveCall.restype = c_int
_Py_CheckRecursiveCall.argtypes = [ char_pwhere ]



# extern c_int _Py_CheckRecursionLimit
_Py_CheckRecursionLimit = c_int.from_address(_dll._Py_CheckRecursionLimit)



# char_p PyEval_GetFuncName(PyObject_p)
PyEval_GetFuncName = _dll.PyEval_GetFuncName
PyEval_GetFuncName.restype = char_p
PyEval_GetFuncName.argtypes = [ PyObject_p ]



# char_p PyEval_GetFuncDesc(PyObject_p)
PyEval_GetFuncDesc = _dll.PyEval_GetFuncDesc
PyEval_GetFuncDesc.restype = char_p
PyEval_GetFuncDesc.argtypes = [ PyObject_p ]



# PyObject_p PyEval_GetCallStats(PyObject_p)
PyEval_GetCallStats = _dll.PyEval_GetCallStats
PyEval_GetCallStats.restype = PyObject_p
PyEval_GetCallStats.argtypes = [ PyObject_p ]



# PyObject_p PyEval_EvalFrame(struct _frame_p)
PyEval_EvalFrame = _dll.PyEval_EvalFrame
PyEval_EvalFrame.restype = PyObject_p
PyEval_EvalFrame.argtypes = [ struct _frame_p ]



# PyObject_p PyEval_EvalFrameEx(struct _frame_pf, c_int exc)
PyEval_EvalFrameEx = _dll.PyEval_EvalFrameEx
PyEval_EvalFrameEx.restype = PyObject_p
PyEval_EvalFrameEx.argtypes = [ struct _frame_pf, c_int exc ]



# extern volatile c_int _Py_Ticker
_Py_Ticker = volatile c_int.from_address(_dll._Py_Ticker)



# extern c_int _Py_Checkc_interval
_Py_Checkc_interval = c_int.from_address(_dll._Py_Checkc_interval)



# PyThreadState_p PyEval_SaveThread(c_void)
PyEval_SaveThread = _dll.PyEval_SaveThread
PyEval_SaveThread.restype = PyThreadState_p
PyEval_SaveThread.argtypes = [ c_void ]



# c_void PyEval_RestoreThread(PyThreadState_p)
PyEval_RestoreThread = _dll.PyEval_RestoreThread
PyEval_RestoreThread.restype = c_void
PyEval_RestoreThread.argtypes = [ PyThreadState_p ]



# c_int PyEval_ThreadsInitialized(c_void)
PyEval_ThreadsInitialized = _dll.PyEval_ThreadsInitialized
PyEval_ThreadsInitialized.restype = c_int
PyEval_ThreadsInitialized.argtypes = [ c_void ]



# c_void PyEval_InitThreads(c_void)
PyEval_InitThreads = _dll.PyEval_InitThreads
PyEval_InitThreads.restype = c_void
PyEval_InitThreads.argtypes = [ c_void ]



# c_void PyEval_AcquireLock(c_void)
PyEval_AcquireLock = _dll.PyEval_AcquireLock
PyEval_AcquireLock.restype = c_void
PyEval_AcquireLock.argtypes = [ c_void ]



# c_void PyEval_ReleaseLock(c_void)
PyEval_ReleaseLock = _dll.PyEval_ReleaseLock
PyEval_ReleaseLock.restype = c_void
PyEval_ReleaseLock.argtypes = [ c_void ]



# c_void PyEval_AcquireThread(PyThreadState_ptstate)
PyEval_AcquireThread = _dll.PyEval_AcquireThread
PyEval_AcquireThread.restype = c_void
PyEval_AcquireThread.argtypes = [ PyThreadState_ptstate ]



# c_void PyEval_ReleaseThread(PyThreadState_ptstate)
PyEval_ReleaseThread = _dll.PyEval_ReleaseThread
PyEval_ReleaseThread.restype = c_void
PyEval_ReleaseThread.argtypes = [ PyThreadState_ptstate ]



# c_void PyEval_ReInitThreads(c_void)
PyEval_ReInitThreads = _dll.PyEval_ReInitThreads
PyEval_ReInitThreads.restype = c_void
PyEval_ReInitThreads.argtypes = [ c_void ]



# c_int _PyEval_SliceIndex(PyObject_p, Py_ssize_t_p)
_PyEval_SliceIndex = _dll._PyEval_SliceIndex
_PyEval_SliceIndex.restype = c_int
_PyEval_SliceIndex.argtypes = [ PyObject_p, Py_ssize_t_p ]



# PyObject_p PySys_GetObject(char_p)
PySys_GetObject = _dll.PySys_GetObject
PySys_GetObject.restype = PyObject_p
PySys_GetObject.argtypes = [ char_p ]



# c_int PySys_SetObject(char_p, PyObject_p)
PySys_SetObject = _dll.PySys_SetObject
PySys_SetObject.restype = c_int
PySys_SetObject.argtypes = [ char_p, PyObject_p ]



# FILE_p PySys_GetFile(char_p, FILE_p)
PySys_GetFile = _dll.PySys_GetFile
PySys_GetFile.restype = FILE_p
PySys_GetFile.argtypes = [ char_p, FILE_p ]



# c_void PySys_SetArgv(c_int, char_p_p)
PySys_SetArgv = _dll.PySys_SetArgv
PySys_SetArgv.restype = c_void
PySys_SetArgv.argtypes = [ c_int, char_p_p ]



# c_void PySys_SetArgvEx(c_int, char_p_p, c_int)
PySys_SetArgvEx = _dll.PySys_SetArgvEx
PySys_SetArgvEx.restype = c_void
PySys_SetArgvEx.argtypes = [ c_int, char_p_p, c_int ]



# c_void PySys_SetPath(char_p)
PySys_SetPath = _dll.PySys_SetPath
PySys_SetPath.restype = c_void
PySys_SetPath.argtypes = [ char_p ]



# c_void PySys_WriteStdout(char_pformat, ...)
PySys_WriteStdout = _dll.PySys_WriteStdout
PySys_WriteStdout.restype = c_void
PySys_WriteStdout.argtypes = [ char_pformat, ... ]



# c_void PySys_WriteStderr(char_pformat, ...)
PySys_WriteStderr = _dll.PySys_WriteStderr
PySys_WriteStderr.restype = c_void
PySys_WriteStderr.argtypes = [ char_pformat, ... ]



# c_void PySys_ResetWarnOptions(c_void)
PySys_ResetWarnOptions = _dll.PySys_ResetWarnOptions
PySys_ResetWarnOptions.restype = c_void
PySys_ResetWarnOptions.argtypes = [ c_void ]



# c_void PySys_AddWarnOption(char_p)
PySys_AddWarnOption = _dll.PySys_AddWarnOption
PySys_AddWarnOption.restype = c_void
PySys_AddWarnOption.argtypes = [ char_p ]



# c_int PySys_HasWarnOptions(c_void)
PySys_HasWarnOptions = _dll.PySys_HasWarnOptions
PySys_HasWarnOptions.restype = c_int
PySys_HasWarnOptions.argtypes = [ c_void ]



# c_int PyOS_c_interruptOccurred(c_void)
PyOS_c_interruptOccurred = _dll.PyOS_c_interruptOccurred
PyOS_c_interruptOccurred.restype = c_int
PyOS_c_interruptOccurred.argtypes = [ c_void ]



# c_void PyOS_Initc_interrupts(c_void)
PyOS_Initc_interrupts = _dll.PyOS_Initc_interrupts
PyOS_Initc_interrupts.restype = c_void
PyOS_Initc_interrupts.argtypes = [ c_void ]



# c_void PyOS_AfterFork(c_void)
PyOS_AfterFork = _dll.PyOS_AfterFork
PyOS_AfterFork.restype = c_void
PyOS_AfterFork.argtypes = [ c_void ]



# c_long PyImport_GetMagicNumber(c_void)
PyImport_GetMagicNumber = _dll.PyImport_GetMagicNumber
PyImport_GetMagicNumber.restype = c_long
PyImport_GetMagicNumber.argtypes = [ c_void ]



# PyObject_p PyImport_ExecCodeModule(char_pname, PyObject_pco)
PyImport_ExecCodeModule = _dll.PyImport_ExecCodeModule
PyImport_ExecCodeModule.restype = PyObject_p
PyImport_ExecCodeModule.argtypes = [ char_pname, PyObject_pco ]



# PyObject_p PyImport_ExecCodeModuleEx( char_pname, PyObject_pco, char_ppathname)
PyImport_ExecCodeModuleEx = _dll.PyImport_ExecCodeModuleEx
PyImport_ExecCodeModuleEx.restype = PyObject_p
PyImport_ExecCodeModuleEx.argtypes = [  char_pname, PyObject_pco, char_ppathname ]



# PyObject_p PyImport_GetModuleDict(c_void)
PyImport_GetModuleDict = _dll.PyImport_GetModuleDict
PyImport_GetModuleDict.restype = PyObject_p
PyImport_GetModuleDict.argtypes = [ c_void ]



# PyObject_p PyImport_AddModule(char_pname)
PyImport_AddModule = _dll.PyImport_AddModule
PyImport_AddModule.restype = PyObject_p
PyImport_AddModule.argtypes = [ char_pname ]



# PyObject_p PyImport_ImportModule(char_pname)
PyImport_ImportModule = _dll.PyImport_ImportModule
PyImport_ImportModule.restype = PyObject_p
PyImport_ImportModule.argtypes = [ char_pname ]



# PyObject_p PyImport_ImportModuleNoBlock(char_p)
PyImport_ImportModuleNoBlock = _dll.PyImport_ImportModuleNoBlock
PyImport_ImportModuleNoBlock.restype = PyObject_p
PyImport_ImportModuleNoBlock.argtypes = [ char_p ]



# PyObject_p PyImport_ImportModuleLevel(char_pname, PyObject_pglobals, PyObject_plocals, PyObject_pfromlist, c_int level)
PyImport_ImportModuleLevel = _dll.PyImport_ImportModuleLevel
PyImport_ImportModuleLevel.restype = PyObject_p
PyImport_ImportModuleLevel.argtypes = [ char_pname, PyObject_pglobals, PyObject_plocals, PyObject_pfromlist, c_int level ]



# PyObject_p PyImport_GetImporter(PyObject_ppath)
PyImport_GetImporter = _dll.PyImport_GetImporter
PyImport_GetImporter.restype = PyObject_p
PyImport_GetImporter.argtypes = [ PyObject_ppath ]



# PyObject_p PyImport_Import(PyObject_pname)
PyImport_Import = _dll.PyImport_Import
PyImport_Import.restype = PyObject_p
PyImport_Import.argtypes = [ PyObject_pname ]



# PyObject_p PyImport_ReloadModule(PyObject_pm)
PyImport_ReloadModule = _dll.PyImport_ReloadModule
PyImport_ReloadModule.restype = PyObject_p
PyImport_ReloadModule.argtypes = [ PyObject_pm ]



# c_void PyImport_Cleanup(c_void)
PyImport_Cleanup = _dll.PyImport_Cleanup
PyImport_Cleanup.restype = c_void
PyImport_Cleanup.argtypes = [ c_void ]



# c_int PyImport_ImportFrozenModule(char_p)
PyImport_ImportFrozenModule = _dll.PyImport_ImportFrozenModule
PyImport_ImportFrozenModule.restype = c_int
PyImport_ImportFrozenModule.argtypes = [ char_p ]



# c_void _PyImport_AcquireLock(c_void)
_PyImport_AcquireLock = _dll._PyImport_AcquireLock
_PyImport_AcquireLock.restype = c_void
_PyImport_AcquireLock.argtypes = [ c_void ]



# c_int _PyImport_ReleaseLock(c_void)
_PyImport_ReleaseLock = _dll._PyImport_ReleaseLock
_PyImport_ReleaseLock.restype = c_int
_PyImport_ReleaseLock.argtypes = [ c_void ]



# struct filedescr_p _PyImport_FindModule( char_p, PyObject_p, char_p, c_size_t, FILE_p_p, PyObject_p_p)
_PyImport_FindModule = _dll._PyImport_FindModule
_PyImport_FindModule.restype = struct filedescr_p
_PyImport_FindModule.argtypes = [  char_p, PyObject_p, char_p, c_size_t, FILE_p_p, PyObject_p_p ]



# c_int _PyImport_IsScript(struct filedescr_p)
_PyImport_IsScript = _dll._PyImport_IsScript
_PyImport_IsScript.restype = c_int
_PyImport_IsScript.argtypes = [ struct filedescr_p ]



# c_void _PyImport_ReInitLock(c_void)
_PyImport_ReInitLock = _dll._PyImport_ReInitLock
_PyImport_ReInitLock.restype = c_void
_PyImport_ReInitLock.argtypes = [ c_void ]



# PyObject_p _PyImport_FindExtension(char_p, char_p)
_PyImport_FindExtension = _dll._PyImport_FindExtension
_PyImport_FindExtension.restype = PyObject_p
_PyImport_FindExtension.argtypes = [ char_p, char_p ]



# PyObject_p _PyImport_FixupExtension(char_p, char_p)
_PyImport_FixupExtension = _dll._PyImport_FixupExtension
_PyImport_FixupExtension.restype = PyObject_p
_PyImport_FixupExtension.argtypes = [ char_p, char_p ]



# extern PyTypeObject PyNullImporter_Type
PyNullImporter_Type = PyTypeObject.from_address(_dll.PyNullImporter_Type)



# extern struct _inittab_p PyImport_Inittab
PyImport_Inittab = struct _inittab_p.from_address(_dll.PyImport_Inittab)



# c_int PyImport_AppendInittab(char_pname, c_void (_pinitfunc)
PyImport_AppendInittab = _dll.PyImport_AppendInittab
PyImport_AppendInittab.restype = c_int
PyImport_AppendInittab.argtypes = [ char_pname, c_void (_pinitfunc ]



# c_int PyImport_ExtendInittab(struct _inittab_pnewtab)
PyImport_ExtendInittab = _dll.PyImport_ExtendInittab
PyImport_ExtendInittab.restype = c_int
PyImport_ExtendInittab.argtypes = [ struct _inittab_pnewtab ]



# extern struct _frozen_p PyImport_FrozenModules
PyImport_FrozenModules = struct _frozen_p.from_address(_dll.PyImport_FrozenModules)



# c_int PyObject_Cmp(PyObject_po1, PyObject_po2, c_int_presult)
PyObject_Cmp = _dll.PyObject_Cmp
PyObject_Cmp.restype = c_int
PyObject_Cmp.argtypes = [ PyObject_po1, PyObject_po2, c_int_presult ]



# PyObject_p PyObject_Call(PyObject_pcallable_object, PyObject_pargs, PyObject_pkw)
PyObject_Call = _dll.PyObject_Call
PyObject_Call.restype = PyObject_p
PyObject_Call.argtypes = [ PyObject_pcallable_object, PyObject_pargs, PyObject_pkw ]



# PyObject_p PyObject_CallObject(PyObject_pcallable_object, PyObject_pargs)
PyObject_CallObject = _dll.PyObject_CallObject
PyObject_CallObject.restype = PyObject_p
PyObject_CallObject.argtypes = [ PyObject_pcallable_object, PyObject_pargs ]



# PyObject_p PyObject_CallFunction(PyObject_pcallable_object, char_pformat, ...)
PyObject_CallFunction = _dll.PyObject_CallFunction
PyObject_CallFunction.restype = PyObject_p
PyObject_CallFunction.argtypes = [ PyObject_pcallable_object, char_pformat, ... ]



# PyObject_p PyObject_CallMethod(PyObject_po, char_pm, char_pformat, ...)
PyObject_CallMethod = _dll.PyObject_CallMethod
PyObject_CallMethod.restype = PyObject_p
PyObject_CallMethod.argtypes = [ PyObject_po, char_pm, char_pformat, ... ]



# PyObject_p _PyObject_CallFunction_SizeT(PyObject_pcallable, char_pformat, ...)
_PyObject_CallFunction_SizeT = _dll._PyObject_CallFunction_SizeT
_PyObject_CallFunction_SizeT.restype = PyObject_p
_PyObject_CallFunction_SizeT.argtypes = [ PyObject_pcallable, char_pformat, ... ]



# PyObject_p _PyObject_CallMethod_SizeT(PyObject_po, char_pname, char_pformat, ...)
_PyObject_CallMethod_SizeT = _dll._PyObject_CallMethod_SizeT
_PyObject_CallMethod_SizeT.restype = PyObject_p
_PyObject_CallMethod_SizeT.argtypes = [ PyObject_po, char_pname, char_pformat, ... ]



# PyObject_p PyObject_CallFunctionObjArgs(PyObject_pcallable, ...)
PyObject_CallFunctionObjArgs = _dll.PyObject_CallFunctionObjArgs
PyObject_CallFunctionObjArgs.restype = PyObject_p
PyObject_CallFunctionObjArgs.argtypes = [ PyObject_pcallable, ... ]



# PyObject_p PyObject_CallMethodObjArgs(PyObject_po, PyObject_pm, ...)
PyObject_CallMethodObjArgs = _dll.PyObject_CallMethodObjArgs
PyObject_CallMethodObjArgs.restype = PyObject_p
PyObject_CallMethodObjArgs.argtypes = [ PyObject_po, PyObject_pm, ... ]



# PyObject_p PyObject_Type(PyObject_po)
PyObject_Type = _dll.PyObject_Type
PyObject_Type.restype = PyObject_p
PyObject_Type.argtypes = [ PyObject_po ]



# Py_ssize_t PyObject_Size(PyObject_po)
PyObject_Size = _dll.PyObject_Size
PyObject_Size.restype = Py_ssize_t
PyObject_Size.argtypes = [ PyObject_po ]



# Py_ssize_t PyObject_Length(PyObject_po)
PyObject_Length = _dll.PyObject_Length
PyObject_Length.restype = Py_ssize_t
PyObject_Length.argtypes = [ PyObject_po ]



# Py_ssize_t _PyObject_LengthHc_int(PyObject_po, Py_ssize_t)
_PyObject_LengthHc_int = _dll._PyObject_LengthHc_int
_PyObject_LengthHc_int.restype = Py_ssize_t
_PyObject_LengthHc_int.argtypes = [ PyObject_po, Py_ssize_t ]



# PyObject_p PyObject_GetItem(PyObject_po, PyObject_pkey)
PyObject_GetItem = _dll.PyObject_GetItem
PyObject_GetItem.restype = PyObject_p
PyObject_GetItem.argtypes = [ PyObject_po, PyObject_pkey ]



# c_int PyObject_SetItem(PyObject_po, PyObject_pkey, PyObject_pv)
PyObject_SetItem = _dll.PyObject_SetItem
PyObject_SetItem.restype = c_int
PyObject_SetItem.argtypes = [ PyObject_po, PyObject_pkey, PyObject_pv ]



# c_int PyObject_DelItemString(PyObject_po, char_pkey)
PyObject_DelItemString = _dll.PyObject_DelItemString
PyObject_DelItemString.restype = c_int
PyObject_DelItemString.argtypes = [ PyObject_po, char_pkey ]



# c_int PyObject_DelItem(PyObject_po, PyObject_pkey)
PyObject_DelItem = _dll.PyObject_DelItem
PyObject_DelItem.restype = c_int
PyObject_DelItem.argtypes = [ PyObject_po, PyObject_pkey ]



# c_int PyObject_AsCharBuffer(PyObject_pobj, char_p_pbuffer, Py_ssize_t_pbuffer_len)
PyObject_AsCharBuffer = _dll.PyObject_AsCharBuffer
PyObject_AsCharBuffer.restype = c_int
PyObject_AsCharBuffer.argtypes = [ PyObject_pobj, char_p_pbuffer, Py_ssize_t_pbuffer_len ]



# c_int PyObject_CheckReadBuffer(PyObject_pobj)
PyObject_CheckReadBuffer = _dll.PyObject_CheckReadBuffer
PyObject_CheckReadBuffer.restype = c_int
PyObject_CheckReadBuffer.argtypes = [ PyObject_pobj ]



# c_int PyObject_AsReadBuffer(PyObject_pobj, c_void_p_pbuffer, Py_ssize_t_pbuffer_len)
PyObject_AsReadBuffer = _dll.PyObject_AsReadBuffer
PyObject_AsReadBuffer.restype = c_int
PyObject_AsReadBuffer.argtypes = [ PyObject_pobj, c_void_p_pbuffer, Py_ssize_t_pbuffer_len ]



# c_int PyObject_AsWriteBuffer(PyObject_pobj, c_void_p_pbuffer, Py_ssize_t_pbuffer_len)
PyObject_AsWriteBuffer = _dll.PyObject_AsWriteBuffer
PyObject_AsWriteBuffer.restype = c_int
PyObject_AsWriteBuffer.argtypes = [ PyObject_pobj, c_void_p_pbuffer, Py_ssize_t_pbuffer_len ]



# c_int PyObject_GetBuffer(PyObject_pobj, Py_buffer_pview, c_int flags)
PyObject_GetBuffer = _dll.PyObject_GetBuffer
PyObject_GetBuffer.restype = c_int
PyObject_GetBuffer.argtypes = [ PyObject_pobj, Py_buffer_pview, c_int flags ]



# c_void_p PyBuffer_GetPoc_inter(Py_buffer_pview, Py_ssize_t_pindices)
PyBuffer_GetPoc_inter = _dll.PyBuffer_GetPoc_inter
PyBuffer_GetPoc_inter.restype = c_void_p
PyBuffer_GetPoc_inter.argtypes = [ Py_buffer_pview, Py_ssize_t_pindices ]



# c_int PyBuffer_ToContiguous(c_void_pbuf, Py_buffer_pview, Py_ssize_t len, char fort)
PyBuffer_ToContiguous = _dll.PyBuffer_ToContiguous
PyBuffer_ToContiguous.restype = c_int
PyBuffer_ToContiguous.argtypes = [ c_void_pbuf, Py_buffer_pview, Py_ssize_t len, char fort ]



# c_int PyBuffer_FromContiguous(Py_buffer_pview, c_void_pbuf, Py_ssize_t len, char fort)
PyBuffer_FromContiguous = _dll.PyBuffer_FromContiguous
PyBuffer_FromContiguous.restype = c_int
PyBuffer_FromContiguous.argtypes = [ Py_buffer_pview, c_void_pbuf, Py_ssize_t len, char fort ]



# c_int PyObject_CopyData(PyObject_pdest, PyObject_psrc)
PyObject_CopyData = _dll.PyObject_CopyData
PyObject_CopyData.restype = c_int
PyObject_CopyData.argtypes = [ PyObject_pdest, PyObject_psrc ]



# c_int PyBuffer_IsContiguous(Py_buffer_pview, char fort)
PyBuffer_IsContiguous = _dll.PyBuffer_IsContiguous
PyBuffer_IsContiguous.restype = c_int
PyBuffer_IsContiguous.argtypes = [ Py_buffer_pview, char fort ]



# c_void PyBuffer_FillContiguousStrides(c_int ndims, Py_ssize_t_pshape, Py_ssize_t_pstrides, c_int itemsize, char fort)
PyBuffer_FillContiguousStrides = _dll.PyBuffer_FillContiguousStrides
PyBuffer_FillContiguousStrides.restype = c_void
PyBuffer_FillContiguousStrides.argtypes = [ c_int ndims, Py_ssize_t_pshape, Py_ssize_t_pstrides, c_int itemsize, char fort ]



# c_int PyBuffer_FillInfo(Py_buffer_pview, PyObject_po, c_void_pbuf, Py_ssize_t len, c_int readonly, c_int flags)
PyBuffer_FillInfo = _dll.PyBuffer_FillInfo
PyBuffer_FillInfo.restype = c_int
PyBuffer_FillInfo.argtypes = [ Py_buffer_pview, PyObject_po, c_void_pbuf, Py_ssize_t len, c_int readonly, c_int flags ]



# c_void PyBuffer_Release(Py_buffer_pview)
PyBuffer_Release = _dll.PyBuffer_Release
PyBuffer_Release.restype = c_void
PyBuffer_Release.argtypes = [ Py_buffer_pview ]



# PyObject_p PyObject_Format(PyObject_p obj, PyObject_pformat_spec)
PyObject_Format = _dll.PyObject_Format
PyObject_Format.restype = PyObject_p
PyObject_Format.argtypes = [ PyObject_p obj, PyObject_pformat_spec ]



# PyObject_p PyObject_GetIter(PyObject_p)
PyObject_GetIter = _dll.PyObject_GetIter
PyObject_GetIter.restype = PyObject_p
PyObject_GetIter.argtypes = [ PyObject_p ]



# PyObject_p PyIter_Next(PyObject_p)
PyIter_Next = _dll.PyIter_Next
PyIter_Next.restype = PyObject_p
PyIter_Next.argtypes = [ PyObject_p ]



# c_int PyNumber_Check(PyObject_po)
PyNumber_Check = _dll.PyNumber_Check
PyNumber_Check.restype = c_int
PyNumber_Check.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Add(PyObject_po1, PyObject_po2)
PyNumber_Add = _dll.PyNumber_Add
PyNumber_Add.restype = PyObject_p
PyNumber_Add.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Subtract(PyObject_po1, PyObject_po2)
PyNumber_Subtract = _dll.PyNumber_Subtract
PyNumber_Subtract.restype = PyObject_p
PyNumber_Subtract.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Multiply(PyObject_po1, PyObject_po2)
PyNumber_Multiply = _dll.PyNumber_Multiply
PyNumber_Multiply.restype = PyObject_p
PyNumber_Multiply.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Divide(PyObject_po1, PyObject_po2)
PyNumber_Divide = _dll.PyNumber_Divide
PyNumber_Divide.restype = PyObject_p
PyNumber_Divide.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_FloorDivide(PyObject_po1, PyObject_po2)
PyNumber_FloorDivide = _dll.PyNumber_FloorDivide
PyNumber_FloorDivide.restype = PyObject_p
PyNumber_FloorDivide.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_TrueDivide(PyObject_po1, PyObject_po2)
PyNumber_TrueDivide = _dll.PyNumber_TrueDivide
PyNumber_TrueDivide.restype = PyObject_p
PyNumber_TrueDivide.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Remainder(PyObject_po1, PyObject_po2)
PyNumber_Remainder = _dll.PyNumber_Remainder
PyNumber_Remainder.restype = PyObject_p
PyNumber_Remainder.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Divmod(PyObject_po1, PyObject_po2)
PyNumber_Divmod = _dll.PyNumber_Divmod
PyNumber_Divmod.restype = PyObject_p
PyNumber_Divmod.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Power(PyObject_po1, PyObject_po2, PyObject_po3)
PyNumber_Power = _dll.PyNumber_Power
PyNumber_Power.restype = PyObject_p
PyNumber_Power.argtypes = [ PyObject_po1, PyObject_po2, PyObject_po3 ]



# PyObject_p PyNumber_Negative(PyObject_po)
PyNumber_Negative = _dll.PyNumber_Negative
PyNumber_Negative.restype = PyObject_p
PyNumber_Negative.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Positive(PyObject_po)
PyNumber_Positive = _dll.PyNumber_Positive
PyNumber_Positive.restype = PyObject_p
PyNumber_Positive.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Absolute(PyObject_po)
PyNumber_Absolute = _dll.PyNumber_Absolute
PyNumber_Absolute.restype = PyObject_p
PyNumber_Absolute.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Invert(PyObject_po)
PyNumber_Invert = _dll.PyNumber_Invert
PyNumber_Invert.restype = PyObject_p
PyNumber_Invert.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Lshift(PyObject_po1, PyObject_po2)
PyNumber_Lshift = _dll.PyNumber_Lshift
PyNumber_Lshift.restype = PyObject_p
PyNumber_Lshift.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Rshift(PyObject_po1, PyObject_po2)
PyNumber_Rshift = _dll.PyNumber_Rshift
PyNumber_Rshift.restype = PyObject_p
PyNumber_Rshift.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_And(PyObject_po1, PyObject_po2)
PyNumber_And = _dll.PyNumber_And
PyNumber_And.restype = PyObject_p
PyNumber_And.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Xor(PyObject_po1, PyObject_po2)
PyNumber_Xor = _dll.PyNumber_Xor
PyNumber_Xor.restype = PyObject_p
PyNumber_Xor.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Or(PyObject_po1, PyObject_po2)
PyNumber_Or = _dll.PyNumber_Or
PyNumber_Or.restype = PyObject_p
PyNumber_Or.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_Index(PyObject_po)
PyNumber_Index = _dll.PyNumber_Index
PyNumber_Index.restype = PyObject_p
PyNumber_Index.argtypes = [ PyObject_po ]



# Py_ssize_t PyNumber_AsSsize_t(PyObject_po, PyObject_pexc)
PyNumber_AsSsize_t = _dll.PyNumber_AsSsize_t
PyNumber_AsSsize_t.restype = Py_ssize_t
PyNumber_AsSsize_t.argtypes = [ PyObject_po, PyObject_pexc ]



# PyObject_p _PyNumber_Convertc_integralToc_int( PyObject_pc_integral, char_p error_format)
_PyNumber_Convertc_integralToc_int = _dll._PyNumber_Convertc_integralToc_int
_PyNumber_Convertc_integralToc_int.restype = PyObject_p
_PyNumber_Convertc_integralToc_int.argtypes = [  PyObject_pc_integral, char_p error_format ]



# PyObject_p PyNumber_c_int(PyObject_po)
PyNumber_c_int = _dll.PyNumber_c_int
PyNumber_c_int.restype = PyObject_p
PyNumber_c_int.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Long(PyObject_po)
PyNumber_Long = _dll.PyNumber_Long
PyNumber_Long.restype = PyObject_p
PyNumber_Long.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_Float(PyObject_po)
PyNumber_Float = _dll.PyNumber_Float
PyNumber_Float.restype = PyObject_p
PyNumber_Float.argtypes = [ PyObject_po ]



# PyObject_p PyNumber_InPlaceAdd(PyObject_po1, PyObject_po2)
PyNumber_InPlaceAdd = _dll.PyNumber_InPlaceAdd
PyNumber_InPlaceAdd.restype = PyObject_p
PyNumber_InPlaceAdd.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceSubtract(PyObject_po1, PyObject_po2)
PyNumber_InPlaceSubtract = _dll.PyNumber_InPlaceSubtract
PyNumber_InPlaceSubtract.restype = PyObject_p
PyNumber_InPlaceSubtract.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceMultiply(PyObject_po1, PyObject_po2)
PyNumber_InPlaceMultiply = _dll.PyNumber_InPlaceMultiply
PyNumber_InPlaceMultiply.restype = PyObject_p
PyNumber_InPlaceMultiply.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceDivide(PyObject_po1, PyObject_po2)
PyNumber_InPlaceDivide = _dll.PyNumber_InPlaceDivide
PyNumber_InPlaceDivide.restype = PyObject_p
PyNumber_InPlaceDivide.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceFloorDivide(PyObject_po1, PyObject_po2)
PyNumber_InPlaceFloorDivide = _dll.PyNumber_InPlaceFloorDivide
PyNumber_InPlaceFloorDivide.restype = PyObject_p
PyNumber_InPlaceFloorDivide.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceTrueDivide(PyObject_po1, PyObject_po2)
PyNumber_InPlaceTrueDivide = _dll.PyNumber_InPlaceTrueDivide
PyNumber_InPlaceTrueDivide.restype = PyObject_p
PyNumber_InPlaceTrueDivide.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceRemainder(PyObject_po1, PyObject_po2)
PyNumber_InPlaceRemainder = _dll.PyNumber_InPlaceRemainder
PyNumber_InPlaceRemainder.restype = PyObject_p
PyNumber_InPlaceRemainder.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlacePower(PyObject_po1, PyObject_po2, PyObject_po3)
PyNumber_InPlacePower = _dll.PyNumber_InPlacePower
PyNumber_InPlacePower.restype = PyObject_p
PyNumber_InPlacePower.argtypes = [ PyObject_po1, PyObject_po2, PyObject_po3 ]



# PyObject_p PyNumber_InPlaceLshift(PyObject_po1, PyObject_po2)
PyNumber_InPlaceLshift = _dll.PyNumber_InPlaceLshift
PyNumber_InPlaceLshift.restype = PyObject_p
PyNumber_InPlaceLshift.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceRshift(PyObject_po1, PyObject_po2)
PyNumber_InPlaceRshift = _dll.PyNumber_InPlaceRshift
PyNumber_InPlaceRshift.restype = PyObject_p
PyNumber_InPlaceRshift.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceAnd(PyObject_po1, PyObject_po2)
PyNumber_InPlaceAnd = _dll.PyNumber_InPlaceAnd
PyNumber_InPlaceAnd.restype = PyObject_p
PyNumber_InPlaceAnd.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceXor(PyObject_po1, PyObject_po2)
PyNumber_InPlaceXor = _dll.PyNumber_InPlaceXor
PyNumber_InPlaceXor.restype = PyObject_p
PyNumber_InPlaceXor.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_InPlaceOr(PyObject_po1, PyObject_po2)
PyNumber_InPlaceOr = _dll.PyNumber_InPlaceOr
PyNumber_InPlaceOr.restype = PyObject_p
PyNumber_InPlaceOr.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PyNumber_ToBase(PyObject_pn, c_int base)
PyNumber_ToBase = _dll.PyNumber_ToBase
PyNumber_ToBase.restype = PyObject_p
PyNumber_ToBase.argtypes = [ PyObject_pn, c_int base ]



# c_int PySequence_Check(PyObject_po)
PySequence_Check = _dll.PySequence_Check
PySequence_Check.restype = c_int
PySequence_Check.argtypes = [ PyObject_po ]



# Py_ssize_t PySequence_Size(PyObject_po)
PySequence_Size = _dll.PySequence_Size
PySequence_Size.restype = Py_ssize_t
PySequence_Size.argtypes = [ PyObject_po ]



# Py_ssize_t PySequence_Length(PyObject_po)
PySequence_Length = _dll.PySequence_Length
PySequence_Length.restype = Py_ssize_t
PySequence_Length.argtypes = [ PyObject_po ]



# PyObject_p PySequence_Concat(PyObject_po1, PyObject_po2)
PySequence_Concat = _dll.PySequence_Concat
PySequence_Concat.restype = PyObject_p
PySequence_Concat.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PySequence_Repeat(PyObject_po, Py_ssize_t count)
PySequence_Repeat = _dll.PySequence_Repeat
PySequence_Repeat.restype = PyObject_p
PySequence_Repeat.argtypes = [ PyObject_po, Py_ssize_t count ]



# PyObject_p PySequence_GetItem(PyObject_po, Py_ssize_t i)
PySequence_GetItem = _dll.PySequence_GetItem
PySequence_GetItem.restype = PyObject_p
PySequence_GetItem.argtypes = [ PyObject_po, Py_ssize_t i ]



# PyObject_p PySequence_GetSlice(PyObject_po, Py_ssize_t i1, Py_ssize_t i2)
PySequence_GetSlice = _dll.PySequence_GetSlice
PySequence_GetSlice.restype = PyObject_p
PySequence_GetSlice.argtypes = [ PyObject_po, Py_ssize_t i1, Py_ssize_t i2 ]



# c_int PySequence_SetItem(PyObject_po, Py_ssize_t i, PyObject_pv)
PySequence_SetItem = _dll.PySequence_SetItem
PySequence_SetItem.restype = c_int
PySequence_SetItem.argtypes = [ PyObject_po, Py_ssize_t i, PyObject_pv ]



# c_int PySequence_DelItem(PyObject_po, Py_ssize_t i)
PySequence_DelItem = _dll.PySequence_DelItem
PySequence_DelItem.restype = c_int
PySequence_DelItem.argtypes = [ PyObject_po, Py_ssize_t i ]



# c_int PySequence_SetSlice(PyObject_po, Py_ssize_t i1, Py_ssize_t i2, PyObject_pv)
PySequence_SetSlice = _dll.PySequence_SetSlice
PySequence_SetSlice.restype = c_int
PySequence_SetSlice.argtypes = [ PyObject_po, Py_ssize_t i1, Py_ssize_t i2, PyObject_pv ]



# c_int PySequence_DelSlice(PyObject_po, Py_ssize_t i1, Py_ssize_t i2)
PySequence_DelSlice = _dll.PySequence_DelSlice
PySequence_DelSlice.restype = c_int
PySequence_DelSlice.argtypes = [ PyObject_po, Py_ssize_t i1, Py_ssize_t i2 ]



# PyObject_p PySequence_Tuple(PyObject_po)
PySequence_Tuple = _dll.PySequence_Tuple
PySequence_Tuple.restype = PyObject_p
PySequence_Tuple.argtypes = [ PyObject_po ]



# PyObject_p PySequence_List(PyObject_po)
PySequence_List = _dll.PySequence_List
PySequence_List.restype = PyObject_p
PySequence_List.argtypes = [ PyObject_po ]



# PyObject_p PySequence_Fast(PyObject_po, char_p m)
PySequence_Fast = _dll.PySequence_Fast
PySequence_Fast.restype = PyObject_p
PySequence_Fast.argtypes = [ PyObject_po, char_p m ]



# Py_ssize_t PySequence_Count(PyObject_po, PyObject_pvalue)
PySequence_Count = _dll.PySequence_Count
PySequence_Count.restype = Py_ssize_t
PySequence_Count.argtypes = [ PyObject_po, PyObject_pvalue ]



# c_int PySequence_Contains(PyObject_pseq, PyObject_pob)
PySequence_Contains = _dll.PySequence_Contains
PySequence_Contains.restype = c_int
PySequence_Contains.argtypes = [ PyObject_pseq, PyObject_pob ]



# Py_ssize_t _PySequence_IterSearch(PyObject_pseq, PyObject_pobj, c_int operation)
_PySequence_IterSearch = _dll._PySequence_IterSearch
_PySequence_IterSearch.restype = Py_ssize_t
_PySequence_IterSearch.argtypes = [ PyObject_pseq, PyObject_pobj, c_int operation ]



# c_int PySequence_In(PyObject_po, PyObject_pvalue)
PySequence_In = _dll.PySequence_In
PySequence_In.restype = c_int
PySequence_In.argtypes = [ PyObject_po, PyObject_pvalue ]



# Py_ssize_t PySequence_Index(PyObject_po, PyObject_pvalue)
PySequence_Index = _dll.PySequence_Index
PySequence_Index.restype = Py_ssize_t
PySequence_Index.argtypes = [ PyObject_po, PyObject_pvalue ]



# PyObject_p PySequence_InPlaceConcat(PyObject_po1, PyObject_po2)
PySequence_InPlaceConcat = _dll.PySequence_InPlaceConcat
PySequence_InPlaceConcat.restype = PyObject_p
PySequence_InPlaceConcat.argtypes = [ PyObject_po1, PyObject_po2 ]



# PyObject_p PySequence_InPlaceRepeat(PyObject_po, Py_ssize_t count)
PySequence_InPlaceRepeat = _dll.PySequence_InPlaceRepeat
PySequence_InPlaceRepeat.restype = PyObject_p
PySequence_InPlaceRepeat.argtypes = [ PyObject_po, Py_ssize_t count ]



# c_int PyMapping_Check(PyObject_po)
PyMapping_Check = _dll.PyMapping_Check
PyMapping_Check.restype = c_int
PyMapping_Check.argtypes = [ PyObject_po ]



# Py_ssize_t PyMapping_Size(PyObject_po)
PyMapping_Size = _dll.PyMapping_Size
PyMapping_Size.restype = Py_ssize_t
PyMapping_Size.argtypes = [ PyObject_po ]



# Py_ssize_t PyMapping_Length(PyObject_po)
PyMapping_Length = _dll.PyMapping_Length
PyMapping_Length.restype = Py_ssize_t
PyMapping_Length.argtypes = [ PyObject_po ]



# c_int PyMapping_HasKeyString(PyObject_po, char_pkey)
PyMapping_HasKeyString = _dll.PyMapping_HasKeyString
PyMapping_HasKeyString.restype = c_int
PyMapping_HasKeyString.argtypes = [ PyObject_po, char_pkey ]



# c_int PyMapping_HasKey(PyObject_po, PyObject_pkey)
PyMapping_HasKey = _dll.PyMapping_HasKey
PyMapping_HasKey.restype = c_int
PyMapping_HasKey.argtypes = [ PyObject_po, PyObject_pkey ]



# PyObject_p PyMapping_GetItemString(PyObject_po, char_pkey)
PyMapping_GetItemString = _dll.PyMapping_GetItemString
PyMapping_GetItemString.restype = PyObject_p
PyMapping_GetItemString.argtypes = [ PyObject_po, char_pkey ]



# c_int PyMapping_SetItemString(PyObject_po, char_pkey, PyObject_pvalue)
PyMapping_SetItemString = _dll.PyMapping_SetItemString
PyMapping_SetItemString.restype = c_int
PyMapping_SetItemString.argtypes = [ PyObject_po, char_pkey, PyObject_pvalue ]



# c_int PyObject_IsInstance(PyObject_pobject, PyObject_ptypeorclass)
PyObject_IsInstance = _dll.PyObject_IsInstance
PyObject_IsInstance.restype = c_int
PyObject_IsInstance.argtypes = [ PyObject_pobject, PyObject_ptypeorclass ]



# c_int PyObject_IsSubclass(PyObject_pobject, PyObject_ptypeorclass)
PyObject_IsSubclass = _dll.PyObject_IsSubclass
PyObject_IsSubclass.restype = c_int
PyObject_IsSubclass.argtypes = [ PyObject_pobject, PyObject_ptypeorclass ]



# c_int _PyObject_RealIsInstance(PyObject_pinst, PyObject_pcls)
_PyObject_RealIsInstance = _dll._PyObject_RealIsInstance
_PyObject_RealIsInstance.restype = c_int
_PyObject_RealIsInstance.argtypes = [ PyObject_pinst, PyObject_pcls ]



# c_int _PyObject_RealIsSubclass(PyObject_pderived, PyObject_pcls)
_PyObject_RealIsSubclass = _dll._PyObject_RealIsSubclass
_PyObject_RealIsSubclass.restype = c_int
_PyObject_RealIsSubclass.argtypes = [ PyObject_pderived, PyObject_pcls ]



# c_void _Py_add_one_to_index_F(c_int nd, Py_ssize_t_pindex, Py_ssize_t_pshape)
_Py_add_one_to_index_F = _dll._Py_add_one_to_index_F
_Py_add_one_to_index_F.restype = c_void
_Py_add_one_to_index_F.argtypes = [ c_int nd, Py_ssize_t_pindex, Py_ssize_t_pshape ]



# c_void _Py_add_one_to_index_C(c_int nd, Py_ssize_t_pindex, Py_ssize_t_pshape)
_Py_add_one_to_index_C = _dll._Py_add_one_to_index_C
_Py_add_one_to_index_C.restype = c_void
_Py_add_one_to_index_C.argtypes = [ c_int nd, Py_ssize_t_pindex, Py_ssize_t_pshape ]



# extern PyTypeObject PyCode_Type
PyCode_Type = PyTypeObject.from_address(_dll.PyCode_Type)



# PyCodeObject_p PyCode_New( c_int, c_int, c_int, c_int, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, c_int, PyObject_p)
PyCode_New = _dll.PyCode_New
PyCode_New.restype = PyCodeObject_p
PyCode_New.argtypes = [  c_int, c_int, c_int, c_int, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, PyObject_p, c_int, PyObject_p ]



# PyCodeObject_p PyCode_NewEmpty(char_pfilename, char_pfuncname, c_int firstlineno)
PyCode_NewEmpty = _dll.PyCode_NewEmpty
PyCode_NewEmpty.restype = PyCodeObject_p
PyCode_NewEmpty.argtypes = [ char_pfilename, char_pfuncname, c_int firstlineno ]



# c_int PyCode_Addr2Line(PyCodeObject_p, c_int)
PyCode_Addr2Line = _dll.PyCode_Addr2Line
PyCode_Addr2Line.restype = c_int
PyCode_Addr2Line.argtypes = [ PyCodeObject_p, c_int ]



# c_int _PyCode_CheckLineNumber(PyCodeObject_p co, c_int lasti, PyAddrPair_pbounds)
_PyCode_CheckLineNumber = _dll._PyCode_CheckLineNumber
_PyCode_CheckLineNumber.restype = c_int
_PyCode_CheckLineNumber.argtypes = [ PyCodeObject_p co, c_int lasti, PyAddrPair_pbounds ]



# PyObject_p PyCode_Optimize(PyObject_pcode, PyObject_p consts, PyObject_pnames, PyObject_plineno_obj)
PyCode_Optimize = _dll.PyCode_Optimize
PyCode_Optimize.restype = PyObject_p
PyCode_Optimize.argtypes = [ PyObject_pcode, PyObject_p consts, PyObject_pnames, PyObject_plineno_obj ]



# PyCodeObject_p PyNode_Compile(struct _node_p, char_p)
PyNode_Compile = _dll.PyNode_Compile
PyNode_Compile.restype = PyCodeObject_p
PyNode_Compile.argtypes = [ struct _node_p, char_p ]



# PyCodeObject_p PyAST_Compile(struct _mod_p, char_p, PyCompilerFlags_p, PyArena_p)
PyAST_Compile = _dll.PyAST_Compile
PyAST_Compile.restype = PyCodeObject_p
PyAST_Compile.argtypes = [ struct _mod_p, char_p, PyCompilerFlags_p, PyArena_p ]



# PyFutureFeatures_p PyFuture_FromAST(struct _mod_p, char_p)
PyFuture_FromAST = _dll.PyFuture_FromAST
PyFuture_FromAST.restype = PyFutureFeatures_p
PyFuture_FromAST.argtypes = [ struct _mod_p, char_p ]



# PyObject_p PyEval_EvalCode(PyCodeObject_p, PyObject_p, PyObject_p)
PyEval_EvalCode = _dll.PyEval_EvalCode
PyEval_EvalCode.restype = PyObject_p
PyEval_EvalCode.argtypes = [ PyCodeObject_p, PyObject_p, PyObject_p ]



# PyObject_p PyEval_EvalCodeEx(PyCodeObject_pco, PyObject_pglobals, PyObject_plocals, PyObject_p_pargs, c_int argc, PyObject_p_pkwds, c_int kwdc, PyObject_p_pdefs, c_int defc, PyObject_pclosure)
PyEval_EvalCodeEx = _dll.PyEval_EvalCodeEx
PyEval_EvalCodeEx.restype = PyObject_p
PyEval_EvalCodeEx.argtypes = [ PyCodeObject_pco, PyObject_pglobals, PyObject_plocals, PyObject_p_pargs, c_int argc, PyObject_p_pkwds, c_int kwdc, PyObject_p_pdefs, c_int defc, PyObject_pclosure ]



# PyObject_p _PyEval_CallTracing(PyObject_pfunc, PyObject_pargs)
_PyEval_CallTracing = _dll._PyEval_CallTracing
_PyEval_CallTracing.restype = PyObject_p
_PyEval_CallTracing.argtypes = [ PyObject_pfunc, PyObject_pargs ]



# double PyOS_ascii_strtod(char_pstr, char_p_pptr)
PyOS_ascii_strtod = _dll.PyOS_ascii_strtod
PyOS_ascii_strtod.restype = double
PyOS_ascii_strtod.argtypes = [ char_pstr, char_p_pptr ]



# double PyOS_ascii_atof(char_pstr)
PyOS_ascii_atof = _dll.PyOS_ascii_atof
PyOS_ascii_atof.restype = double
PyOS_ascii_atof.argtypes = [ char_pstr ]



# char_p PyOS_ascii_formatd(char_pbuffer, c_size_t buf_len, char_pformat, double d)
PyOS_ascii_formatd = _dll.PyOS_ascii_formatd
PyOS_ascii_formatd.restype = char_p
PyOS_ascii_formatd.argtypes = [ char_pbuffer, c_size_t buf_len, char_pformat, double d ]



# double PyOS_string_to_double(char_pstr, char_p_pendptr, PyObject_poverflow_exception)
PyOS_string_to_double = _dll.PyOS_string_to_double
PyOS_string_to_double.restype = double
PyOS_string_to_double.argtypes = [ char_pstr, char_p_pendptr, PyObject_poverflow_exception ]



# char_p PyOS_double_to_string(double val, char format_code, c_int precision, c_int flags, c_int_ptype)
PyOS_double_to_string = _dll.PyOS_double_to_string
PyOS_double_to_string.restype = char_p
PyOS_double_to_string.argtypes = [ double val, char format_code, c_int precision, c_int flags, c_int_ptype ]



# double _Py_parse_inf_or_nan(char_pp, char_p_pendptr)
_Py_parse_inf_or_nan = _dll._Py_parse_inf_or_nan
_Py_parse_inf_or_nan.restype = double
_Py_parse_inf_or_nan.argtypes = [ char_pp, char_p_pendptr ]



# c_int PyOS_mystrnicmp(char_p, char_p, Py_ssize_t)
PyOS_mystrnicmp = _dll.PyOS_mystrnicmp
PyOS_mystrnicmp.restype = c_int
PyOS_mystrnicmp.argtypes = [ char_p, char_p, Py_ssize_t ]



# c_int PyOS_mystricmp(char_p, char_p)
PyOS_mystricmp = _dll.PyOS_mystricmp
PyOS_mystricmp.restype = c_int
PyOS_mystricmp.argtypes = [ char_p, char_p ]



# double _Py_dg_strtod(char_pstr, char_p_pptr)
_Py_dg_strtod = _dll._Py_dg_strtod
_Py_dg_strtod.restype = double
_Py_dg_strtod.argtypes = [ char_pstr, char_p_pptr ]



# char_p _Py_dg_dtoa(double d, c_int mode, c_int ndigits, c_int_pdecpt, c_int_psign, char_p_prve)
_Py_dg_dtoa = _dll._Py_dg_dtoa
_Py_dg_dtoa.restype = char_p
_Py_dg_dtoa.argtypes = [ double d, c_int mode, c_int ndigits, c_int_pdecpt, c_int_psign, char_p_prve ]



# c_void _Py_dg_freedtoa(char_ps)
_Py_dg_freedtoa = _dll._Py_dg_freedtoa
_Py_dg_freedtoa.restype = c_void
_Py_dg_freedtoa.argtypes = [ char_ps ]



# PyObject_p _Py_Mangle(PyObject_pp, PyObject_pname)
_Py_Mangle = _dll._Py_Mangle
_Py_Mangle.restype = PyObject_p
_Py_Mangle.argtypes = [ PyObject_pp, PyObject_pname ]



# extern PyTypeObject PyFrame_Type
PyFrame_Type = PyTypeObject.from_address(_dll.PyFrame_Type)



# PyFrameObject_p PyFrame_New(PyThreadState_p, PyCodeObject_p, PyObject_p, PyObject_p)
PyFrame_New = _dll.PyFrame_New
PyFrame_New.restype = PyFrameObject_p
PyFrame_New.argtypes = [ PyThreadState_p, PyCodeObject_p, PyObject_p, PyObject_p ]



# c_void PyFrame_BlockSetup(PyFrameObject_p, c_int, c_int, c_int)
PyFrame_BlockSetup = _dll.PyFrame_BlockSetup
PyFrame_BlockSetup.restype = c_void
PyFrame_BlockSetup.argtypes = [ PyFrameObject_p, c_int, c_int, c_int ]



# PyTryBlock_p PyFrame_BlockPop(PyFrameObject_p)
PyFrame_BlockPop = _dll.PyFrame_BlockPop
PyFrame_BlockPop.restype = PyTryBlock_p
PyFrame_BlockPop.argtypes = [ PyFrameObject_p ]



# c_void PyFrame_LocalsToFast(PyFrameObject_p, c_int)
PyFrame_LocalsToFast = _dll.PyFrame_LocalsToFast
PyFrame_LocalsToFast.restype = c_void
PyFrame_LocalsToFast.argtypes = [ PyFrameObject_p, c_int ]



# c_void PyFrame_FastToLocals(PyFrameObject_p)
PyFrame_FastToLocals = _dll.PyFrame_FastToLocals
PyFrame_FastToLocals.restype = c_void
PyFrame_FastToLocals.argtypes = [ PyFrameObject_p ]



# c_int PyFrame_ClearFreeList(c_void)
PyFrame_ClearFreeList = _dll.PyFrame_ClearFreeList
PyFrame_ClearFreeList.restype = c_int
PyFrame_ClearFreeList.argtypes = [ c_void ]



# c_int PyFrame_GetLineNumber(PyFrameObject_p)
PyFrame_GetLineNumber = _dll.PyFrame_GetLineNumber
PyFrame_GetLineNumber.restype = c_int
PyFrame_GetLineNumber.argtypes = [ PyFrameObject_p ]



# PyObject_p PyMember_Get(char_p, struct memberlist_p, char_p)
PyMember_Get = _dll.PyMember_Get
PyMember_Get.restype = PyObject_p
PyMember_Get.argtypes = [ char_p, struct memberlist_p, char_p ]



# c_int PyMember_Set(char_p, struct memberlist_p, char_p, PyObject_p)
PyMember_Set = _dll.PyMember_Set
PyMember_Set.restype = c_int
PyMember_Set.argtypes = [ char_p, struct memberlist_p, char_p, PyObject_p ]



# PyObject_p PyMember_GetOne(char_p, struct PyMemberDef_p)
PyMember_GetOne = _dll.PyMember_GetOne
PyMember_GetOne.restype = PyObject_p
PyMember_GetOne.argtypes = [ char_p, struct PyMemberDef_p ]



# c_int PyMember_SetOne(char_p, struct PyMemberDef_p, PyObject_p)
PyMember_SetOne = _dll.PyMember_SetOne
PyMember_SetOne.restype = c_int
PyMember_SetOne.argtypes = [ char_p, struct PyMemberDef_p, PyObject_p ]