cpp.hint

// Compiler
#define alignas(x)
#define _Alignas(x)
#define __extension__
#define attribute(x)
#define __attribute(x)
#define __attribute__(x)
#define __declspec(...)
#define __volatile volatile
#define __volatile__ volatile
#define explicit
#define constexpr
#define __const const
#define __const__ const
#define __label__
#define typeof decltype
#define __typeof decltype
#define __typeof__ decltype
#define complex
#define _Complex
#define __complex
#define __complex__
#define _Atomic
#define __thread
#define __auto_type auto
#define inline
#define __inline
#define __inline__
#define noreturn
#define _Noreturn
#define thread_local
#define _Thread_local
#define __flash
#define __flash1
#define __flash2
#define __flash3
#define __flash4
#define __flash5
#define __memx
#define __far
#define __ea
#define __seg_fs
#define __seg_gs
#define __signed signed
#define __signed__ signed
#define __unsigned unsigned
#define __unsigned__ unsigned
#define __restrict restrict
#define __restrict__ restrict
#define __restrict_arr restrict
#define asm(...)
#define __asm(...)
#define __asm__(...)
#define __w64
#define __fastcall
#define __stdcall
#define __cdecl
#define __thiscall
#define __clrcall
#define __ms_abi
#define __sysv_abi
#define register



// <__stdinc.h> + <hybrid/compiler.h>
#define DECL_BEGIN extern "C"{
#define __DECL_BEGIN extern "C"{
#define __SYSDECL_BEGIN extern "C"{
#define DECL_END }
#define __DECL_END }
#define __SYSDECL_END }

#define __pragma_GCC_diagnostic_push
#define __pragma_GCC_diagnostic_pop
#define __pragma_GCC_diagnostic_ignored(name)
#define __pragma_GCC_diagnostic_push_ignored(name)
#define __pragma_GCC_diagnostic_pop_ignored(name)
#define __pragma_MSVC_diagnostic_ignored
#define __pragma_MSVC_diagnostic_push_ignored
#define __pragma_MSVC_diagnostic_pop_ignored(ids)

#define __BOOL       bool
#define __LONGLONG   long long
#define __ULONGLONG  unsigned long long
#define __LONGDOUBLE long double

#define NULL 0
#define __NULLPTR 0

#define XBLOCK
#define __XBLOCK
#define XRETURN
#define __XRETURN

#define __register
#define __P(x) x
#define __builtin_va_list va_list
#define DFL(x) =x
#define __DFL(x) =x
#define COMPILER_FLEXIBLE_ARRAY(T,n) T n[]
#define __COMPILER_FLEXIBLE_ARRAY(T,n) T n[]
#define ASMNAME(x)
#define __COMPILER_ASMNAME(x)
#define UNUSED(...) __VA_ARGS__
#define __UNUSED(...) __VA_ARGS__
#define static_assert(...)
#define _Static_assert(...)
#define STATIC_ASSERT(...)
#define __STATIC_ASSERT(...)
#define STATIC_ASSERT_MSG(...)
#define __STATIC_ASSERT_MSG(...)

#define DEFINE_PRIVATE_ALIAS(n,o) int n(){}
#define __DEFINE_PRIVATE_ALIAS(n,o) int n(){}
#define DEFINE_PUBLIC_ALIAS(n,o) int n(){}
#define __DEFINE_PUBLIC_ALIAS(n,o) int n(){}
#define DEFINE_INTERN_ALIAS(n,o) int n(){}
#define __DEFINE_INTERN_ALIAS(n,o) int n(){}
#define DEFINE_PRIVATE_WEAK_ALIAS(n,o) int n(){}
#define __DEFINE_PRIVATE_WEAK_ALIAS(n,o) int n(){}
#define DEFINE_PUBLIC_WEAK_ALIAS(n,o) int n(){}
#define __DEFINE_PUBLIC_WEAK_ALIAS(n,o) int n(){}
#define DEFINE_INTERN_WEAK_ALIAS(n,o) int n(){}
#define __DEFINE_INTERN_WEAK_ALIAS(n,o) int n(){}

#define __COMPILER_SREDIRECT(decl,attr,T,name,asmname) extern T name;
#define __COMPILER_SREDIRECT2(decl,attr,Tdecl,name,asmname) extern Tdecl;
#define __COMPILER_REDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,args)                                        Treturn name param;
#define __COMPILER_REDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,args)                                              void name param;
#define __COMPILER_VREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,args,before_va_start,varcount,vartypes)     Treturn name param;
#define __COMPILER_VREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,args,before_va_start,varcount,vartypes)           void name param;
#define __COMPILER_VFREDIRECT(decl,attr,Treturn,nothrow,cc,name,paramf,asmnamef,vparamf,vasmnamef,args,before_va_start)  Treturn name paramf;
#define __COMPILER_VFREDIRECT_VOID(decl,attr,nothrow,cc,name,paramf,asmnamef,vparamf,vasmnamef,args,before_va_start)        void name paramf;
#define __COMPILER_XREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,code)                                       Treturn name param;
#define __COMPILER_XREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,code)                                             void name param;
#define __COMPILER_EIDECLARE(attr,Treturn,nothrow,cc,name,param,...)                                                     Treturn name param;
#define __COMPILER_EIREDIRECT(attr,Treturn,nothrow,cc,name,param,asmname,...)                                            Treturn name param;
#define __COMPILER_CREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,args)                                       Treturn name param;
#define __COMPILER_CREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,args)                                             void name param;
#define __COMPILER_CVREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,args,before_va_start,varcount,vartypes)    Treturn name param;
#define __COMPILER_CVREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,args,before_va_start,varcount,vartypes)          void name param;
#define __COMPILER_CVFREDIRECT(decl,attr,Treturn,nothrow,cc,name,paramf,asmnamef,vparamf,vasmnamef,args,before_va_start) Treturn name paramf;
#define __COMPILER_CVFREDIRECT_VOID(decl,attr,nothrow,cc,name,paramf,asmnamef,vparamf,vasmnamef,args,before_va_start)       void name paramf;
#define __COMPILER_CXREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,code)                                      Treturn name param;
#define __COMPILER_CXREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,code)                                            void name param;
#define __COMPILER_CEIDECLARE(attr,Treturn,nothrow,cc,name,param,...)                                                    Treturn name param;
#define __COMPILER_CEIREDIRECT(attr,Treturn,nothrow,cc,name,param,asmname,...)                                           Treturn name param;
#define REDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,args)                                                   Treturn name param;
#define REDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,args)                                                         void name param;
#define VREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,args,before_va_start,varcount,vartypes)                Treturn name param;
#define VREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,args,before_va_start,varcount,vartypes)                      void name param;
#define VFREDIRECT(decl,attr,Treturn,nothrow,cc,name,paramf,asmnamef,vparamf,vasmnamef,args,before_va_start)             Treturn name paramf;
#define VFREDIRECT_VOID(decl,attr,nothrow,cc,name,paramf,asmnamef,vparamf,vasmnamef,args,before_va_start)                   void name paramf;
#define XREDIRECT(decl,attr,Treturn,nothrow,cc,name,param,asmname,code)                                                  Treturn name param;
#define XREDIRECT_VOID(decl,attr,nothrow,cc,name,param,asmname,code)                                                        void name param;
#define EIDECLARE(attr,Treturn,nothrow,cc,name,param,...)                                                                Treturn name param;
#define EIREDIRECT(attr,Treturn,nothrow,cc,name,param,asmname,...)                                                       Treturn name param;

#define __NAMESPACE_GLB_SYM                ::
#define __NAMESPACE_STD_BEGIN              namespace std{
#define __NAMESPACE_STD_END                }
#define __NAMESPACE_STD_SYM                ::std::
#define __NAMESPACE_STD_USING(x)           using ::std::x;
#define __NAMESPACE_GLB_USING(x)           using ::x;
#define __NAMESPACE_GLB_USING_TYPE(x)      using ::x;
#define __NAMESPACE_GLB_USING_OR_IMPL(x,i) using ::x;

#define __NAMESPACE_INT_BEGIN namespace __intern{
#define __NAMESPACE_INT_END   }
#define __NAMESPACE_INT_SYM   ::__intern::
#define __NAMESPACE_INT_LSYM  __intern::

#define __STATIC_IF(x) if(x)
#define __STATIC_ELSE(x) else
#define __IF0 if(0)
#define __IF1 if(1)
#define __WHILE0 while(0)
#define __WHILE1 while(1)
#define likely
#define unlikely
#define __likely
#define __unlikely
#define likely_untraced
#define unlikely_untraced
#define __likely_untraced
#define __unlikely_untraced
#define untraced
#define __untraced

#define IMPDEF extern
#define __IMPDEF extern
#define EXPDEF
#define __EXPDEF
#define FUNDEF
#define __PUBDEF
#define DATDEF extern
#define __DATDEF extern
#define PUBLIC
#define __PUBLIC
#define INTERN
#define __INTERN
#define PUBLIC_CONST
#define __PUBLIC_CONST
#define INTERN_CONST
#define __INTERN_CONST
#define INTERN_COMDAT
#define __INTERN_COMDAT
#define INTDEF extern
#define __INTDEF extern
#define PRIVATE static
#define __PRIVATE static
#define FORCELOCAL
#define __FORCELOCAL
#define EXTERN_INLINE
#define __EXTERN_INLINE
#define EXTERN_FORCEINLINE
#define __EXTERN_FORCEINLINE
#define LOCAL
#define __LOCAL
#define __LOCAL_REDIRECT

#define NONNULL(...)
#define NONNULL_T(...)
#define ATTR_NONNULL(...)
#define ATTR_NONNULL_T(...)
#define __ATTR_NONNULL(...)
#define __ATTR_NONNULL_T(...)
#define NONNULL_CXX(...)
#define ATTR_NONNULL_CXX(...)
#define __ATTR_NONNULL_CXX(...)
#define WUNUSED
#define WUNUSED_T
#define ATTR_WUNUSED
#define ATTR_WUNUSED_T
#define __ATTR_WUNUSED
#define __ATTR_WUNUSED_T

#define NOTHROW
#define NOTHROW_T
#define __NOTHROW
#define __NOTHROW_T
#define NOTHROW_NCX
#define NOTHROW_NCX_T
#define __NOTHROW_NCX
#define __NOTHROW_NCX_T
#define NOTHROW_CB
#define NOTHROW_CB_T
#define __NOTHROW_CB
#define __NOTHROW_CB_T
#define NOTHROW_CB_NCX
#define NOTHROW_CB_NCX_T
#define __NOTHROW_CB_NCX
#define __NOTHROW_CB_NCX_T
#define __NOTHROW_KRN
#define NOTHROW_RPC
#define NOTHROW_RPC_T
#define __NOTHROW_RPC
#define __NOTHROW_RPC_T
#define NOTHROW_RPC_KOS
#define NOTHROW_RPC_KOS_T
#define __NOTHROW_RPC_KOS
#define __NOTHROW_RPC_KOS_T
#define NOTHROW_RPC_NOKOS
#define NOTHROW_RPC_NOKOS_T
#define __NOTHROW_RPC_NOKOS
#define __NOTHROW_RPC_NOKOS_T
#define NOTHROW_RPC_PURE
#define NOTHROW_RPC_PURE_T
#define __NOTHROW_RPC_PURE
#define __NOTHROW_RPC_PURE_T
#define NOTHROW_KERNEL
#define NOTHROW_KERNEL_T
#define __NOTHROW_KERNEL
#define __NOTHROW_KERNEL_T
#define NOTHROW_USER
#define NOTHROW_USER_T
#define __NOTHROW_USER
#define __NOTHROW_USER_T
#define THROWING(...)
#define THROWING_T(...)
#define __THROWING(...)
#define __THROWING_T(...)

#define ASMCALL
#define __ASMCALL

#define __ATTR_W64
#define ATTR_NOINLINE
#define __ATTR_NOINLINE
#define ATTR_NORETURN
#define ATTR_NORETURN_T
#define __ATTR_NORETURN
#define __ATTR_NORETURN_T
#define ATTR_FASTCALL
#define __ATTR_FASTCALL
#define ATTR_STDCALL
#define __ATTR_STDCALL
#define ATTR_CDECL
#define __ATTR_CDECL
#define ATTR_SYSVABI
#define __ATTR_SYSVABI
#define ATTR_MSABI
#define __ATTR_MSABI
#define ATTR_PURE
#define ATTR_PURE_T
#define __ATTR_PURE
#define __ATTR_PURE_T
#define ATTR_CONST
#define ATTR_CONST_T
#define __ATTR_CONST
#define __ATTR_CONST_T
#define ATTR_LEAF
#define ATTR_LEAF_P
#define __ATTR_LEAF
#define __ATTR_LEAF_T
#define ATTR_FLATTEN
#define __ATTR_FLATTEN
#define ATTR_MALLOC
#define ATTR_MALLOC_T
#define __ATTR_MALLOC
#define __ATTR_MALLOC_T
#define ATTR_HOT
#define ATTR_HOT_T
#define __ATTR_HOT
#define __ATTR_HOT_T
#define ATTR_COLD
#define ATTR_COLD_T
#define __ATTR_COLD
#define __ATTR_COLD_T
#define ATTR_WEAK
#define __ATTR_WEAK
#define ATTR_ALLOC_SIZE(x)
#define ATTR_ALLOC_SIZE_T(x)
#define __ATTR_ALLOC_SIZE(x)
#define __ATTR_ALLOC_SIZE_T(x)
#define ATTR_ASSUME_ALIGNED(x)
#define ATTR_ASSUME_ALIGNED_T(x)
#define __ATTR_ASSUME_ALIGNED(x)
#define __ATTR_ASSUME_ALIGNED_T(x)
#define ATTR_ALLOC_ALIGN(x)
#define ATTR_ALLOC_ALIGN_T(x)
#define __ATTR_ALLOC_ALIGN(x)
#define __ATTR_ALLOC_ALIGN_T(x)
#define ATTR_NOTHROW
#define ATTR_NOTHROW_T
#define __ATTR_NOTHROW
#define __ATTR_NOTHROW_T
#define ATTR_DLLIMPORT
#define __ATTR_DLLIMPORT
#define ATTR_DLLEXPORT
#define __ATTR_DLLEXPORT
#define ATTR_NOCLONE
#define __ATTR_NOCLONE
#define ATTR_USED
#define __ATTR_USED
#define ATTR_UNUSED
#define __ATTR_UNUSED
#define ATTR_SENTINEL
#define ATTR_SENTINEL_T
#define __ATTR_SENTINEL
#define __ATTR_SENTINEL_T
#define ATTR_SENTINEL_O(x)
#define ATTR_SENTINEL_O_T(x)
#define __ATTR_SENTINEL_O(x)
#define __ATTR_SENTINEL_O_T(x)
#define ATTR_THREAD
#define __ATTR_THREAD
#define ATTR_DEPRECATED(x)
#define ATTR_DEPRECATED_T(x)
#define __ATTR_DEPRECATED(x)
#define __ATTR_DEPRECATED_T(x)
#define ATTR_DEPRECATED_
#define ATTR_DEPRECATED_T_
#define __ATTR_DEPRECATED_
#define __ATTR_DEPRECATED_T_
#define ATTR_WARNING(x)
#define ATTR_WARNING_T(x)
#define __ATTR_WARNING(x)
#define __ATTR_WARNING_T(x)
#define ATTR_ERROR(x)
#define ATTR_ERROR_T(x)
#define __ATTR_ERROR(x)
#define __ATTR_ERROR_T(x)
#define ATTR_SECTION(x)
#define __ATTR_SECTION(x)
#define ATTR_RETNONNULL
#define ATTR_RETNONNULL_T
#define __ATTR_RETNONNULL
#define __ATTR_RETNONNULL_T
#define ATTR_ALIGNED(x)
#define __ATTR_ALIGNED(x)
#define ATTR_ALIGN(...) __VA_ARGS__
#define __ATTR_ALIGN(...) __VA_ARGS__
#define ATTR_ALIAS(x)
#define __ATTR_ALIAS(x)
#define ATTR_INLINE
#define __ATTR_INLINE
#define ATTR_FORCEINLINE
#define __ATTR_FORCEINLINE
#define ATTR_PACKED
#define __ATTR_PACKED
#define ATTR_RETURNS_TWICE
#define ATTR_RETURNS_TWICE_T
#define __ATTR_RETURNS_TWICE
#define __ATTR_RETURNS_TWICE_T
#define ATTR_EXTERNALLY_VISIBLE
#define __ATTR_EXTERNALLY_VISIBLE
#define ATTR_ARTIFICIAL
#define __ATTR_ARTIFICIAL
#define ATTR_FORMAT_ARG(x)
#define ATTR_FORMAT_ARG_T(x)
#define __ATTR_FORMAT_ARG(x)
#define __ATTR_FORMAT_ARG_T(x)
#define ATTR_FALLTHROUGH ;
#define __ATTR_FALLTHROUGH ;
#define ATTR_OPTIMIZE(x)
#define __ATTR_OPTIMIZE(x)
#define ATTR_TRANSPARENT_UNION
#define __ATTR_TRANSPARENT_UNION
#define ATTR_FORMAT_PRINTF(...)
#define ATTR_FORMAT_PRINTF_T(...)
#define __ATTR_FORMAT_PRINTF(...)
#define __ATTR_FORMAT_PRINTF_T(...)
#define ATTR_FORMAT_SCANF(...)
#define ATTR_FORMAT_SCANF_T(...)
#define __ATTR_FORMAT_SCANF(...)
#define __ATTR_FORMAT_SCANF_T(...)
#define ATTR_FORMAT_STRFMON(...)
#define ATTR_FORMAT_STRFMON_T(...)
#define __ATTR_FORMAT_STRFMON(...)
#define __ATTR_FORMAT_STRFMON_T(...)
#define ATTR_FORMAT_STRFTIME(...)
#define ATTR_FORMAT_STRFTIME_T(...)
#define __ATTR_FORMAT_STRFTIME(...)
#define __ATTR_FORMAT_STRFTIME_T(...)
#define ATTR_NOPLT
#define __ATTR_NOPLT
#define ATTR_SELECTANY
#define __ATTR_SELECTANY
#define ATTR_VISIBILITY(x)
#define __ATTR_VISIBILITY(x)
#define ATTR_ACCESS_NONE(x)
#define ATTR_ACCESS_NONE_T(x)
#define __ATTR_ACCESS_NONE(x)
#define __ATTR_ACCESS_NONE_T(x)
#define ATTR_INS(x,y)
#define ATTR_INS_T(x,y)
#define __ATTR_INS(x,y)
#define __ATTR_INS_T(x,y)
#define ATTR_OUTS(x,y)
#define ATTR_OUTS_T(x,y)
#define __ATTR_OUTS(x,y)
#define __ATTR_OUTS_T(x,y)
#define ATTR_INOUTS(x,y)
#define ATTR_INOUTS_T(x,y)
#define __ATTR_INOUTS(x,y)
#define __ATTR_INOUTS_T(x,y)
#define ATTR_IN_OPT(x)
#define ATTR_IN_OPT_T(x)
#define __ATTR_IN_OPT(x)
#define __ATTR_IN_OPT_T(x)
#define ATTR_OUT_OPT(x)
#define ATTR_OUT_OPT_T(x)
#define __ATTR_OUT_OPT(x)
#define __ATTR_OUT_OPT_T(x)
#define ATTR_INOUT_OPT(x)
#define ATTR_INOUT_OPT_T(x)
#define __ATTR_INOUT_OPT(x)
#define __ATTR_INOUT_OPT_T(x)
#define ATTR_IN(x)
#define ATTR_IN_T(x)
#define __ATTR_IN(x)
#define __ATTR_IN_T(x)
#define ATTR_OUT(x)
#define ATTR_OUT_T(x)
#define __ATTR_OUT(x)
#define __ATTR_OUT_T(x)
#define ATTR_INOUT(x)
#define ATTR_INOUT_T(x)
#define __ATTR_INOUT(x)
#define __ATTR_INOUT_T(x)
#define ATTR_FDARG(x)
#define ATTR_FDARG_T(x)
#define __ATTR_FDARG(x)
#define __ATTR_FDARG_T(x)
#define ATTR_FDREAD(x)
#define ATTR_FDREAD_T(x)
#define __ATTR_FDREAD(x)
#define __ATTR_FDREAD_T(x)
#define ATTR_FDWRITE(x)
#define ATTR_FDWRITE_T(x)
#define __ATTR_FDWRITE(x)
#define __ATTR_FDWRITE_T(x)



// <__stdcxx.h>
#define __CXX_DEDUCE_TYPENAME typename
#define __CXX_FORCEINLINE
#define __CXX_CLASSMEMBER
#define __CXX_INLINE_CONSTEXPR
#define __CXX_DEFAULT_CTOR(T) T()
#define __CXX_DEFAULT_DTOR(T) ~T()
#define __CXX_DEFAULT_COPY(T,...) T(T const&)=default
#define __CXX_DEFAULT_CTOR_NOEXCEPT(T) T()
#define __CXX_DEFAULT_DTOR_NOEXCEPT(T) ~T()
#define __CXX_DEFAULT_COPY_NOEXCEPT(T,...) T(T const&)=default
#define __CXX_STATIC_CONST(T,decl) static T decl
#define __CXX_DELETE_CTOR(T) T()
#define __CXX_DELETE_DTOR(T) ~T()
#define __CXX_DELETE_COPY(T) T(T const&)
#define __CXX_DELETE_COPY_ASSIGN(T) T&operator=(T const&)
#define __CXX_DELETE_VOLATILE_COPY_ASSIGN(T) T&operator=(T const&)volatile
#define __CXXDECL_BEGIN extern "C++"{
#define __CXXDECL_END }
#define __CXX_THROWS(...)
#define __CXX_NOEXCEPT
#define __CXX_NOEXCEPT_IF(expr)
#define __CXX_NOEXCEPT_IS(expr)
#define __CXX_NOEXCEPT_IFNX(expr)
#define __CXX11_CONSTEXPR
#define __CXX11_CONSTEXPR_OR_CONST
#define __CXX14_CONSTEXPR
#define __CXX14_CONSTEXPR_OR_CONST
#define __CXX17_CONSTEXPR
#define __CXX17_CONSTEXPR_OR_CONST



// <hybrid/typecore.h>
#define INT8_C(c) c
#define __INT8_C(c) c
#define INT16_C(c) c
#define __INT16_C(c) c
#define INT32_C(c) c
#define __INT32_C(c) c
#define UINT8_C(c) c
#define __UINT8_C(c) c
#define UINT16_C(c) c
#define __UINT16_C(c) c
#define UINT32_C(c) c
#define __UINT32_C(c) c
#define INT64_C(c) c
#define __INT64_C(c) c
#define UINT64_C(c) c
#define __UINT64_C(c) c
#define INT128_C(c) c
#define __INT128_C(c) c
#define UINT128_C(c) c
#define __UINT128_C(c) c
#define INTMAX_C(c) c
#define __INTMAX_C(c) c
#define UINTMAX_C(c) c
#define __UINTMAX_C(c) c
#define INTPTR_C(c) c
#define __INTPTR_C(c) c
#define UINTPTR_C(c) c
#define __UINTPTR_C(c) c
#define SIZE_C(c) c
#define __SIZE_C(c) c
#define SSIZE_C(c) c
#define __SSIZE_C(c) c
#define __SHIFT_TYPE__        shift_t
#define __INT8_TYPE__         int8_t
#define __UINT8_TYPE__        uint8_t
#define __INT16_TYPE__        int16_t
#define __UINT16_TYPE__       uint16_t
#define __INT32_TYPE__        int32_t
#define __UINT32_TYPE__       uint32_t
#define __INT64_TYPE__        int64_t
#define __UINT64_TYPE__       uint64_t
#define __SIZE_TYPE__         size_t
#define __PTRDIFF_TYPE__      ptrdiff_t
#define __SSIZE_TYPE__        ssize_t
#define __INTPTR_TYPE__       intptr_t
#define __UINTPTR_TYPE__      uintptr_t
#define __BYTE_TYPE__         byte_t
#define __REGISTER_TYPE__     register_t
#define __SREGISTER_TYPE__    sregister_t
#define __TYPEFOR_INTIB1      int8_t
#define __TYPEFOR_UINTIB1     uint8_t
#define __TYPEFOR_INTIB2      int16_t
#define __TYPEFOR_UINTIB2     uint16_t
#define __TYPEFOR_INTIB4      int32_t
#define __TYPEFOR_UINTIB4     uint32_t
#define __TYPEFOR_INTIB8      int64_t
#define __TYPEFOR_UINTIB8     uint64_t
#define __CHAR8_TYPE__        char
#define __INT_LEAST8_TYPE__   int_least8_t
#define __UINT_LEAST8_TYPE__  uint_least8_t
#define __INT_LEAST16_TYPE__  int_least16_t
#define __UINT_LEAST16_TYPE__ uint_least16_t
#define __INT_LEAST32_TYPE__  int_least32_t
#define __UINT_LEAST32_TYPE__ uint_least32_t
#define __INT_LEAST64_TYPE__  int_least64_t
#define __UINT_LEAST64_TYPE__ uint_least64_t
#define __INT_FAST8_TYPE__    int_fast8_t
#define __UINT_FAST8_TYPE__   uint_fast8_t
#define __INT_FAST16_TYPE__   int_fast16_t
#define __UINT_FAST16_TYPE__  uint_fast16_t
#define __INT_FAST32_TYPE__   int_fast32_t
#define __UINT_FAST32_TYPE__  uint_fast32_t
#define __INT_FAST64_TYPE__   int_fast64_t
#define __UINT_FAST64_TYPE__  uint_fast64_t
#define __INTMAX_TYPE__       intmax_t
#define __UINTMAX_TYPE__      uintmax_t
#define __INTPTR_HALF_TYPE__  intptr_half_t
#define __UINTPTR_HALF_TYPE__ uintptr_half_t
#define __LONGPTR_TYPE__      longptr_t
#define __ULONGPTR_TYPE__     ulongptr_t
#define __SBYTE_TYPE__        sbyte_t
#define __WCHAR_TYPE__        wchar_t
#define __CHAR16_TYPE__       char16_t
#define __CHAR32_TYPE__       char32_t
#define __WCHAR16_TYPE__      char16_t
#define __WCHAR32_TYPE__      char32_t
#define __WINT_TYPE__         wint_t
#define __SIG_ATOMIC_TYPE__   sig_atomic_t
#define __INTSIZE_TYPE__      size_t
#define __INTSSIZE_TYPE__     ssize_t
#define __LONGSIZE_TYPE__     size_t
#define __LONGSSIZE_TYPE__    ssize_t
#define __LONG32_TYPE__       long32_t
#define __ULONG32_TYPE__      ulong32_t
#define __LONG64_TYPE__       long64_t
#define __ULONG64_TYPE__      ulong64_t



// <hybrid/pointer.h>
#define __HYBRID_FUNCPTR32(return,cc,name,args) return (cc*name)args
#define __HYBRID_FUNCPTR64(return,cc,name,args) return (cc*name)args
#define FUNCPTR32(return,cc,name,args) return (cc*name)args
#define FUNCPTR64(return,cc,name,args) return (cc*name)args
#define __HYBRID_PTR32(T) T*
#define __HYBRID_PTR64(T) T*
#define PTR32(T) T*
#define PTR64(T) T*



// <hybrid/bitset.h>
#define __hybrid_bitset_decl(x,n) x[n]
#define __hybrid_bitset_foreach(x,y,z) for(;;)
#define __hybrid_bitset_nforeach(x,y,z,a) for(;;)
#define __hybrid_bitset_nforeach_r(x,y,z,a) for(;;)
#define bitset_decl(x,n) x[n]
#define bitset_foreach(x,y,z) for(;;)
#define bitset_nforeach(x,y,z,a) for(;;)
#define bitset_nforeach_r(x,y,z,a) for(;;)



// <hybrid/__assembly.h>
#define PRIVATE_FUNCTION(sym)      ;int sym(){}
#define INTERN_FUNCTION(sym)       ;int sym(){}
#define PUBLIC_FUNCTION(sym)       ;int sym(){}
#define PRIVATE_WEAK_FUNCTION(sym) ;int sym(){}
#define INTERN_WEAK_FUNCTION(sym)  ;int sym(){}
#define PUBLIC_WEAK_FUNCTION(sym)  ;int sym(){}
#define PRIVATE_OBJECT(sym)        ;int sym;
#define INTERN_OBJECT(sym)         ;int sym;
#define PUBLIC_OBJECT(sym)         ;int sym;
#define PRIVATE_WEAK_OBJECT(sym)   ;int sym;
#define INTERN_WEAK_OBJECT(sym)    ;int sym;
#define PUBLIC_WEAK_OBJECT(sym)    ;int sym;
#define __ASM_BEGIN
#define __ASM_END
#define __ASM_ARG(x)
#define __ASM_L(...)



// <hybrid/__altint.h>
#define __HYBRID_ALTINT(UID,allow_int_ops,...) __VA_ARGS__
#define __HYBRID_ALTINT_UID(UID)
#define __HYBRID_ALTINT_COMPAT(Ta,Tb)
#define __HYBRID_ALTINT_TYPEDEF(Told,Tnew,allow_int_ops) typedef Told Tnew



// <hybrid/int128.h>
#define __HYBRID_INT128_DEFINE_BINARY_CXX_OPERATOR(op,name) \
	template<class ValType>__hybrid_uint128_t&operator op##=(__hybrid_uint128_t&self,ValType v){}\
	template<class ValType>__hybrid_int128_t&operator op##=(__hybrid_int128_t&self,ValType v){}\
	template<class ValType>__hybrid_uint128_t&operator op##=(__hybrid_uint128_t&self,ValType v){}\
	template<class ValType>__hybrid_int128_t&operator op##=(__hybrid_int128_t&self,ValType v){}\
	template<class ValType>__hybrid_uint128_t operator op(__hybrid_uint128_t const&self,ValType __v){}\
	template<class ValType>__hybrid_int128_t operator op(__hybrid_int128_t const&self,ValType __v){}\
	template<class ValType>__hybrid_uint128_t operator op(__hybrid_uint128_t const&self,ValType __v){}\
	template<class ValType>__hybrid_int128_t operator op(__hybrid_int128_t const&self,ValType __v){}\
	__hybrid_uint128_t&operator op##=(__hybrid_uint128_t&self,__hybrid_uint128_t const&v){}\
	__hybrid_uint128_t&operator op##=(__hybrid_uint128_t&self,__hybrid_int128_t const&v){}\
	__hybrid_int128_t&operator op##=(__hybrid_int128_t&self,__hybrid_uint128_t const&v){}\
	__hybrid_int128_t&operator op##=(__hybrid_int128_t&self,__hybrid_int128_t const&v){}\
	__hybrid_uint128_t operator op(__hybrid_uint128_t const&self,__hybrid_uint128_t const&v){}\
	__hybrid_uint128_t operator op(__hybrid_uint128_t const&self,__hybrid_int128_t const&v){}\
	__hybrid_int128_t operator op(__hybrid_int128_t const&self,__hybrid_uint128_t const&v){}\
	__hybrid_int128_t operator op(__hybrid_int128_t const&self,__hybrid_int128_t const&v){}
#define __HYBRID_INT128_DEFINE_COMPARE_CXX_OPERATOR(op,np,name) \
	template<class ValType>bool operator op(__hybrid_uint128_t const&self,ValType v){}\
	template<class ValType>bool operator np(__hybrid_uint128_t const&self,ValType v){}\
	template<class ValType>bool operator op(__hybrid_int128_t const&self,ValType v){}\
	template<class ValType>bool operator np(__hybrid_int128_t const&self,ValType v){}\
	template<class ValType>bool operator op(__hybrid_uint128_t const&self,ValType v){}\
	template<class ValType>bool operator np(__hybrid_uint128_t const&self,ValType v){}\
	template<class ValType>bool operator op(__hybrid_int128_t const&self,ValType v){}\
	template<class ValType>bool operator np(__hybrid_int128_t const&self,ValType v){}\
	bool operator op(__hybrid_int128_t const&self,__hybrid_int128_t const&v){}\
	bool operator op(__hybrid_int128_t const&self,__hybrid_uint128_t const&v){}\
	bool operator np(__hybrid_int128_t const&self,__hybrid_int128_t const&v){}\
	bool operator np(__hybrid_int128_t const&self,__hybrid_uint128_t const&v){}\
	bool operator op(__hybrid_uint128_t const&self,__hybrid_int128_t const&v){}\
	bool operator op(__hybrid_uint128_t const&self,__hybrid_uint128_t const&v){}\
	bool operator np(__hybrid_uint128_t const&self,__hybrid_int128_t const&v){}\
	bool operator np(__hybrid_uint128_t const&self,__hybrid_uint128_t const&v){}



// <hybrid/sequence/[...].h>
#define __HYBRID_Q_STRUCT struct
#define __HYBRID_Q_CLASS class
#define LIST_HEAD(n,t) struct n{struct t*lh_first;}
#define LIST_HEAD_P(T) struct{T*lh_first;}
#define LIST_ENTRY(t) struct{struct t*le_next,**le_prev;}
#define LIST_ENTRY_P(T) struct{T*le_next,**le_prev;}
#define __PRIVATE_FOREACH_STDFILENO(...) for(;;)
#define LIST_FOREACH(...) for(;;)
#define LIST_FOREACH_P(...) for(;;)
#define LIST_FOREACH_SAFE(...) for(;;)
#define LIST_FOREACH_SAFE_P(...) for(;;)
#define LIST_FOREACH_FROM(...) for(;;)
#define LIST_FOREACH_FROM_P(...) for(;;)
#define LIST_FOREACH_FROM_SAFE(...) for(;;)
#define LIST_FOREACH_FROM_SAFE_P(...) for(;;)
#define LIST_P_FOREACH(...) for(;;)
#define LIST_P_FOREACH_P(...) for(;;)

#define SLIST_HEAD(n,t) struct n{struct t*slh_first;}
#define SLIST_HEAD_P(T) struct{T*slh_first;}
#define SLIST_ENTRY(t) struct{struct t*sle_next;}
#define SLIST_ENTRY_P(T) struct{T*sle_next;}
#define SLIST_FOREACH(...) for(;;)
#define SLIST_FOREACH_P(...) for(;;)
#define SLIST_FOREACH_SAFE(...) for(;;)
#define SLIST_FOREACH_SAFE_P(...) for(;;)
#define SLIST_FOREACH_FROM(...) for(;;)
#define SLIST_FOREACH_FROM_P(...) for(;;)
#define SLIST_FOREACH_FROM_SAFE(...) for(;;)
#define SLIST_FOREACH_FROM_SAFE_P(...) for(;;)
#define SLIST_FOREACH_PREVPTR(...) for(;;)
#define SLIST_FOREACH_PREVPTR_P(...) for(;;)
#define SLIST_P_FOREACH(...) for(;;)
#define SLIST_P_FOREACH_P(...) for(;;)

#define STAILQ_HEAD(n,t) struct n{struct t*stqh_first,**stqh_last;}
#define STAILQ_ENTRY(t) struct{struct t*stqe_next;}
#define STAILQ_HEAD_P(T) struct{T*stqh_first,**stqh_last;}
#define STAILQ_ENTRY_P(T) struct{T*stqe_next;}
#define STAILQ_FOREACH(...) for(;;)
#define STAILQ_FOREACH_P(...) for(;;)
#define STAILQ_FOREACH_SAFE(...) for(;;)
#define STAILQ_FOREACH_SAFE_P(...) for(;;)
#define STAILQ_FOREACH_FROM(...) for(;;)
#define STAILQ_FOREACH_FROM_P(...) for(;;)
#define STAILQ_FOREACH_FROM_SAFE(...) for(;;)
#define STAILQ_FOREACH_FROM_SAFE_P(...) for(;;)

#define SIMPLEQ_HEAD(n,t) struct n{struct t*sqh_first,**sqh_last;}
#define SIMPLEQ_ENTRY(t) struct{struct t*sqe_next;}
#define SIMPLEQ_HEAD_P(T) struct{T*sqh_first,**sqh_last;}
#define SIMPLEQ_ENTRY_P(T) struct{T*sqe_next;}
#define SIMPLEQ_FOREACH(...) for(;;)
#define SIMPLEQ_FOREACH_P(...) for(;;)
#define SIMPLEQ_FOREACH_SAFE(...) for(;;)
#define SIMPLEQ_FOREACH_SAFE_P(...) for(;;)
#define SIMPLEQ_FOREACH_FROM(...) for(;;)
#define SIMPLEQ_FOREACH_FROM_P(...) for(;;)
#define SIMPLEQ_FOREACH_FROM_SAFE(...) for(;;)
#define SIMPLEQ_FOREACH_FROM_SAFE_P(...) for(;;)

#define _TAILQ_HEAD(n,T,q) struct n{T q*tqh_first,*q*tqh_last;}
#define _TAILQ_ENTRY(T,q) struct{T q*tqe_next,*q*tqe_prev;}
#define TAILQ_HEAD(n,t) struct n{struct t*tqh_first,**tqh_last;}
#define TAILQ_HEAD_P(T) struct{T*tqh_first,**tqh_last;}
#define TAILQ_ENTRY(t) struct{struct t*tqe_next,**tqe_prev;}
#define TAILQ_ENTRY_P(T) struct{T*tqe_next,**tqe_prev;}
#define TAILQ_FOREACH(...) for(;;)
#define TAILQ_FOREACH_P(...) for(;;)
#define TAILQ_FOREACH_REVERSE(...) for(;;)
#define TAILQ_FOREACH_REVERSE_P(...) for(;;)
#define TAILQ_FOREACH_SAFE(...) for(;;)
#define TAILQ_FOREACH_SAFE_P(...) for(;;)
#define TAILQ_FOREACH_REVERSE_SAFE(...) for(;;)
#define TAILQ_FOREACH_REVERSE_SAFE_P(...) for(;;)
#define TAILQ_FOREACH_FROM(...) for(;;)
#define TAILQ_FOREACH_FROM_P(...) for(;;)
#define TAILQ_FOREACH_REVERSE_FROM(...) for(;;)
#define TAILQ_FOREACH_REVERSE_FROM_P(...) for(;;)
#define TAILQ_FOREACH_FROM_SAFE(...) for(;;)
#define TAILQ_FOREACH_FROM_SAFE_P(...) for(;;)
#define TAILQ_FOREACH_REVERSE_FROM_SAFE(...) for(;;)
#define TAILQ_FOREACH_REVERSE_FROM_SAFE_P(...) for(;;)

#define CIRCLEQ_HEAD(n,t) struct n{struct t*cqh_first,*cqh_last;}
#define CIRCLEQ_HEAD_P(T) struct{T*cqh_first,*cqh_last;}
#define CIRCLEQ_ENTRY(t) struct{struct t*cqe_next,*cqe_prev;}
#define CIRCLEQ_ENTRY_P(T) struct{T*cqe_next,*cqe_prev;}
#define CIRCLEQ_FOREACH(...) for(;;)
#define CIRCLEQ_FOREACH_P(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_P(...) for(;;)
#define CIRCLEQ_FOREACH_SAFE(...) for(;;)
#define CIRCLEQ_FOREACH_SAFE_P(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_SAFE(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_SAFE_P(...) for(;;)
#define CIRCLEQ_FOREACH_FROM(...) for(;;)
#define CIRCLEQ_FOREACH_FROM_P(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_FROM(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_FROM_P(...) for(;;)
#define CIRCLEQ_FOREACH_FROM_SAFE(...) for(;;)
#define CIRCLEQ_FOREACH_FROM_SAFE_P(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_FROM_SAFE(...) for(;;)
#define CIRCLEQ_FOREACH_REVERSE_FROM_SAFE_P(...) for(;;)

#define RINGQ_ENTRY(t) struct{struct t*rqe_next,*rqe_prev;}
#define RINGQ_ENTRY_P(T) struct{T*rqe_next,*rqe_prev;}

#define DLIST_HEAD(n,t) struct n{struct t*dlh_first;}
#define DLIST_ENTRY(t) struct{struct t*dle_next,*dle_prev;}
#define DLIST_ENTRY_P(T) struct{T*dle_next,*dle_prev;}
#define DLIST_FOREACH(...) for(;;)
#define DLIST_FOREACH_P(...) for(;;)
#define DLIST_FOREACH_SAFE(...) for(;;)
#define DLIST_FOREACH_SAFE_P(...) for(;;)
#define DLIST_FOREACH_FROM(...) for(;;)
#define DLIST_FOREACH_FROM_P(...) for(;;)
#define DLIST_FOREACH_FROM_SAFE(...) for(;;)
#define DLIST_FOREACH_FROM_SAFE_P(...) for(;;)

#define LIST_TRYREMOVE_IF(...)
#define LIST_TRYREMOVE_IF_P(...)
#define LIST_REMOVEALL(...)
#define LIST_REMOVEALL_P(...)
#define LIST_TRYUNBIND_IF(...)
#define LIST_TRYUNBIND_IF_P(...)
#define LIST_UNBINDALL(...)
#define LIST_UNBINDALL_P(...)
#define DLIST_TRYREMOVE_IF(...)
#define DLIST_TRYREMOVE_IF_P(...)
#define DLIST_REMOVEALL(...)
#define DLIST_REMOVEALL_P(...)
#define SLIST_TRYREMOVE(...)
#define SLIST_TRYREMOVE_P(...)
#define SLIST_TRYREMOVE_IF(...)
#define SLIST_TRYREMOVE_IF_P(...)
#define SLIST_REMOVEALL(...)
#define SLIST_REMOVEALL_P(...)
#define SLIST_CONTAINS(...)
#define SLIST_CONTAINS_P(...)
#define SLIST_TRYREPLACE(...)
#define SLIST_TRYREPLACE_P(...)
#define SLIST_TRYREPLACE_R(...)
#define SLIST_TRYREPLACE_R_P(...)
#define STAILQ_TRYREMOVE(...)
#define STAILQ_TRYREMOVE_P(...)
#define STAILQ_TRYREMOVE_IF(...)
#define STAILQ_TRYREMOVE_IF_P(...)
#define STAILQ_REMOVEALL(...)
#define STAILQ_REMOVEALL_P(...)
#define STAILQ_CONTAINS(...)
#define STAILQ_CONTAINS_P(...)
#define STAILQ_TRYREPLACE(...)
#define STAILQ_TRYREPLACE_P(...)
#define STAILQ_TRYREPLACE_R(...)
#define STAILQ_TRYREPLACE_R_P(...)
#define SIMPLEQ_TRYREMOVE(...)
#define SIMPLEQ_TRYREMOVE_P(...)
#define SIMPLEQ_TRYREMOVE_IF(...)
#define SIMPLEQ_TRYREMOVE_IF_P(...)
#define SIMPLEQ_REMOVEALL(...)
#define SIMPLEQ_REMOVEALL_P(...)
#define SIMPLEQ_CONTAINS(...)
#define SIMPLEQ_CONTAINS_P(...)
#define SIMPLEQ_TRYREPLACE(...)
#define SIMPLEQ_TRYREPLACE_P(...)
#define SIMPLEQ_TRYREPLACE_R(...)
#define SIMPLEQ_TRYREPLACE_R_P(...)

#define RBTREE_NODE(T)                   struct{struct T*rb_par,*rb_lhs,*rb_rhs;}
#define RBTREE_NODE_P(T)                 struct{T*rb_par,*rb_lhs,*rb_rhs;}
#define RBTREE_NODE_WITH_KEY(T,Tkey)     struct{struct T*rb_par,*rb_lhs,*rb_rhs;Tkey rb_min,rb_max;}
#define RBTREE_NODE_WITH_KEY_P(T,Tkey)   struct{T*rb_par,*rb_lhs,*rb_rhs;Tkey rb_min,rb_max;}
#define LLRBTREE_NODE(T)                 struct{struct T*rb_lhs,*rb_rhs;}
#define LLRBTREE_NODE_P(T)               struct{T*rb_lhs,*rb_rhs;}
#define LLRBTREE_NODE_WITH_KEY(T,Tkey)   struct{struct T*rb_lhs,*rb_rhs;Tkey rb_min,rb_max;}
#define LLRBTREE_NODE_WITH_KEY_P(T,Tkey) struct{T*rb_lhs,*rb_rhs;Tkey rb_min,rb_max;}
#define RBTREE_ROOT(T)                   struct T*
#define LLRBTREE_ROOT(T)                 struct T*

#define RBTREE_DECL
#define RBTREE_IMPL
#define RBTREE_NOTHROW
#define RBTREE_NOTHROW_U
#define RBTREE_CC
#define RBTREE(x) rbtree_##x
#define RBTREE_SLOT__ARGS
#define RBTREE_SLOT__PARAMS
#define RBTREE_T struct my_node
#define RBTREE_Tkey int
#define RBTREE_DEFINE_FUNCTION(decl,attr,returnType,nothrow,cc,name,params,args) decl returnType name params



// <hybrid/[...].h>
#define __CDECL_OR_DEFAULT
#define __HYBRID_LIBATOMIC_DECL
#define __HYBRID_LIBATOMIC_CC
#define ____IMPL_DO_FFS(...) {}
#define ____IMPL_DO_CLZ(...) {}
#define ____IMPL_DO_CTZ(...) {}
#define ____IMPL_DO_POPCOUNT(...) {}
#define ____IMPL_DO_PARITY(...) {}
#define ____IMPL_DO_CLRSB(...) {}
#define ____IMPL_DO_PDEP(...) {}
#define ____IMPL_DO_PEXT(...) {}
#define BSEARCH(...) for(;;)
#define BSEARCH_EX(...) for(;;)
#define BSEARCH_RANGE(...) for(;;)
#define BSEARCH_RANGE_EX(...) for(;;)
#define BITSET(num_bits) struct{unsigned int _bs_bits[42];}
#define ATOMIC_ONCE_RUN(self,...) __VA_ARGS__



// <deemon/[...].h>
#define tpconst const
#define Dee_tpconst const
#define INTERN_TPCONST
#define PUBLIC_TPCONST

#define dssize_t Dee_ssize_t
#define dhash_t Dee_hash_t
#define dfunptr_t Dee_funptr_t
#define dformatprinter Dee_formatprinter_t

#define DeePrivateSystem_IF_E1(errno,e1,...)
#define DeePrivateSystem_IF_E2(errno,e1,e2,...)
#define DeePrivateSystem_IF_E3(errno,e1,e2,e3,...)
#define DeePrivateSystem_IF_E4(errno,e1,e2,e3,e4,...)
#define DeeSystem_IF_E1(errno,e1,...)
#define DeeSystem_IF_E2(errno,e1,e2,...)
#define DeeSystem_IF_E3(errno,e1,e2,e3,...)
#define DeeSystem_IF_E4(errno,e1,e2,e3,e4,...)

#define DeeSlab_ENUMERATE(func) func(0,4) func(1,5) func(2,6) func(3,8) func(4,10)
#define DEE_PRIVATE_DEFINE_SLAB_FUNCTIONS(index,size) \
	void*DeeSlab_Malloc##size(void);\
	void*DeeSlab_Calloc##size(void);\
	void*DeeSlab_TryMalloc##size(void);\
	void*DeeSlab_TryCalloc##size(void);\
	void*DeeDbgSlab_Malloc##size(char const*file,int line);\
	void*DeeDbgSlab_Calloc##size(char const*file,int line);\
	void*DeeDbgSlab_TryMalloc##size(char const*file,int line);\
	void*DeeDbgSlab_TryCalloc##size(char const*file,int line);\
	void*DeeGCObject_SlabMalloc##size(void);\
	void*DeeGCObject_SlabCalloc##size(void);\
	void*DeeGCObject_SlabTryMalloc##size(void);\
	void*DeeGCObject_SlabTryCalloc##size(void);\
	void DeeSlab_Free##size(void*restrict ptr);\
	void DeeDbgSlab_Free##size(void*restrict ptr,char const*file,int line);\
	void DeeGCObject_SlabFree##size(void*restrict ptr);
#define DEFINE_GC_SLAB_FUNCTIONS(index,size)\
	void*DeeGCObject_SlabMalloc##size(void){}\
	void*DeeGCObject_SlabCalloc##size(void){}\
	void*DeeGCObject_SlabTryMalloc##size(void){}\
	void*DeeGCObject_SlabTryCalloc##size(void){}\
	void DeeGCObject_SlabFree##size(void*restrict ptr){}\
	void*DeeDbgGCObject_SlabMalloc##size(char const*file,int line){}\
	void*DeeDbgGCObject_SlabCalloc##size(char const*file,int line){}\
	void*DeeDbgGCObject_SlabTryMalloc##size(char const*file,int line){}\
	void*DeeDbgGCObject_SlabTryCalloc##size(char const*file,int line){}\
	void DeeDbgGCObject_SlabFree##size(void*restrict ptr,char const*file,int line){}

#define DREF
#define DWEAK
#define DFCALL
#define DCALL
#define DPRINTER_CC
#define DFUNDEF
#define DDATDEF extern
#define DCALL_ASSEMBLY_NAME(x,s) x
#define Dee_DOC(x) x
#define Dee_DOC_DEF(n,x) char const n[]=x
#define Dee_DOC_REF(n) extern char const n[]
#define Dee_DOC_GET(n) n
#define DOC(x) x
#define DOC_DEF(n,x) char const n[]=x
#define DOC_REF(n) extern char const n[]
#define DOC_GET(n) n
#define DEE_CXX_BEGIN namespace deemon{
#define DEE_CXX_END }
#define DEE_CXX_NOTHROW

#define TPPCALL
#define TPPVCALL
#define TPPFUN
#define TPP_LOCAL
#define TPP(x) x
#define TPPSTRING_DEF(name, value) struct{refcnt_t _r;size_t _s;char _t[1];}name={}
#define PRIVDEF

#define OBJECT_HEAD               Dee_refcnt_t ob_refcnt;DeeTypeObject*ob_type;
#define Dee_OBJECT_HEAD           Dee_refcnt_t ob_refcnt;DeeTypeObject*ob_type;
#define OBJECT_HEAD_EX(Ttype)     Dee_refcnt_t ob_refcnt;Ttype*ob_type;
#define Dee_OBJECT_HEAD_EX(Ttype) Dee_refcnt_t ob_refcnt;Ttype*ob_type;
#define ERROR_OBJECT_HEAD         Dee_refcnt_t ob_refcnt;DeeTypeObject*ob_type;struct Dee_string_object*e_message;DeeObject*e_inner;
#define Dee_ERROR_OBJECT_HEAD     Dee_refcnt_t ob_refcnt;DeeTypeObject*ob_type;struct Dee_string_object*e_message;DeeObject*e_inner;
#define FILE_OBJECT_HEAD          Dee_refcnt_t ob_refcnt;DeeFileTypeObject*ob_type;
#define Dee_FILE_OBJECT_HEAD      Dee_refcnt_t ob_refcnt;DeeFileTypeObject*ob_type;

#define DEE_PRIVATE_REFCHANGE_PRIVATE_DATA
#define WEAKREF_SUPPORT           struct Dee_weakref_list ob_weakrefs;
#define Dee_WEAKREF_SUPPORT       struct Dee_weakref_list ob_weakrefs;
#define WEAKREF(T)                struct Dee_weakref
#define Dee_WEAKREF(T)            struct Dee_weakref

#define Dee_ONCE(...) __VA_ARGS__

#define Dee_CASE_WIDTH_1BYTE case 1
#define CASE_WIDTH_1BYTE case 1
#define Dee_CASE_WIDTH_2BYTE case 2
#define CASE_WIDTH_2BYTE case 2
#define Dee_CASE_WIDTH_4BYTE case 4
#define CASE_WIDTH_4BYTE case 4
#define Dee_SWITCH_SIZEOF_WIDTH(...) for(;;)
#define SWITCH_SIZEOF_WIDTH(...) for(;;)
#define DeeString_Foreach(...)

#define DeeType_mro_foreach_start(...) for(;;)

#define DeeThread_FOREACH(t) for(;;)

#define DDI_STATE_DO(ddi_xregs_iter,self) do
#define Dee_DDI_STATE_DO(ddi_xregs_iter,self) do
#define DDI_STATE_WHILE(ddi_xregs_iter,self) while(0)
#define Dee_DDI_STATE_WHILE(ddi_xregs_iter,self) while(0)


#define DEFINE_KWDS(n,...)                         DeeKwdsObject n={}
#define Dee_DEFINE_KWDS(n,...)                     DeeKwdsObject n={}
#define DEFINE_KWLIST(n,...)                       struct Dee_keyword n[]=__VA_ARGS__
#define Dee_DEFINE_KWLIST(n,...)                   struct Dee_keyword n[]=__VA_ARGS__
#define DECLARE_KWLIST(n,...)                      struct Dee_keyword n[]=__VA_ARGS__
#define DEFINE_BYTES(n,...)                        DeeBytesObject n={}
#define Dee_DEFINE_BYTES(n,...)                    DeeBytesObject n={}
#define DEFINE_BYTES_EX(n,...)                     DeeBytesObject n={}
#define Dee_DEFINE_BYTES_EX(n,...)                 DeeBytesObject n={}
#define DEFINE_CODE(n,...)                         DeeCodeObject n={}
#define Dee_DEFINE_CODE(n,...)                     DeeCodeObject n={}
#define DEFINE_FUNCTION(n,...)                     DeeFunctionObject n={}
#define Dee_DEFINE_FUNCTION(n,...)                 DeeFunctionObject n={}
#define DEFINE_FUNCTION_NOREFS(n,...)              DeeFunctionObject n={}
#define Dee_DEFINE_FUNCTION_NOREFS(n,...)          DeeFunctionObject n={}
#define DEFINE_YIELD_FUNCTION(n,...)               DeeYieldFunctionObject n={}
#define Dee_DEFINE_YIELD_FUNCTION(n,...)           DeeYieldFunctionObject n={}
#define DEFINE_YIELD_FUNCTION_NOARGS(n,...)        DeeYieldFunctionObject n={}
#define Dee_DEFINE_YIELD_FUNCTION_NOARGS(n,...)    DeeYieldFunctionObject n={}
#define DEFINE_OBJMETHOD(n,func,self)              DeeObjMethodObject n={}
#define Dee_DEFINE_OBJMETHOD(n,func,self)          DeeObjMethodObject n={}
#define DEFINE_KWOBJMETHOD(n,func,self)            DeeKwObjMethodObject n={}
#define Dee_DEFINE_KWOBJMETHOD(n,func,self)        DeeKwObjMethodObject n={}
#define DEFINE_CLSMETHOD(n,func,type)              DeeClsMethodObject n={}
#define Dee_DEFINE_CLSMETHOD(n,func,type)          DeeClsMethodObject n={}
#define DEFINE_KWCLSMETHOD(n,func,type)            DeeKwClsMethodObject n={}
#define Dee_DEFINE_KWCLSMETHOD(n,func,type)        DeeKwClsMethodObject n={}
#define DEFINE_CLSPROPERTY(n,type,get,del,set)     DeeClsPropertyObject n={}
#define Dee_DEFINE_CLSPROPERTY(n,type,get,del,set) DeeClsPropertyObject n={}
#define DEFINE_CMETHOD(n,func)                     DeeCMethodObject n={}
#define Dee_DEFINE_CMETHOD(n,func)                 DeeCMethodObject n={}
#define DEFINE_KWCMETHOD(n,func)                   DeeKwCMethodObject n={}
#define Dee_DEFINE_KWCMETHOD(n,func)               DeeKwCMethodObject n={}
#define DEFINE_STRING_EX(n,a,b,c)                  DeeStringObject n={}
#define Dee_DEFINE_STRING_EX(n,a,b,c)              DeeStringObject n={}
#define DEFINE_STRING(n,a)                         DeeStringObject n={}
#define Dee_DEFINE_STRING(n,a)                     DeeStringObject n={}
#define DEFINE_INT_1DIGIT(n,a)                     DeeIntObject n={}
#define Dee_DEFINE_INT_1DIGIT(n,a)                 DeeIntObject n={}
#define DEFINE_UINT_1DIGIT(n,a)                    DeeIntObject n={}
#define Dee_DEFINE_UINT_1DIGIT(n,a)                DeeIntObject n={}
#define DEFINE_INT_2DIGITS(n,a)                    DeeIntObject n={}
#define Dee_DEFINE_INT_2DIGITS(n,a)                DeeIntObject n={}
#define DEFINE_UINT_2DIGITS(n,a)                   DeeIntObject n={}
#define Dee_DEFINE_UINT_2DIGITS(n,a)               DeeIntObject n={}
#define DEFINE_INT_3DIGITS(n,a)                    DeeIntObject n={}
#define Dee_DEFINE_INT_3DIGITS(n,a)                DeeIntObject n={}
#define DEFINE_INT_4DIGITS(n,a)                    DeeIntObject n={}
#define Dee_DEFINE_INT_4DIGITS(n,a)                DeeIntObject n={}
#define DEFINE_INT_5DIGITS(n,a)                    DeeIntObject n={}
#define Dee_DEFINE_INT_5DIGITS(n,a)                DeeIntObject n={}
#define DEFINE_UINT_3DIGITS(n,a)                   DeeIntObject n={}
#define Dee_DEFINE_UINT_3DIGITS(n,a)               DeeIntObject n={}
#define DEFINE_UINT_4DIGITS(n,a)                   DeeIntObject n={}
#define Dee_DEFINE_UINT_4DIGITS(n,a)               DeeIntObject n={}
#define DEFINE_UINT_5DIGITS(n,a)                   DeeIntObject n={}
#define Dee_DEFINE_UINT_5DIGITS(n,a)               DeeIntObject n={}
#define DEFINE_INT15(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT15(n,a)                      DeeIntObject n={}
#define DEFINE_INT16(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT16(n,a)                      DeeIntObject n={}
#define DEFINE_INT30(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT30(n,a)                      DeeIntObject n={}
#define DEFINE_INT32(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT32(n,a)                      DeeIntObject n={}
#define DEFINE_INT45(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT45(n,a)                      DeeIntObject n={}
#define DEFINE_INT48(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT48(n,a)                      DeeIntObject n={}
#define DEFINE_INT60(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT60(n,a)                      DeeIntObject n={}
#define DEFINE_INT64(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT64(n,a)                      DeeIntObject n={}
#define DEFINE_INT75(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT75(n,a)                      DeeIntObject n={}
#define DEFINE_UINT15(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT15(n,a)                     DeeIntObject n={}
#define DEFINE_UINT16(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT16(n,a)                     DeeIntObject n={}
#define DEFINE_UINT30(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT30(n,a)                     DeeIntObject n={}
#define DEFINE_UINT32(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT32(n,a)                     DeeIntObject n={}
#define DEFINE_UINT45(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT45(n,a)                     DeeIntObject n={}
#define DEFINE_UINT48(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT48(n,a)                     DeeIntObject n={}
#define DEFINE_UINT60(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT60(n,a)                     DeeIntObject n={}
#define DEFINE_UINT64(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT64(n,a)                     DeeIntObject n={}
#define DEFINE_UINT75(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT75(n,a)                     DeeIntObject n={}
#define DEFINE_INT90(n,a)                          DeeIntObject n={}
#define Dee_DEFINE_INT90(n,a)                      DeeIntObject n={}
#define DEFINE_UINT90(n,a)                         DeeIntObject n={}
#define Dee_DEFINE_UINT90(n,a)                     DeeIntObject n={}
#define DEFINE_FLOAT(n,a)                          DeeFloatObject n={}
#define Dee_DEFINE_FLOAT(n,a)                      DeeFloatObject n={}


#define _DeeSystem_DEFINE_memccpyT(rT,T,Tneedle,n) rT*n(void*restrict dst,void const*restrict src,Tneedle needle,size_t num_bytes){}
#define _DeeSystem_DEFINE_memchrT(rT,T,Tneedle,n) rT*n(void const*restrict p,Tneedle c,size_t n){}
#define _DeeSystem_DEFINE_memrchrT(rT,T,Tneedle,n) rT*n(void const*restrict p,Tneedle c,size_t n){}
#define _DeeSystem_DEFINE_memcmpT(T,n) int n(void const*s1,void const*s2,size_t n){}
#define _DeeSystem_DEFINE_strcmpT(T,unsignedT,n) int n(T const*s1,T const*s2){}
#define _DeeSystem_DEFINE_strncmpT(T,unsignedT,n) int n(T const*s1,T const*s2,size_t maxlen){}
#define _DeeSystem_DEFINE_strcasecmpT(T,unsignedT,n) int n(T const*s1,T const*s2){}
#define _DeeSystem_DEFINE_strncasecmpT(T,unsignedT,n) int n(T const*s1,T const*s2,size_t maxlen){}
#define _DeeSystem_DEFINE_stpncpyT(T,n,strnlen) T*n(T*buf,T const*src,size_t buflen){}
#define _DeeSystem_DEFINE_strncpyT(T,n,strnlen) T*n(T*buf,T const*src,size_t buflen){}
#define DeeSystem_DEFINE_memccpy(n) _DeeSystem_DEFINE_memccpyT(void,uint8_t,int,n)
#define DeeSystem_DEFINE_memrchr(n) _DeeSystem_DEFINE_memrchrT(void,uint8_t,int,n)
#define DeeSystem_DEFINE_memrchrw(n) _DeeSystem_DEFINE_memrchrT(uint16_t,uint16_t,uint16_t,n)
#define DeeSystem_DEFINE_memrchrl(n) _DeeSystem_DEFINE_memrchrT(uint32_t,uint32_t,uint32_t,n)
#define DeeSystem_DEFINE_memrchrq(n) _DeeSystem_DEFINE_memrchrT(uint64_t,uint64_t,uint64_t,n)
#define DeeSystem_DEFINE_memchrw(n) _DeeSystem_DEFINE_memchrT(uint16_t,uint16_t,uint16_t,n)
#define DeeSystem_DEFINE_memchrl(n) _DeeSystem_DEFINE_memchrT(uint32_t,uint32_t,uint32_t,n)
#define DeeSystem_DEFINE_memchrq(n) _DeeSystem_DEFINE_memchrT(uint64_t,uint64_t,uint64_t,n)
#define DeeSystem_DEFINE_wmemchr(n) _DeeSystem_DEFINE_memchrT(Dee_wchar_t,Dee_wchar_t,wint_t,n)
#define DeeSystem_DEFINE_memcmpw(n) _DeeSystem_DEFINE_memcmpT(uint16_t,n)
#define DeeSystem_DEFINE_memcmpl(n) _DeeSystem_DEFINE_memcmpT(uint32_t,n)
#define DeeSystem_DEFINE_memcmpq(n) _DeeSystem_DEFINE_memcmpT(uint64_t,n)
#define DeeSystem_DEFINE_strcmp(n) _DeeSystem_DEFINE_strcmpT(char,unsigned char,n)
#define DeeSystem_DEFINE_strncmp(n) _DeeSystem_DEFINE_strncmpT(char,unsigned char,n)
#define DeeSystem_DEFINE_strcasecmp(n) _DeeSystem_DEFINE_strcasecmpT(char,unsigned char,n)
#define DeeSystem_DEFINE_strncasecmp(n) _DeeSystem_DEFINE_strncasecmpT(char,unsigned char,n)
#define DeeSystem_DEFINE_stpncpy(n) _DeeSystem_DEFINE_stpncpyT(char,n,strnlen)
#define DeeSystem_DEFINE_strncpy(n) _DeeSystem_DEFINE_strncpyT(char,n,strnlen)
#define _DeeSystem_DEFINE_memmemT(rT,T,memchr,memeq,n) rT*n(void const*restrict haystack,size_t haystack_length,void const*restrict needle,size_t needle_length){}
#define _DeeSystem_DEFINE_memrmemT(rT,T,memrchr,memeq,n) rT*n(void const*restrict haystack,size_t haystack_length,void const*restrict needle,size_t needle_length){}
#define DeeSystem_DEFINE_memmem(n) _DeeSystem_DEFINE_memmemT(void,uint8_t,memchr,,n)
#define DeeSystem_DEFINE_memmemw(n,memchrw,memeqw) _DeeSystem_DEFINE_memmemT(uint16_t,uint16_t,memchrw,memeqw,n)
#define DeeSystem_DEFINE_memmeml(n,memchrl,memeql) _DeeSystem_DEFINE_memmemT(uint32_t,uint32_t,memchrl,memeql,n)
#define DeeSystem_DEFINE_memmemq(n,memchrq,memeqq) _DeeSystem_DEFINE_memmemT(uint64_t,uint64_t,memchrq,memeqq,n)
#define DeeSystem_DEFINE_memrmem(n) _DeeSystem_DEFINE_memrmemT(void,uint8_t,memrchr,,n)
#define DeeSystem_DEFINE_memrmemw(n,memrchrw,memeqw) _DeeSystem_DEFINE_memrmemT(uint16_t,uint16_t,memrchrw,memeqw,n)
#define DeeSystem_DEFINE_memrmeml(n,memrchrl,memeql) _DeeSystem_DEFINE_memrmemT(uint32_t,uint32_t,memrchrl,memeql,n)
#define DeeSystem_DEFINE_memrmemq(n,memrchrq,memeqq) _DeeSystem_DEFINE_memrmemT(uint64_t,uint64_t,memrchrq,memeqq,n)
#define DeeSystem_DEFINE_strnlen(n) size_t n(char const*restrict str,size_t maxlen){}
#define _DeeSystem_DEFINE_strlenT(T,n) size_t n(T const*restrict str){}
#define DeeSystem_DEFINE_wcslen(n) _DeeSystem_DEFINE_strlenT(Dee_wchar_t,n)
#define _DeeSystem_DEFINE_strcmpzT(T,Tu,Tr,n) Tr n(T const*lhs,T const*rhs,size_t rhs_len){}
#define DeeSystem_DEFINE_strcmpz(n) _DeeSystem_DEFINE_strcmpzT(char,unsigned char,int,n)
#define DeeSystem_DEFINE_rawmemchr(n) void*n(void const*restrict p,int c){}
#define DeeSystem_DEFINE_rawmemrchr(n) void*n(void const*restrict p,int c){}
#define DeeSystem_DEFINE_memend(n) void*n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_memxend(n) void*n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_memrend(n) void*n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_memlen(n) size_t n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_memxlen(n) size_t n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_memrlen(n) size_t n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_rawmemlen(n) size_t n(void const*p,int byte){}
#define DeeSystem_DEFINE_rawmemrlen(n) size_t n(void const*p,int byte){}
#define DeeSystem_DEFINE_memxchr(n) void*n(void const*restrict p,int c,size_t n){}
#define DeeSystem_DEFINE_rawmemxchr(n) void*n(void const*restrict p,int c){}
#define DeeSystem_DEFINE_rawmemxlen(n) size_t n(void const*p,int byte){}
#define DeeSystem_DEFINE_memcasecmp(n) int n(void const*a,void const*b,size_t n){}
#define DeeSystem_DEFINE_memcasemem(n) void*n(void const*restrict haystack,size_t haystack_len,void const*restrict needle,size_t needle_len){}
#define DeeSystem_DEFINE_memrev(n) void*n(void*restrict buf,size_t n){}
#define DeeSystem_DEFINE_memxrchr(n) void*n(void const*restrict p,int c,size_t n){}
#define DeeSystem_DEFINE_memxrend(n) void*n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_memxrlen(n) size_t n(void const*p,int byte,size_t num_bytes){}
#define DeeSystem_DEFINE_rawmemxrchr(n) void*n(void const*restrict p,int c){}
#define DeeSystem_DEFINE_rawmemxrlen(n) size_t n(void const*p,int byte){}
#define DeeSystem_DEFINE_memcasermem(n) void*_##n##_memlowerrchr(void const*restrict p,uint8_t c,size_t n){} void*n(void const*restrict haystack,size_t haystack_len,void const*restrict needle,size_t needle_len){}
#define DeeSystem_DEFINE_qsort(n) void _##n##_swapmemory(uint8_t*a,uint8_t*b,size_t num_bytes);void n(void*base,size_t count,size_t size,int (*compare)(void const*a,void const*b)){}
#define _DeeSystem_DEFINE_memsetT(T,n) void*n(void*restrict p,T c,size_t n){}
#define DeeSystem_DEFINE_memsetw(n) _DeeSystem_DEFINE_memsetT(uint16_t,n)
#define DeeSystem_DEFINE_memsetl(n) _DeeSystem_DEFINE_memsetT(uint32_t,n)
#define DeeSystem_DEFINE_memsetq(n) _DeeSystem_DEFINE_memsetT(uint64_t,n)
#define DeeSystem_DEFINE_memsetp(n) _DeeSystem_DEFINE_memsetT(uintptr_t,n)
#define _DeeSystem_DEFINE_mempsetT(T,n) void*n(void*restrict p,T c,size_t n){}
#define DeeSystem_DEFINE_mempsetw(n) _DeeSystem_DEFINE_mempsetT(uint16_t,n)
#define DeeSystem_DEFINE_mempsetl(n) _DeeSystem_DEFINE_mempsetT(uint32_t,n)
#define DeeSystem_DEFINE_mempsetq(n) _DeeSystem_DEFINE_mempsetT(uint64_t,n)
#define DeeSystem_DEFINE_mempsetp(n) _DeeSystem_DEFINE_mempsetT(uintptr_t,n)

#define cache_struct Dee_cache_struct
#define cache_object Dee_cache_object
#define DEFINE_STRUCT_CACHE            DEE_DEFINE_STRUCT_CACHE
#define DEFINE_OBJECT_CACHE            DEE_DEFINE_OBJECT_CACHE
#define DECLARE_STRUCT_CACHE           DEE_DECLARE_STRUCT_CACHE
#define DECLARE_OBJECT_CACHE           DEE_DECLARE_OBJECT_CACHE
#define DEFINE_STRUCT_CACHE_TRYALLOC   DEE_DEFINE_STRUCT_CACHE_TRYALLOC
#define DEFINE_STRUCT_CACHE_EX         DEE_DEFINE_STRUCT_CACHE_EX
#define DEFINE_OBJECT_CACHE_EX         DEE_DEFINE_OBJECT_CACHE_EX
#define DEE_DEFINE_STRUCT_CACHE(n,T,l) DEE_DEFINE_STRUCT_CACHE_EX(n,T,,)
#define DEE_DEFINE_OBJECT_CACHE(n,T,l) DEE_DEFINE_OBJECT_CACHE_EX(n,T,,)
#define DEE_DECLARE_STRUCT_CACHE(n,T) \
	struct Dee_cache_struct*structcache_##n##_list;\
	size_t structcache_##n##_size;\
	size_t n##_clear(size_t max_clear);\
	void n##_free(T*ob);\
	T*n##_alloc(void);\
	T*n##_dbgalloc(char const*file,int line);
#define DEE_DECLARE_OBJECT_CACHE(n,T) \
	struct Dee_cache_object*obcache_##n##_list;\
	size_t obcache_##n##_size;\
	size_t n##_clear(size_t max_clear);\
	void n##_free(T*ob);\
	T*n##_alloc(void);\
	T*n##_dbgalloc(char const*file,int line);\
	void n##_tp_free(void*ob);\
	void*n##_tp_alloc(void);
#define DEE_DEFINE_STRUCT_CACHE_EX(n,T,s,l) \
	struct Dee_cache_struct*structcache_##n##_list=0;\
	size_t structcache_##n##_size=0;\
	size_t n##_clear(size_t max_clear){}\
	void n##_free(T*ob){}\
	T*DCALL n##_alloc(){}\
	T*DCALL n##_dbgalloc(char const*file,int line){}
#define DEE_DEFINE_OBJECT_CACHE_EX(n,T,s,l) \
	struct Dee_cache_object*obcache_##n##_list=0;\
	size_t obcache_##n##_size=0;\
	size_t n##_clear(size_t max_clear){}\
	void n##_free(T*ob){}\
	T*n##_alloc(){}\
	T*n##_dbgalloc(char const*file,int line){}\
	void n##_tp_free(void*ob){}\
	void*n##_tp_alloc(){}

#define DECLARE_DeeTime_NewUnix() DeeObject*DeeTime_NewUnix(int64_t seconds_since_01_01_1970,uint32_t extra_nanoseconds)
#define DEFINE_DeeTime_NewUnix(get_time_module) DeeObject*DeeTime_NewUnix(int64_t seconds_since_01_01_1970,uint32_t extra_nanoseconds){}
#define DECLARE_DeeTime_NewFILETIME() DeeObject*DeeTime_NewFILETIME(void const*p_filetime)
#define DEFINE_DeeTime_NewFILETIME(get_time_module) DeeObject*DeeTime_NewFILETIME(void const*p_filetime){}



#define appexit_object                 Dee_appexit_object
#define ascii_printer                  Dee_ascii_printer
#define attribute_info                 Dee_attribute_info
#define attribute_lookup_rules         Dee_attribute_lookup_rules
#define attribute_object               Dee_attribute_object
#define bool_object                    Dee_bool_object
#define bytes_object                   Dee_bytes_object
#define bytes_printer                  Dee_bytes_printer
#define cell_object                    Dee_cell_object
#define charptr                        Dee_dcharptr
#define class_attribute                Dee_class_attribute
#define class_desc                     Dee_class_desc
#define class_descriptor_object        Dee_class_descriptor_object
#define class_operator                 Dee_class_operator
#define class_optable                  Dee_class_optable
#define clsmember_object               Dee_clsmember_object
#define clsmethod_object               Dee_clsmethod_object
#define clsproperty_object             Dee_clsproperty_object
#define clsproperty_origin             Dee_clsproperty_origin
#define cmethod_object                 Dee_cmethod_object
#define cmethod_origin                 Dee_cmethod_origin
#define code_frame                     Dee_code_frame
#define code_object                    Dee_code_object
#define compiler_error_loc             Dee_compiler_error_loc
#define compiler_error_object          Dee_compiler_error_object
#define compiler_items                 Dee_compiler_items
#define compiler_object                Dee_compiler_object
#define compiler_options               Dee_compiler_options
#define ddi_exdat                      Dee_ddi_exdat
#define ddi_object                     Dee_ddi_object
#define ddi_regs                       Dee_ddi_regs
#define ddi_saved                      Dee_ddi_saved
#define ddi_state                      Dee_ddi_state
#define ddi_xregs                      Dee_ddi_xregs
#define deep_assoc                     Dee_deep_assoc
#define deep_assoc_entry               Dee_deep_assoc_entry
#define dex                            Dee_dex
#define dex_notification               Dee_dex_notification
#define dex_object                     Dee_dex_object
#define dex_symbol                     Dee_dex_symbol
#define dict_item                      Dee_dict_item
#define dict_object                    Dee_dict_object
#define enumattr_iterator_object       Dee_enumattr_iterator_object
#define enumattr_object                Dee_enumattr_object
#define error_object                   Dee_error_object
#define except_frame                   Dee_except_frame
#define except_handler                 Dee_except_handler
#define file_buffer_link               Dee_file_buffer_link
#define file_buffer_object             Dee_file_buffer_object
#define file_object                    Dee_file_object
#define file_reader_object             Dee_file_reader_object
#define file_writer_object             Dee_file_writer_object
#define filetype_object                Dee_filetype_object
#define float_object                   Dee_float_object
#define function_object                Dee_function_object
#define gc_head                        Dee_gc_head
#define gc_head_link                   Dee_gc_head_link
#define hashset_item                   Dee_hashset_item
#define hashset_object                 Dee_hashset_object
#define instance_desc                  Dee_instance_desc
#define instance_method                Dee_instance_method
#define instancemember_object          Dee_instancemember_object
#define int_object                     Dee_int_object
#define kwclsmethod_object             Dee_kwclsmethod_object
#define kwcmethod_object               Dee_kwcmethod_object
#define kwobjmethod_object             Dee_kwobjmethod_object
#define list_object                    Dee_list_object
#define memory_file_object             Dee_memory_file_object
#define module_object                  Dee_module_object
#define module_path_object             Dee_module_path_object
#define module_symbol                  Dee_module_symbol
#define nomemory_error_object          Dee_nomemory_error_object
#define none_object                    Dee_none_object
#define object                         Dee_object_
#define objmethod_object               Dee_objmethod_object
#define objmethod_origin               Dee_objmethod_origin
#define opinfo                         Dee_opinfo
#define property_object                Dee_property_object
#define regex_range                    Dee_regex_range
#define regex_range_ex                 Dee_regex_range_ex
#define regex_range_ptr                Dee_regex_range_ptr
#define repr_frame                     Dee_repr_frame
#define rodict_item                    Dee_rodict_item
#define rodict_object                  Dee_rodict_object
#define roset_item                     Dee_roset_item
#define roset_object                   Dee_roset_object
#define string_object                  Dee_string_object
#define string_utf                     Dee_string_utf
#define super_object                   Dee_super_object
#define system_error_object            Dee_system_error_object
#define system_file_object             Dee_system_file_object
#define thread_interrupt               Dee_thread_interrupt
#define thread_object                  Dee_thread_object
#define threadexit_object              Dee_threadexit_object
#define tls_callback_hooks             Dee_tls_callback_hooks
#define traceback_object               Dee_traceback_object
#define trepr_frame                    Dee_trepr_frame
#define tuple_object                   Dee_tuple_object
#define type_attr                      Dee_type_attr
#define type_buffer                    Dee_type_buffer
#define type_cast                      Dee_type_cast
#define type_cmp                       Dee_type_cmp
#define type_constructor               Dee_type_constructor
#define type_gc                        Dee_type_gc
#define type_getset                    Dee_type_getset
#define type_math                      Dee_type_math
#define type_member                    Dee_type_member
#define type_method                    Dee_type_method
#define type_nii                       Dee_type_nii
#define type_object                    Dee_type_object
#define type_operator                  Dee_type_operator
#define type_seq                       Dee_type_seq
#define type_with                      Dee_type_with
#define unicode_printer                Dee_unicode_printer
#define unitraits                      Dee_unitraits
#define weakref                        Dee_weakref
#define weakref_list                   Dee_weakref_list
#define weakref_object                 Dee_weakref_object
#define weakrefable_object             Dee_weakrefable_object
#define yield_function_iterator_object Dee_yield_function_iterator_object
#define yield_function_object          Dee_yield_function_object
#define keyword                        Dee_keyword
#define kwds_entry                     dee_kwds_entry
#define kwds_mapping_object            dee_kwds_mapping_object
#define kwds_object                    dee_kwds_object



// Misc. local macros
#define DEFINE_OPERATOR_INVOKE(name,...)struct Dee_operator_invoke name={};DeeObject *invoke_##name(DeeTypeObject*tp_self,DeeObject*self,DeeObject**p_self,size_t argc,DeeObject*const*argv)
#define DEFINE_STRING_TRAIT(n,...) DeeObject*string_##n(String*self,size_t argc,DeeObject*const*argv);
#define DEFINE_ANY_STRING_TRAIT(n,...) DeeObject*string_##n(String*self,size_t argc,DeeObject*const*argv,DeeObject*kw);
#define DEFINE_BYTES_TRAIT(n,...) DeeObject*bytes_##n(Bytes*self,size_t argc,DeeObject*const*argv);
#define DEFINE_ANY_BYTES_TRAIT(n,...) DeeObject*bytes_##n(Bytes*self,size_t argc,DeeObject*const*argv,DeeObject*kw);
#define SUPER_PRIVATE_EXPANDARGS(...) (DeeTypeObject *tp_self, __VA_ARGS__)
#define DEFINE_OPERATOR(return,n,args) return DeeObject_T##n SUPER_PRIVATE_EXPANDARGS args{} return DeeObject_##n args
#define DEFINE_INTERNAL_OPERATOR(return,n,args) return DeeObject_T##n SUPER_PRIVATE_EXPANDARGS args{} return DeeObject_##n args
#define DEFINE_INTERNAL_SEQ_OPERATOR(return,n,args) return DeeSeq_T##n SUPER_PRIVATE_EXPANDARGS args{} return DeeSeq_##n args
#define DEFINE_INTERNAL_SET_OPERATOR(return,n,args) return DeeSet_T##n SUPER_PRIVATE_EXPANDARGS args{} return DeeSet_##n args
#define DEFINE_INTERNAL_MAP_OPERATOR(return,n,args) return DeeMap_T##n SUPER_PRIVATE_EXPANDARGS args{} return DeeMap_##n args
#define DEFINE_DEFAULT_FOO_WITH_INPLACE_FOO_OPERATOR(x,...) DEFINE_INTERNAL_OPERATOR(DeeObject*,Default##x##WithInplace##x,(DeeObject*self,DeeObject*other)){}
#define DEFINE_DEFAULT_INPLACE_FOO_WITH_FOO_OPERATOR(x,...) DEFINE_INTERNAL_OPERATOR(DeeObject*,DefaultInplace##x##With##x,(DeeObject*self,DeeObject*other)){}
#define DEFINE_FILE_OPERATOR(return,n,args) return DeeFile_T##n SUPER_PRIVATE_EXPANDARGS args{} return DeeFile_##n args
#define DEFINE_MATH_INPLACE_INT_OPERATOR(n,a,b,c,...) int n(DeeObject**restrict p_self,c val){}
#define DEF_STRING(n,a,b,c) DeeStringObject n={};
#define RESTRICT_IF_NOTYPE
#define ACTION(...)
#define CONSTEXPR_FRAME_BEGIN(...) if(0)
#define FUNC(...) __VA_ARGS__
#define IF_EVAL(...) __VA_ARGS__
#define IF_SKIP(...)
#define IFELSE(a,b) a
#define RETURN_TYPE int
#define TPPCALL
#define TRY
#define EXCEPT
#define CASE(x) case x
#define TARGET(...)
#define XTARGET(...)
#define RAW_TARGET(...)
#define PREFIX_TARGET(...)
#define F(x) x
#define CC
#define VCC
#define PRIVATE_AST_GENERATOR_UNPACK_ARGS(...) (__VA_ARGS__,char const*file,int line)
#define DEFINE_AST_GENERATOR(attr,n,args) struct ast*n##_d PRIVATE_AST_GENERATOR_UNPACK_ARGS args{}struct ast*n args
#define DECLARE_AST_GENERATOR(attr,n,args) struct ast*n##_d PRIVATE_AST_GENERATOR_UNPACK_ARGS args;struct ast*n args
#define DEE_CXX_PRIVATE_DEFINE_OBJECT_WRAPPER(n) template<class T= ::DeeObject>class n {public:operator T*()const{}explicit n(DeeObject*ptr){}n(n const&ptr){}};
#define DEE_ENABLE_IF_OBJECT(S) S
#define DEE_ENABLE_IF_OBJECT_T(S,T) T
#define DEE_ENABLE_IF_OBJECT_AND_PTR_T(Sob,Sptr,T) T
#define DEE_ENABLE_IF_OBJECT_PTR_T(S,T) T
#define DEE_ENABLE_IF_OBJECT_PTR2_T(S1,S2,T) T
#define DEE_ENABLE_IF_OBJECT_PTR3_T(S1,S2,S3,T) T
#define DEE_ENABLE_IF_OBJECT_PTR4_T(S1,S2,S3,S4,T) T
#define DEE_ENABLE_IF_OBJECT_PTR5_T(S1,S2,S3,S4,S5,T) T
#define DEE_ENABLE_IF_OBJECT_PTR6_T(S1,S2,S3,S4,S5,S6,T) T
#define DEE_ENABLE_IF_OBJECT_ASSIGNABLE(To,From) To
#define DEE_ENABLE_IF_OBJECT_ASSIGNABLE_T(To,From,T) T
#define DEE_ENABLE_IF_OBJECT_ASSIGNABLE2(To,From1,From2) To
#define DEC_FOREACH_SECTION_VARS
#define DEC_FOREACH_SECTION(s) for(;;)
#define DEFINE_SIMPLE_SUFFIX_PARSER_FUNCTION(n,func,IF_SUFFIX,is_suffix) DeeObject*parser_##n(DeeCompilerWrapperObject*self,size_t argc,DeeObject*const*argv,DeeObject*kw){}
#define DEFINE_SIMPLE_LOOKUPMODE_PARSER_FUNCTION(n,func) DeeObject*parser_##n(DeeCompilerWrapperObject*self,size_t argc,DeeObject*const*argv,DeeObject*kw){}
#define DEFINE_KEYWORD_FLAG_FUNCTIONS(n,flag) \
	DeeObject*keyword_get_##n(DeeCompilerItemObject*self){}\
	int keyword_del_##n(DeeCompilerItemObject*self){}\
	int keyword_set_##n(DeeCompilerItemObject*self,DeeObject*value){}
#define DEFINE_LEXER_FLAG_FUNCTIONS(n,flag) \
	DeeObject*lexer_get_##n(DeeCompilerWrapperObject*self){}\
	int lexer_del_##n(DeeCompilerWrapperObject*self){}\
	int lexer_set_##n(DeeCompilerWrapperObject*self,DeeObject*value){}
#define STACK_ALLOCATOR_DECL
#define CONFIG_DEEMON_PATH(x)
#define SEQ_EACH_HEAD OBJECT_HEAD DeeObject*se_seq;
#define PROXY_OBJECT_HEAD_EX(T,o) OBJECT_HEAD T*o;
#define PROXY_OBJECT_HEAD2_EX(T,o,S,p) OBJECT_HEAD T*o;S*p;
#define PROXY_OBJECT_HEAD3_EX(T,o,S,p,U,q) OBJECT_HEAD T*o;S*p;U*q;
#define PROXY_OBJECT_HEAD(o) OBJECT_HEAD DeeObject*o;
#define PROXY_OBJECT_HEAD2(o,p) OBJECT_HEAD DeeObject*o,*p;
#define PROXY_OBJECT_HEAD3(o,p,q) OBJECT_HEAD DeeObject*o,*p,*q;
#define DEFINE_SEQ_EACH_UNARY(n,...) SeqEachOperator*n(SeqEachBase*self){}
#define DEFINE_SEQ_EACH_BINARY(n,...) SeqEachOperator*n(SeqEachBase*self,DeeObject*other){}
#define DEFINE_SEQ_EACH_TRINARY(n,...) SeqEachOperator*n(SeqEachBase*self,DeeObject*a,DeeObject*b){}
#define DEFINE_SEQ_EACH_UNARY_INPLACE(n,...) int n(SeqEachBase**p_self){}
#define DEFINE_SEQ_EACH_BINARY_INPLACE(n,...) int n(SeqEachBase**p_self,DeeObject*other){}
#define DEFINE_SEW_UNARY(n,...) SeqEachOperator*n(DeeObject*self){}
#define DEFINE_SEW_BINARY(n,...) SeqEachOperator*n(DeeObject*self,DeeObject*other){}
#define DEFINE_SEW_TRINARY(n,...) SeqEachOperator*n(DeeObject*self,DeeObject*a,DeeObject*b){}
#define DEFINE_SEO_UNARY_INPLACE(n,...) int n(SeqEachOperator**p_self){}
#define DEFINE_SEO_BINARY_INPLACE(n,...) int n(SeqEachOperator**p_self,DeeObject*other){}
#define DEFINE_FOLD_COMPARE(n,T) size_t n(T const*data,size_t datalen,uint32_t fold[UNICODE_FOLDED_MAX],size_t fold_len);
#define DEFINE_MEMCASECHR(n,rname,T,dee_foldcmp) \
	T*n(T const*haystack,T needle,size_t haystack_length){}\
	T*rname(T const*haystack,T needle,size_t haystack_length){}
#define DEFINE_UNICODE_ISOLDREADER_API(n,T)\
	struct n {\
		T const*uf_dataptr;\
		size_t uf_datalen;\
		uint32_t uf_buf[UNICODE_FOLDED_MAX];\
		uint8_t uf_len;\
		uint8_t uf_idx;\
	};\
	uint32_t n##_getc(struct n*self){}\
	uint32_t n##_getc_back(struct n*self){}
#define DEFINE_MEMCASEEQ(n,T) bool n(T const*a,size_t a_size,T const*b,size_t b_size){}
#define DEFINE_MEMCASESTARTSWITH(n,T) size_t n(T const*a,size_t a_size,T const*b,size_t b_size){}
#define DEFINE_MEMCASEENDSWITH(n,T) size_t n(T const*a,size_t a_size,T const*b,size_t b_size){}
#define DEFINE_MEMCASEMEM(n,rname,T,...) \
	T*n(T const*haystack,size_t haystack_length,T const*needle,size_t needle_length,size_t*p_match_length){}\
	T*rname(T const*haystack,size_t haystack_length,T const*needle,size_t needle_length,size_t*p_match_length){}
#define DEFINE_FUZZY_COMPARE_FUNCTION(n,T,...) dssize_t n(T const*a,size_t alen,T const*b,size_t blen){}
#define DEFINE_FUZZY_FOLDCOMPARE_FUNCTION(n,T) dssize_t n(T const*a,size_t alen,T const*b,size_t blen){}
#define DEFINE_VERSION_COMPARE_FUNCTION(n,T,Ts,...) Ts n(T*a,size_t a_size,T*b,size_t b_size){}
#define DEFINE_FIND_MATCH_FUNCTION(n,T,...) T*n(T*scan_str,size_t scan_size,T*open_str,size_t open_size,T*clos_str,size_t clos_size){}
#define DEFINE_CASEFIND_MATCH_FUNCTION(n,T,...) T*n(T*scan_str,size_t scan_size,T*open_str,size_t open_size,T*clos_str,size_t clos_size,size_t*p_match_length){}
#define DEFINE_RFIND_MATCH_FUNCTION(n,T,...) T*n(T*scan_str,size_tscan_size,T*open_str,size_topen_size,T*clos_str,size_tclos_size){}
#define DEFINE_CASERFIND_MATCH_FUNCTION(n,T,...) T*n(T*scan_str,size_t scan_size,T*open_str,size_t open_size,T*clos_str,size_t clos_size,size_t*p_match_length){}
#define SWITCH_BUILTIN_CODECS(n,...) {}
#define DEFINE_DEPRECATED_INPLACE_BINARY(n,...) DeeObject*object_##n(DeeObject*self,size_t argc,DeeObject*const*argv){}
#define DEFINE_NUMERIC_ISCMP(n,...) DeeObject*numeric_##n(DeeObject*self,size_t argc,DeeObject*const*argv){}
#define DEFINE_INT_COMPARE_FUNCTION(n,...) DeeObject*int_##n(DeeIntObject*self,size_t argc,DeeObject*const*argv){}
#define DEFINE_FLOAT_COMPARE(n,...) DeeObject*n(Float*self,DeeObject*other){}
#define DEFINE_FLOAT_COMPARE_FUNCTION(n,...) DeeObject*float_##n(Float*self,size_t argc,DeeObject*const*argv){}
#define DEFINE_FILE_CLASS_STD_FUNCTIONS(stdxxx,...) \
	DeeObject*file_class_get_##stdxxx(DeeObject*self){}\
	int file_class_del_##stdxxx(DeeObject*self){}\
	int file_class_set_##stdxxx(DeeObject*self,DeeObject*value){}
#define DEFINE_UNARY_INSTANCE_WRAPPER_FUNCTION(instance_txxx,instance_xxx,...) \
	DeeObject*instance_txxx(DeeTypeObject*tp_self,DeeObject*self){}\
	DeeObject*instance_xxx(DeeObject*self){}
#define DEFINE_BINARY_INSTANCE_WRAPPER_FUNCTION(instance_txxx,instance_xxx,...) \
	DeeObject*instance_txxx(DeeTypeObject*tp_self,DeeObject*self,DeeObject*other){}\
	DeeObject*instance_xxx(DeeObject*self,DeeObject*other){}
#define DEFINE_TRINARY_INSTANCE_WRAPPER_FUNCTION(instance_txxx,instance_xxx,...) \
	DeeObject*instance_txxx(DeeTypeObject*tp_self,DeeObject*self,DeeObject*other,DeeObject*other2){}\
	DeeObject*instance_xxx(DeeObject*self,DeeObject*other,DeeObject*other2){}
#define DEFINE_UNARY_INSTANCE_WRAPPER_FUNCTION_INT(instance_txxx,instance_xxx,...) \
	int instance_txxx(DeeTypeObject*tp_self,DeeObject*self){}\
	int instance_xxx(DeeObject*self){}
#define DEFINE_BINARY_INSTANCE_WRAPPER_FUNCTION_INT(instance_txxx,instance_xxx,...) \
	int instance_txxx(DeeTypeObject*tp_self,DeeObject*self,DeeObject*other){}\
	int instance_xxx(DeeObject*self,DeeObject*other){}
#define DEFINE_TRINARY_INSTANCE_WRAPPER_FUNCTION_INT(instance_txxx,instance_xxx,...) \
	int instance_txxx(DeeTypeObject*tp_self,DeeObject*self,DeeObject*other,DeeObject*other2){}\
	int instance_xxx(DeeObject*self,DeeObject*other,DeeObject*other2){}
#define DEFINE_QUADARY_INSTANCE_WRAPPER_FUNCTION_INT(instance_txxx,instance_xxx,...) \
	int instance_txxx(DeeTypeObject*tp_self,DeeObject*self,DeeObject*other,DeeObject*other2,DeeObject*other3){}\
	int instance_xxx(DeeObject*self,DeeObject*other,DeeObject*other2,DeeObject*other3){}
#define DEFINE_UNARY_INPLACE_INSTANCE_WRAPPER_FUNCTION(instance_txxx,instance_xxx,...) \
	int instance_txxx(DeeTypeObject*tp_self,DeeObject**p_self){}\
	int instance_xxx(DeeObject**p_self){}
#define DEFINE_BINARY_INPLACE_INSTANCE_WRAPPER_FUNCTION(instance_txxx,instance_xxx,...) \
	int instance_txxx(DeeTypeObject*tp_self,DeeObject**p_self,DeeObject*other){}\
	int instance_xxx(DeeObject**p_self,DeeObject*other){}
#define DEFINE_BYTES_COMPARE(n,...) DeeObject*n(Bytes*self,DeeObject*other){}
#define DEFINE_SEQITERATOR_COMPARE(n,...) DeeObject*n(SeqIterator*self,SeqIterator*other){}
#define DEFINE_TYPE_INHERIT_FUNCTION(n,...) bool n(DeeTypeObject*self){}
#define DEFINE_TYPE_INHERIT_FUNCTION1(n,...) bool n(DeeTypeObject*self){}
#define DEFINE_MATH_OPERATOR2(n,...) DEFINE_OPERATOR(DeeObject*,n,(DeeObject*self,DeeObject*some_object)){}
#define DEFINE_MATH_INPLACE_OPERATOR2(n,...) DEFINE_OPERATOR(int,n,(DeeObject**p_self,DeeObject*some_object)){}
#define DEFINE_OBJECT_COMPARE_OPERATOR(n,...) DEFINE_OPERATOR(DeeObject*,n,(DeeObject*self,DeeObject*some_object)){}
#define DEFINE_COMPARE_ASBOOL_OPERATOR(n,...) int n(DeeObject*self,DeeObject*some_object){}
#define DEE_DEFINE_BYTEWRITER_PUTX(n,T,x) int n(struct Dee_bytewriter*self,T x){}
#define DEE_DEFINE_ATOMIC_HELPERS(n,T) \
	T _Dee_atomic_xch_no_threads_##n(T*p,T value){}\
	T _Dee_atomic_fetchand_no_threads_##n(T*p,T value){}\
	T _Dee_atomic_fetchor_no_threads_##n(T*p,T value){}\
	T _Dee_atomic_fetchnand_no_threads_##n(T*p,T value){}
#define DEFINE_RBTREE_NODE_FIELD_GETTER(rbtreeiter_get_FOO,...) DeeObject*rbtreeiter_get_FOO(RBTreeIterator*self){}
#define DEFINE_RBTREE_NODE_SUBNODE_GETTER(rbtreeiter_get_FOO,...) DeeObject*rbtreeiter_get_FOO(RBTreeIterator*self){}
#define DEFINE_CTYPES_FLOAT_COMPARE(n,...) DeeObject*n(DeeSTypeObject*tp_self,T*self,DeeObject*some_object){}
#define DEFINE_UNARY_STRUCT_OPERATOR(Treturn,struct_xxx,...) Treturn struct_xxx(DeeObject*self){}
#define DEFINE_BINARY_STRUCT_OPERATOR(Treturn,struct_xxx,...) Treturn struct_xxx(DeeObject*self,DeeObject*other){}
#define DEFINE_TRINARY_STRUCT_OPERATOR(Treturn,struct_xxx,...) Treturn struct_xxx(DeeObject*self,DeeObject*a,DeeObject*b){}
#define DEFINE_UNARY_INPLACE_STRUCT_OPERATOR(Treturn,struct_xxx,...) Treturn struct_xxx(DeeObject**p_self){}
#define DEFINE_BINARY_INPLACE_STRUCT_OPERATOR(Treturn,struct_xxx,...) Treturn struct_xxx(DeeObject**p_self,DeeObject*other){}
#define DEFINE_UNARY_MATH_OPERATOR(Treturn,error_result,DeeStruct_Xxx,...) Treturn DeeStruct_Xxx(DeeSTypeObject*tp_self,void*self){}
#define DEFINE_BINARY_MATH_OPERATOR(Treturn,error_result,DeeStruct_Xxx,...) Treturn DeeStruct_Xxx(DeeSTypeObject*tp_self,void*self,DeeObject*other){}
#define DHASHALGO_MEMBERS(T) \
	struct dhashalgo ha_base;\
	T ha_start;\
	T ha_outmod;\
	T ha_table[256];
#define DEFINE_LIBMATH_CONVERSION_1(n) DeeObject*f_math_##n(size_t argc,DeeObject*const*argv){}DEFINE_CMETHOD(math_##n,&f_math_##n,0);
#define DEFINE_LIBMATH_CONVERSION_1_E(n) DeeObject*f_math_##n(size_t argc,DeeObject*const*argv){}DEFINE_CMETHOD(math_##n,&f_math_##n,0);
#define DEFINE_LIBMATH_CONVERSION_2(n) DeeObject*f_math_##n(size_t argc,DeeObject*const*argv){}DEFINE_CMETHOD(math_##n,&f_math_##n,0);
#define DEFINE_LIBMATH_CONVERSION_2_E(n) DeeObject*f_math_##n(size_t argc,DeeObject*const*argv){}DEFINE_CMETHOD(math_##n,&f_math_##n,0);
#define DEFINE_LIBMATH_FLOAT_TRAIT(n)  DeeObject*f_math_##n(size_t argc,DeeObject*const*argv){}DEFINE_CMETHOD(math_##n,&f_math_##n,0);
#define DEFINE_LIBMATH_FLOAT_TRAIT2(n) DeeObject*f_math_##n(size_t argc,DeeObject*const*argv){}DEFINE_CMETHOD(math_##n,&f_math_##n,0);
#define DEFINE_SLABINFO_FIELD_READER(n) DeeObject*si_get_##n(SlabInfoObject*self){}
#define DEFINE_LIBTIME_AS(n, ...) \
	DeeObject*time_getval_##n(DeeTimeObject*self){}\
	int time_setval_##n(DeeTimeObject*self,DeeObject*value){}\
	int time_delval_##n(DeeTimeObject*self){}

#define DEFINE_CCALL_OPTIMIZATION(name,...) int name(struct fungen*self,vstackaddr_t argc){}
#define DEFINE_CCALL_OPERATOR(name,...) int name(struct fungen*self,vstackaddr_t argc){}

#define DEFINE_FILETYPE_INHERIT_HOOK(x,...) bool x(DeeFileTypeObject*self,DeeTypeObject*type_type,struct Dee_opinfo const*info){}
#define DEFINE_TYPE_INHERIT_HOOK(x,...) bool x(DeeTypeObject*self,DeeTypeObject*type_type,struct Dee_opinfo const*info){}

#define memstate_foreach(...) for(;;)
#define memstate_foreach_end
#define _memval_foreach_obj(...) for(;;)
#define memval_foreach_obj(...) for(;;)
#define memval_foreach_obj_end

#define LOCAL_seq_compare__(x) seq_compare__##x
#define LOCAL_seq_docompare__(x) seq_docompare__##x
#define LOCAL_NONNULL
#define LOCAL_MAYBE_PUBLIC