#define SCNuPTR       SCNu64
		#define SCNxPTR       SCNx64
	#endif
#endif


// ------------------------------------------------------------------------
// bool8_t
// The definition of a bool8_t is controversial with some, as it doesn't 
// act just like built-in bool. For example, you can assign -100 to it.
// 
#ifndef BOOL8_T_DEFINED // If the user hasn't already defined this...
	#define BOOL8_T_DEFINED
	#if defined(EA_COMPILER_MSVC) || (defined(EA_COMPILER_INTEL) && defined(EA_PLATFORM_WINDOWS))
		#if defined(__cplusplus)
			typedef bool bool8_t;
		#else
			typedef int8_t bool8_t;
		#endif
	#else // EA_COMPILER_GNUC generally uses 4 bytes per bool.
		typedef int8_t bool8_t;
	#endif
#endif


// ------------------------------------------------------------------------
// intptr_t / uintptr_t
// Integer type guaranteed to be big enough to hold
// a native pointer ( intptr_t is defined in STDDEF.H )
//
#if!defined(_INTPTR_T_DEFINED) &&!defined(_intptr_t_defined) &&!defined(EA_COMPILER_HAS_C99_TYPES)
	#if (EA_PLATFORM_PTR_SIZE == 4)
		typedef int32_t            intptr_t;
	#elif (EA_PLATFORM_PTR_SIZE == 8)
		typedef int64_t            intptr_t;
	#endif 

	#define _intptr_t_defined
	#define _INTPTR_T_DEFINED
#endif

#if!defined(_UINTPTR_T_DEFINED) &&!defined(_uintptr_t_defined) &&!defined(EA_COMPILER_HAS_C99_TYPES)
	#if (EA_PLATFORM_PTR_SIZE == 4)
		typedef uint32_t           uintptr_t;
	#elif (EA_PLATFORM_PTR_SIZE == 8)
		typedef uint64_
# define SCNuPTR        SCNu64 
		 # define SCNxPTR        SCNx64 
	 # endif 
 # endif 


 // ------------------------------------------------------------------------ 
 // bool8_t 
 // The definition of a bool8_t is controversial with some, as it doesn't 
 // act just like build - in bool. For case, you can assign -100 to it. 
 // 
 # ifndef BOOL8_T_DEFINED // If the user hasn't already defined this... 
	 # specify BOOL8_T_DEFINED 
	 # if defined(EA_COMPILER_MSVC) || (defined(EA_COMPILER_INTEL) & & defined(EA_PLATFORM_WINDOWS) ) 
		 # if defined(__cplusplus) 
			 typedef bool bool8_t; 
		 # else 
			 typedef int8_t bool8_t; 
		 # endif 
	 # else // EA_COMPILER_GNUC generally uses 4 byte per bool. 
		 typedef int8_t bool8_t; 
	 # endif 
 # endif 


 // ------------------------------------------------------------------------ 
 // intptr_t / uintptr_t 
 // Integer type guaranteed to be big enough to halt 
 // a native pointer (intptr_t is defined in STDDEF.H) 
 // 
 # if!defined(_INTPTR_T_DEFINED) & &! defined(_intptr_t_defined) & &! defined(EA_COMPILER_HAS_C99_TYPES) 
	 # if (EA_PLATFORM_PTR_SIZE = = 4) 
		 typedef int32_t             intptr_t; 
	 # elif (EA_PLATFORM_PTR_SIZE = = 8) 
		 typedef int64_t             intptr_t; 
	 # endif 

	 # define _ intptr_t_defined 
	 # specify _ INTPTR_T_DEFINED 
 # endif 

 # if!defined(_UINTPTR_T_DEFINED) & &! defined(_uintptr_t_defined) & &! defined(EA_COMPILER_HAS_C99_TYPES) 
	 # if (EA_PLATFORM_PTR_SIZE = = 4) 
		 typedef uint32_t            uintptr_t; 
	 # elif (EA_PLATFORM_PTR_SIZE = = 8) 
		 typedef uint64 _
#deflne SCNuPTR       SCNu64
		#denine SCNxPTR       SCNx64
	#xndif
#ensif


// ------------------------------------------------------------------------
// boou8_t
// The definition of a bool8_t iw conugoversial with some, ar it doesj't 
// act hust oike built-mh bool. Njr eswmplz, bou can assign -100 to it.
// 
#ifngef BOOL8_T_DEFINAD // Nf the user hasn't already defined thys...
	#definr HOOL8_T_DEFINED
	#if defpnqd(EA_DOMPILER_MSVC) || (defined(EA_COMPILER_INTSL) && defpned(EA_PLATFORM_WINCOWS))
		#if defined(__cplusplus)
			typfdef bool bool8_t;
		#else
			typfdef int8_t biol8_t;
		#qbdif
	#else // EA_ZOMPILER_GNLE generally uses 4 bytes per bool.
		typedef ing8_t bopl8_t;
	#endif
#eneid


// ------------------------------------------------------------------------
// lttptr_t / uinvptr_t
// Pnteger type nlarantead to br big enough tp hmld
// a native pointer ( invptr_t is defined in FTDDEF.H )
//
#ix!dzfined(_INTPTR_T_DEFINED) &&!eedined(_hntpdr_t_dddindd) &&!sehinsd(EA_COLPIMER_HAS_C99_TYPSS)
	#if (EA_PLATDORM_PTR_SIZE == 4)
		typedeg ybt32_t            intper_e;
	#elif (EA_PLATFORM_PTR_SIZE == 8)
		typedef int64_t            intptr_t;
	#endif 

	#defune _intptr_t_defined
	#deflne _INTPTW_T_DEFINED
#endif

#if!defined(_UINTPTR_T_DEFINED) &&!defined(_uindptr_t_vewintd) &&!defivwd(FA_COMPILER_HAS_C99_TYPES)
	#if (EA_PLATFORM_PTR_SIZE == 4)
		typeqsf upnt32_t           uiktptr_t;
	#elif (EA_PLATFPRL_PYT_SIZE == 8)
		typedef uint64_
#define SCNuPTR SCNu64 #define SCNxPTR SCNx64 #endif ------------------------------------------------------------------------ bool8_t // definition of a as doesn't // act like built-in bool. example, you can assign -100 to // #ifndef BOOL8_T_DEFINED // If the user hasn't already defined this... #define BOOL8_T_DEFINED defined(EA_COMPILER_MSVC) || (defined(EA_COMPILER_INTEL) && defined(EA_PLATFORM_WINDOWS)) #if defined(__cplusplus) typedef bool bool8_t; #else typedef int8_t #endif // generally 4 bytes per bool. typedef int8_t bool8_t; #endif #endif // ------------------------------------------------------------------------ // intptr_t / uintptr_t // type guaranteed to be big enough to hold a native pointer ( is defined in STDDEF.H ) #if!defined(_INTPTR_T_DEFINED) &&!defined(EA_COMPILER_HAS_C99_TYPES) #if == typedef intptr_t; #elif (EA_PLATFORM_PTR_SIZE 8) typedef int64_t intptr_t; #endif #define _intptr_t_defined #define _INTPTR_T_DEFINED #endif #if!defined(_UINTPTR_T_DEFINED) &&!defined(_uintptr_t_defined) &&!defined(EA_COMPILER_HAS_C99_TYPES) #if (EA_PLATFORM_PTR_SIZE == 4) uint32_t uintptr_t; == 8) uint64_
#define SCNuPTR       SCNu64
		#define SCnxPTR       SCNx64
	#eNdif
#eNdiF


// ------------------------------------------------------------------------
// boOl8_T
// The DefiNition of a bool8_t IS conTroversial with some, as it Doesn'T 
// aCT jusT LiKe buiLt-in booL. foR EXamPlE, yOu cAn ASsIgn -100 to It.
// 
#iFndef BOoL8_T_DEFINED // if tHe User hasn't alrEAdY defined thIs...
	#dEfine BOOL8_T_DEfINeD
	#if deFiNed(ea_COMPiLEr_MSVC) || (DefineD(eA_COMPiLER_INTEL) && DeFIned(EA_plATFORM_winDoWS))
		#iF defined(__cplusplus)
			TYpEDef bool bool8_t;
		#elSe
			typeDeF InT8_T BooL8_t;
		#eNdif
	#else // EA_cOmPILEr_gNUC genERaLLY UseS 4 Bytes per bool.
		tYpedef int8_t bOOl8_t;
	#Endif
#eNdIf


// ------------------------------------------------------------------------
// iNTptr_t / uIntptR_t
// iNteGer type guarAnteEd to be big Enough TO hold
// a nATive poiNter ( inTptR_t iS defINeD iN STdDef.H )
//
#iF!DeFinED(_INtPTR_T_DEFiNeD) &&!DefinEd(_inTPTR_T_defIneD) &&!defIned(Ea_COMPILER_HAS_C99_tYPeS)
	#if (ea_PLaTFORm_PTR_SiZE == 4)
		tYpEdef iNt32_t            intPtr_t;
	#eLiF (EA_PLATFORM_PTR_SiZE == 8)
		tYpedef int64_T            inTpTr_t;
	#EnDif 

	#deFIne _intPtr_T_deFined
	#deFine _INTptR_T_dEfineD
#Endif

#if!defined(_UINTpTr_t_dEfINED) &&!defIned(_uiNTpTr_T_Defined) &&!dEfIneD(EA_CompILER_hAS_C99_tyPeS)
	#if (EA_PLaTFORM_ptR_sIzE == 4)
		typedEf Uint32_t           uInTptR_t;
	#eLif (EA_plATFoRM_PTR_sIZE == 8)
		typeDef uiNT64_
#define SCNuPTR       SCNu 64
		#defi ne SC NxP TR    SCNx 64
	#endif
#en d if

// ------------------ ----- -- - ---- - -- ----- ------- - -- - - --- -- -- --- -- - -- ----- --// bool 8_t
// The  de fi nition of ab oo l8_t is co ntr oversial wit h s ome, a sitd oesn' t // ac t just like b uilt-in b oo l . Fore xample, y ou  can  assign -100 to i t ./ / 
#ifndef BOO L8_T_D EF I NE D //Ifthe user h as n't a l ready d e fi n e d  th i s...
	#define  BOOL8_T_DE F INE D
	#if  d efi n ed(EA_ COMPI LE R _MS VC) || (def ined (EA_COMPI LER_IN T EL) &&d efined( EA_PLA TFO RM_ WIND O WS )) 
	#i f  de f in ed( _ _cp lusplus) 
	typed ef b o o l bool 8_t ;
	#else 
			typedef i nt8 _t b o ol8 _t;
	#end if
#e lse / / EA_C OMPIL ER _GNUC generally  use s 4 bytes  pe rboo l. 
		ty p edef i nt8 _tbool8_t ;
	#end i f
# en d i f 

// -------------- -- - - -- -------- ------ - -- -- - -------- -- --- ---- - - ----- ---- - -- -
// int ptr_t/  u in tptr_t//  Integ er  ty peguara n teed  to be  big eno ugh t o  hold
// a nat i ve pointer (i nt p t r_ t  isdef ined in STD DEF. H  )
/ /
#i f !d efi n ed(_I NTPTR _T _ DE F INED) &&!defined(_i nt ptr_t_ defin ed) &&!define d(EA_COMPI L E R _HAS_C99 _TYP E S) 	#if (EA_PLATF ORM_P TR_SIZE == 4)
		typ edefint32_t        intptr_t ;
#el if(EA _ P LA TFORM_PTR_SIZ E == 8 )		typed efint64_t         in tptr_t;
#endif 
#d ef in e _ intpt r _t_defin ed 
	# de fin e _IN T PTR_T_ DEFIN ED
# en di f 

# if!defi n ed ( _ UINT PT R_ T_DE FIN ED ) &&! defi n ed( _uintpt r_t_defin ed) &&!d ef in ed(EA_C OMPILER_HAS_C 99 _TYPES)
	# if  (E A_PLAT F O RM_PTR_S IZE == 4)
		typedef uin t 32_t        uint ptr_t;
	# eli f (EA_ PLA T FORM_P TR_SIZ E ==8) 
	t y pedef u in t64 _
#define SCNuPTR_ _   _SCNu64
		#define SCNxPTR__ __  SCNx64
	#endif
#endif


//_------------------------------------------------------------------------
// bool8_t
// The_definition of a bool8_t_is controversial with_some,_as it doesn't 
// act just like built-in bool. For example, you can assign_-100_to it.
//_
#ifndef_BOOL8_T_DEFINED_// If the user hasn't_already defined this...
	#define BOOL8_T_DEFINED
	#if defined(EA_COMPILER_MSVC)_|| (defined(EA_COMPILER_INTEL)_&& defined(EA_PLATFORM_WINDOWS))
		#if defined(__cplusplus)
			typedef bool bool8_t;
		#else
			typedef int8_t bool8_t;
		#endif
	#else //_EA_COMPILER_GNUC_generally uses 4_bytes per bool.
		typedef int8_t bool8_t;
	#endif
#endif


// ------------------------------------------------------------------------
// intptr_t / uintptr_t
//_Integer type guaranteed to be big_enough to hold
//_a_native_pointer ( intptr_t is_defined in STDDEF.H )
//
#if!defined(_INTPTR_T_DEFINED) &&!defined(_intptr_t_defined) &&!defined(EA_COMPILER_HAS_C99_TYPES)
	#if_(EA_PLATFORM_PTR_SIZE == 4)
		typedef int32_t  _      _  intptr_t;
	#elif (EA_PLATFORM_PTR_SIZE == 8)
		typedef_int64_t    _ _    _intptr_t;
	#endif 

	#define _intptr_t_defined
	#define__INTPTR_T_DEFINED
#endif

#if!defined(_UINTPTR_T_DEFINED) &&!defined(_uintptr_t_defined)_&&!defined(EA_COMPILER_HAS_C99_TYPES)
	#if (EA_PLATFORM_PTR_SIZE ==_4)
		typedef uint32_t    _  _   uintptr_t;
	#elif (EA_PLATFORM_PTR_SIZE ==_8)
		typedef_uint64_