/* @(#)root/base:$Id$ */

/*************************************************************************
 * Copyright (C) 1995-2014, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_Rtypes
#define ROOT_Rtypes

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Rtypes                                                               //
//                                                                      //
// Basic types used by ROOT; ClassDef macros.                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


#ifndef ROOT_RtypesCore
#include "RtypesCore.h"
#endif
#ifndef ROOT_DllImport
#include "DllImport.h"
#endif
#ifndef ROOT_Rtypeinfo
#include "Rtypeinfo.h"
#endif

#include <stdio.h>
#include <string.h>
#include "snprintf.h"   // part of stdio.h on systems that have it
#include "strlcpy.h"    // part of string.h on systems that have it
#include <atomic>


//---- forward declared class types --------------------------------------------

class TClass;
class TBuffer;
class TDirectory;
class TMemberInspector;
class TObject;
class TNamed;
class TCollection;
class TFileMergeInfo;
class TString;

//Moved from TSystem.
enum ESysConstants {
   kMAXSIGNALS       = 15,
   kMAXPATHLEN       = 8192,
   kBUFFERSIZE       = 8192,
   kItimerResolution = 10      // interval-timer resolution in ms
};

enum EColor { kWhite =0,   kBlack =1,   kGray=920,
              kRed   =632, kGreen =416, kBlue=600, kYellow=400, kMagenta=616, kCyan=432,
              kOrange=800, kSpring=820, kTeal=840, kAzure =860, kViolet =880, kPink=900 };

// There is several streamer concepts.
class TClassStreamer;   // Streamer functor for a class
class TMemberStreamer;  // Streamer functor for a data member
typedef void (*ClassStreamerFunc_t)(TBuffer&, void*);  // Streamer function for a class
typedef void (*ClassConvStreamerFunc_t)(TBuffer&, void*, const TClass*);  // Streamer function for a class with conversion.
typedef void (*MemberStreamerFunc_t)(TBuffer&, void*, Int_t); // Streamer function for a data member

// This class is used to implement proxy around collection classes.
class TVirtualCollectionProxy;

typedef void    (*VoidFuncPtr_t)();  //pointer to void function
typedef TClass* (*DictFuncPtr_t)();  //pointer to dictionary function
// NOTE: the previous name must be changed.


//---- constants ---------------------------------------------------------------

#ifndef NULL
#define NULL 0
#endif

#ifndef R__NULLPTR
#ifndef nullptr
#define nullptr 0
#endif
#endif

const Bool_t kTRUE  = true;
const Bool_t kFALSE = false;

const Int_t     kMaxUChar    = 256;
const Int_t     kMaxChar     = kMaxUChar >> 1;
const Int_t     kMinChar     = -kMaxChar - 1;

const Int_t     kMaxUShort   = 65534;
const Int_t     kMaxShort    = kMaxUShort >> 1;
const Int_t     kMinShort    = -kMaxShort - 1;

const UInt_t    kMaxUInt     = UInt_t(~0);
const Int_t     kMaxInt      = Int_t(kMaxUInt >> 1);
const Int_t     kMinInt      = -kMaxInt - 1;

const ULong_t   kMaxULong    = ULong_t(~0);
const Long_t    kMaxLong     = Long_t(kMaxULong >> 1);
const Long_t    kMinLong     = -kMaxLong - 1;

const ULong64_t kMaxULong64  = ULong64_t(~0LL);
const Long64_t  kMaxLong64   = Long64_t(kMaxULong64 >> 1);
const Long64_t  kMinLong64   = -kMaxLong64 - 1;

const size_t    kBitsPerByte = 8;
const Ssiz_t    kNPOS        = ~(Ssiz_t)0;


//--- bit manipulation ---------------------------------------------------------

#define BIT(n)       (1ULL << (n))
#define SETBIT(n,i)  ((n) |= BIT(i))
#define CLRBIT(n,i)  ((n) &= ~BIT(i))
#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))


//---- debug global ------------------------------------------------------------

R__EXTERN Int_t gDebug;


//---- ClassDef macros ---------------------------------------------------------

typedef void (*ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient);
class TVirtualIsAProxy;
typedef TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);

// TBuffer.h declares and implements the following 2 operators
template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
template <class Tmpl> TBuffer &operator<<(TBuffer &buf, const Tmpl *obj);

// This might get used if we implement setting a class version.
// template <class RootClass> Short_t GetClassVersion(RootClass *);

namespace ROOT {

   class TGenericClassInfo;
   typedef void *(*NewFunc_t)(void *);
   typedef void *(*NewArrFunc_t)(Long_t size, void *arena);
   typedef void  (*DelFunc_t)(void *);
   typedef void  (*DelArrFunc_t)(void *);
   typedef void  (*DesFunc_t)(void *);
   typedef void  (*DirAutoAdd_t)(void *, TDirectory *);
   typedef Long64_t (*MergeFunc_t)(void *, TCollection *, TFileMergeInfo *);
   typedef void  (*ResetAfterMergeFunc_t)(void *, TFileMergeInfo *);

   template <class RootClass> Short_t SetClassVersion(RootClass *);

   extern TClass *CreateClass(const char *cname, Version_t id,
                              const type_info &info, TVirtualIsAProxy *isa,
                              const char *dfil, const char *ifil,
                              Int_t dl, Int_t il);
   extern void AddClass(const char *cname, Version_t id, const type_info &info,
                        DictFuncPtr_t dict, Int_t pragmabits);
   extern void RemoveClass(const char *cname);
   extern void ResetClassVersion(TClass*, const char*, Short_t);
   extern void AddClassAlternate(const char *normName, const char *alternate);

   extern TNamed *RegisterClassTemplate(const char *name,
                                        const char *file, Int_t line);

   extern void Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector&);

#if 0
   // This function is only implemented in the dictionary file.
   // The parameter is 'only' for overloading resolution.
   // Used to be a template <class T> TGenericClassInfo *GenerateInitInstance(const T*);
   template <class T> TGenericClassInfo *GetClassInfo(const T* t) {
      TGenericClassInfo *GenerateInitInstance(const T*);
      return CreateInitInstance(t);
   };
#endif

   class TInitBehavior {
      // This class defines the interface for the class registration and
      // the TClass creation. To modify the default behavior, one would
      // inherit from this class and overload ROOT::DefineBehavior().
      // See TQObject.h and table/inc/Ttypes.h for examples.
   public:
      virtual ~TInitBehavior() { }
      virtual void Register(const char *cname, Version_t id, const type_info &info,
                            DictFuncPtr_t dict, Int_t pragmabits) const = 0;
      virtual void Unregister(const char *classname) const = 0;
      virtual TClass *CreateClass(const char *cname, Version_t id,
                                  const type_info &info, TVirtualIsAProxy *isa,
                                  const char *dfil, const char *ifil,
                                  Int_t dl, Int_t il) const = 0;
   };

   class TDefaultInitBehavior : public TInitBehavior {
   public:
      virtual void Register(const char *cname, Version_t id, const type_info &info,
                            DictFuncPtr_t dict, Int_t pragmabits) const {
         ROOT::AddClass(cname, id, info, dict, pragmabits);
      }
      virtual void Unregister(const char *classname) const {
         ROOT::RemoveClass(classname);
      }
      virtual TClass *CreateClass(const char *cname, Version_t id,
                                  const type_info &info, TVirtualIsAProxy *isa,
                                  const char *dfil, const char *ifil,
                                  Int_t dl, Int_t il) const {
         return ROOT::CreateClass(cname, id, info, isa, dfil, ifil, dl, il);
      }
   };

   const TInitBehavior *DefineBehavior(void * /*parent_type*/,
                                       void * /*actual_type*/);

} // End of namespace ROOT

// The macros below use TGenericClassInfo, so let's ensure it is included
#ifndef ROOT_TGenericClassInfo
#include "TGenericClassInfo.h"
#endif

typedef std::atomic<TClass*> atomic_TClass_ptr;

// Common part of ClassDef definition.
// DeclFileLine() is not part of it since CINT uses that as trigger for
// the class comment string.
#define _ClassDef_(name,id, virtual_keyword, overrd) \
private: \
   static atomic_TClass_ptr fgIsA; \
public: \
   static TClass *Class(); \
   static const char *Class_Name(); \
   static Version_t Class_Version() { return id; } \
   static TClass *Dictionary(); \
   virtual_keyword TClass *IsA() const overrd { return name::Class(); } \
   virtual_keyword void ShowMembers(TMemberInspector&insp) const overrd { ::ROOT::Class_ShowMembers(name::Class(), this, insp); } \
   virtual_keyword void Streamer(TBuffer&) overrd; \
   void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
   static const char *DeclFileName() { return __FILE__; } \
   static int ImplFileLine(); \
   static const char *ImplFileName();

#define _ClassDefInterp_(name,id,virtual_keyword, overrd) \
private: \
public: \
   static TClass *Class() { static TClass* sIsA = 0; if (!sIsA) sIsA = TClass::GetClass(#name); return sIsA; } \
   static const char *Class_Name() { return #name; } \
   static Version_t Class_Version() { return id; } \
   static TClass *Dictionary() { return 0; } \
   virtual_keyword TClass *IsA() const overrd { return name::Class(); } \
   virtual_keyword void ShowMembers(TMemberInspector&insp) const overrd { ::ROOT::Class_ShowMembers(name::Class(), this, insp); } \
   virtual_keyword void Streamer(TBuffer&) overrd { Error ("Streamer", "Cannot stream interpreted class."); } \
   void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
   static const char *DeclFileName() { return __FILE__; } \
   static int ImplFileLine() { return 0; } \
   static const char *ImplFileName() { return __FILE__; }

#define ClassDef(name,id) \
   _ClassDef_(name,id,virtual,)   \
   static int DeclFileLine() { return __LINE__; }

#define ClassDefOverride(name,id) \
   _ClassDef_(name,id,,override)   \
   static int DeclFileLine() { return __LINE__; }

#define ClassDefNV(name,id) \
   _ClassDef_(name,id,,) \
   static int DeclFileLine() { return __LINE__; }

#define R__UseDummy(name) \
   class _NAME2_(name,_c) { public: _NAME2_(name,_c)() { if (name) { } } }


#define ClassImpUnique(name,key) \
   namespace ROOT { \
      TGenericClassInfo *GenerateInitInstance(const name*); \
      namespace { \
         static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) = \
            GenerateInitInstance((name*)0x0)->SetImplFile(__FILE__, __LINE__); \
         R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyint,key))); \
      } \
   }
#define ClassImp(name) ClassImpUnique(name,default)

// Macro for Namespace

#define NamespaceImpUnique(name,key) \
   namespace name { \
      namespace ROOT { \
         ::ROOT::TGenericClassInfo *GenerateInitInstance(); \
         namespace { \
            static int _R__UNIQUE_(_NAME2_(R__dummyint,key)) = \
               GenerateInitInstance()->SetImplFile(__FILE__, __LINE__); \
            R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyint,key))); \
         } \
      } \
   }
#define NamespaceImp(name) NamespaceImpUnique(name,default)

//---- ClassDefT macros for templates with one template argument ---------------
// ClassDefT  corresponds to ClassDef
// ClassDefT2 goes in the same header as ClassDefT but must be
//            outside the class scope
// ClassImpT  corresponds to ClassImp


// This ClassDefT is stricly redundant and is kept only for
// backward compatibility.

#define ClassDefT(name,id) \
   _ClassDef_(name,id,virtual,) \
   static int DeclFileLine() { return __LINE__; }

#define ClassDefTNV(name,id) \
   _ClassDef_(name,id,virtual,) \
   static int DeclFileLine() { return __LINE__; }


#define ClassDefT2(name,Tmpl)



#define templateClassImpUnique(name,key) \
   namespace ROOT { \
      static TNamed *_R__UNIQUE_(_NAME2_(R__dummyholder,key)) = \
         ROOT::RegisterClassTemplate(_QUOTE_(name), __FILE__, __LINE__); \
      R__UseDummy(_R__UNIQUE_(_NAME2_(R__dummyholder,key))); \
   }
#define templateClassImp(name) templateClassImpUnique(name,default)

#define ClassImpT(name,Tmpl) templateClassImp(name)

//---- ClassDefT macros for templates with two template arguments --------------
// ClassDef2T2 goes in the same header as ClassDefT but must be
//             outside the class scope
// ClassImp2T  corresponds to ClassImpT

#define ClassDef2T2(name,Tmpl1,Tmpl2)
#define ClassImp2T(name,Tmpl1,Tmpl2) templateClassImp(name)


//---- ClassDefT macros for templates with three template arguments ------------
// ClassDef3T2 goes in the same header as ClassDefT but must be
//             outside the class scope
// ClassImp3T  corresponds to ClassImpT

#define ClassDef3T2(name,Tmpl1,Tmpl2,Tmpl3)
#define ClassImp3T(name,Tmpl1,Tmpl2,Tmpl3) templateClassImp(name)


//---- Macro to set the class version of non instrumented classes --------------

#define RootClassVersion(name,VersionNumber) \
namespace ROOT { \
   TGenericClassInfo *GenerateInitInstance(const name*); \
   static Short_t _R__UNIQUE_(R__dummyVersionNumber) = \
           GenerateInitInstance((name*)0x0)->SetVersion(VersionNumber); \
   R__UseDummy(_R__UNIQUE_(R__dummyVersionNumber)); \
}

#define RootStreamer(name,STREAMER)                                  \
namespace ROOT {                                                     \
   TGenericClassInfo *GenerateInitInstance(const name*);             \
   static Short_t _R__UNIQUE_(R__dummyStreamer) =                    \
           GenerateInitInstance((name*)0x0)->SetStreamer(STREAMER);  \
   R__UseDummy(_R__UNIQUE_(R__dummyStreamer));                       \
}

//---- Macro to load a library into the interpreter --------------
// Call as R__LOAD_LIBRARY(libEvent)
// This macro intentionally does not take string as argument, to
// prevent compilation errors with complex diagnostics due to
//   TString BAD_DO_NOT_TRY = "lib";
//   R__LOAD_LIBRARY(BAD_DO_NOT_TRY + "BAD_DO_NOT_TRY.so") // ERROR!
#define _R_PragmaStr(x) _Pragma(#x)
#ifdef __CLING__
# define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(cling load ( #LIBRARY ))
# define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(cling add_include_path ( #PATH ))
# define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(cling add_library_path ( #PATH ))
#elif defined(R__WIN32)
# define R__LOAD_LIBRARY(LIBRARY) _R_PragmaStr(comment(lib, #LIBRARY))
# define R__ADD_INCLUDE_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
# define R__ADD_LIBRARY_PATH(PATH) _R_PragmaStr(comment(path, #PATH))
#else
// No way to inform linker though preprocessor :-(
// We could even inform the user:
/*
# define R__LOAD_LIBRARY(LIBRARY) \
   _R_PragmaStr(message "Compiler cannot handle linking against " #LIBRARY \
                ". Use -L and -l instead.")
*/
# define R__LOAD_LIBRARY(LIBRARY)
# define R__ADD_INCLUDE_PATH(PATH)
# define R__ADD_LIBRARY_PATH(PATH)
#endif

#endif
 Rtypes.h:1
 Rtypes.h:2
 Rtypes.h:3
 Rtypes.h:4
 Rtypes.h:5
 Rtypes.h:6
 Rtypes.h:7
 Rtypes.h:8
 Rtypes.h:9
 Rtypes.h:10
 Rtypes.h:11
 Rtypes.h:12
 Rtypes.h:13
 Rtypes.h:14
 Rtypes.h:15
 Rtypes.h:16
 Rtypes.h:17
 Rtypes.h:18
 Rtypes.h:19
 Rtypes.h:20
 Rtypes.h:21
 Rtypes.h:22
 Rtypes.h:23
 Rtypes.h:24
 Rtypes.h:25
 Rtypes.h:26
 Rtypes.h:27
 Rtypes.h:28
 Rtypes.h:29
 Rtypes.h:30
 Rtypes.h:31
 Rtypes.h:32
 Rtypes.h:33
 Rtypes.h:34
 Rtypes.h:35
 Rtypes.h:36
 Rtypes.h:37
 Rtypes.h:38
 Rtypes.h:39
 Rtypes.h:40
 Rtypes.h:41
 Rtypes.h:42
 Rtypes.h:43
 Rtypes.h:44
 Rtypes.h:45
 Rtypes.h:46
 Rtypes.h:47
 Rtypes.h:48
 Rtypes.h:49
 Rtypes.h:50
 Rtypes.h:51
 Rtypes.h:52
 Rtypes.h:53
 Rtypes.h:54
 Rtypes.h:55
 Rtypes.h:56
 Rtypes.h:57
 Rtypes.h:58
 Rtypes.h:59
 Rtypes.h:60
 Rtypes.h:61
 Rtypes.h:62
 Rtypes.h:63
 Rtypes.h:64
 Rtypes.h:65
 Rtypes.h:66
 Rtypes.h:67
 Rtypes.h:68
 Rtypes.h:69
 Rtypes.h:70
 Rtypes.h:71
 Rtypes.h:72
 Rtypes.h:73
 Rtypes.h:74
 Rtypes.h:75
 Rtypes.h:76
 Rtypes.h:77
 Rtypes.h:78
 Rtypes.h:79
 Rtypes.h:80
 Rtypes.h:81
 Rtypes.h:82
 Rtypes.h:83
 Rtypes.h:84
 Rtypes.h:85
 Rtypes.h:86
 Rtypes.h:87
 Rtypes.h:88
 Rtypes.h:89
 Rtypes.h:90
 Rtypes.h:91
 Rtypes.h:92
 Rtypes.h:93
 Rtypes.h:94
 Rtypes.h:95
 Rtypes.h:96
 Rtypes.h:97
 Rtypes.h:98
 Rtypes.h:99
 Rtypes.h:100
 Rtypes.h:101
 Rtypes.h:102
 Rtypes.h:103
 Rtypes.h:104
 Rtypes.h:105
 Rtypes.h:106
 Rtypes.h:107
 Rtypes.h:108
 Rtypes.h:109
 Rtypes.h:110
 Rtypes.h:111
 Rtypes.h:112
 Rtypes.h:113
 Rtypes.h:114
 Rtypes.h:115
 Rtypes.h:116
 Rtypes.h:117
 Rtypes.h:118
 Rtypes.h:119
 Rtypes.h:120
 Rtypes.h:121
 Rtypes.h:122
 Rtypes.h:123
 Rtypes.h:124
 Rtypes.h:125
 Rtypes.h:126
 Rtypes.h:127
 Rtypes.h:128
 Rtypes.h:129
 Rtypes.h:130
 Rtypes.h:131
 Rtypes.h:132
 Rtypes.h:133
 Rtypes.h:134
 Rtypes.h:135
 Rtypes.h:136
 Rtypes.h:137
 Rtypes.h:138
 Rtypes.h:139
 Rtypes.h:140
 Rtypes.h:141
 Rtypes.h:142
 Rtypes.h:143
 Rtypes.h:144
 Rtypes.h:145
 Rtypes.h:146
 Rtypes.h:147
 Rtypes.h:148
 Rtypes.h:149
 Rtypes.h:150
 Rtypes.h:151
 Rtypes.h:152
 Rtypes.h:153
 Rtypes.h:154
 Rtypes.h:155
 Rtypes.h:156
 Rtypes.h:157
 Rtypes.h:158
 Rtypes.h:159
 Rtypes.h:160
 Rtypes.h:161
 Rtypes.h:162
 Rtypes.h:163
 Rtypes.h:164
 Rtypes.h:165
 Rtypes.h:166
 Rtypes.h:167
 Rtypes.h:168
 Rtypes.h:169
 Rtypes.h:170
 Rtypes.h:171
 Rtypes.h:172
 Rtypes.h:173
 Rtypes.h:174
 Rtypes.h:175
 Rtypes.h:176
 Rtypes.h:177
 Rtypes.h:178
 Rtypes.h:179
 Rtypes.h:180
 Rtypes.h:181
 Rtypes.h:182
 Rtypes.h:183
 Rtypes.h:184
 Rtypes.h:185
 Rtypes.h:186
 Rtypes.h:187
 Rtypes.h:188
 Rtypes.h:189
 Rtypes.h:190
 Rtypes.h:191
 Rtypes.h:192
 Rtypes.h:193
 Rtypes.h:194
 Rtypes.h:195
 Rtypes.h:196
 Rtypes.h:197
 Rtypes.h:198
 Rtypes.h:199
 Rtypes.h:200
 Rtypes.h:201
 Rtypes.h:202
 Rtypes.h:203
 Rtypes.h:204
 Rtypes.h:205
 Rtypes.h:206
 Rtypes.h:207
 Rtypes.h:208
 Rtypes.h:209
 Rtypes.h:210
 Rtypes.h:211
 Rtypes.h:212
 Rtypes.h:213
 Rtypes.h:214
 Rtypes.h:215
 Rtypes.h:216
 Rtypes.h:217
 Rtypes.h:218
 Rtypes.h:219
 Rtypes.h:220
 Rtypes.h:221
 Rtypes.h:222
 Rtypes.h:223
 Rtypes.h:224
 Rtypes.h:225
 Rtypes.h:226
 Rtypes.h:227
 Rtypes.h:228
 Rtypes.h:229
 Rtypes.h:230
 Rtypes.h:231
 Rtypes.h:232
 Rtypes.h:233
 Rtypes.h:234
 Rtypes.h:235
 Rtypes.h:236
 Rtypes.h:237
 Rtypes.h:238
 Rtypes.h:239
 Rtypes.h:240
 Rtypes.h:241
 Rtypes.h:242
 Rtypes.h:243
 Rtypes.h:244
 Rtypes.h:245
 Rtypes.h:246
 Rtypes.h:247
 Rtypes.h:248
 Rtypes.h:249
 Rtypes.h:250
 Rtypes.h:251
 Rtypes.h:252
 Rtypes.h:253
 Rtypes.h:254
 Rtypes.h:255
 Rtypes.h:256
 Rtypes.h:257
 Rtypes.h:258
 Rtypes.h:259
 Rtypes.h:260
 Rtypes.h:261
 Rtypes.h:262
 Rtypes.h:263
 Rtypes.h:264
 Rtypes.h:265
 Rtypes.h:266
 Rtypes.h:267
 Rtypes.h:268
 Rtypes.h:269
 Rtypes.h:270
 Rtypes.h:271
 Rtypes.h:272
 Rtypes.h:273
 Rtypes.h:274
 Rtypes.h:275
 Rtypes.h:276
 Rtypes.h:277
 Rtypes.h:278
 Rtypes.h:279
 Rtypes.h:280
 Rtypes.h:281
 Rtypes.h:282
 Rtypes.h:283
 Rtypes.h:284
 Rtypes.h:285
 Rtypes.h:286
 Rtypes.h:287
 Rtypes.h:288
 Rtypes.h:289
 Rtypes.h:290
 Rtypes.h:291
 Rtypes.h:292
 Rtypes.h:293
 Rtypes.h:294
 Rtypes.h:295
 Rtypes.h:296
 Rtypes.h:297
 Rtypes.h:298
 Rtypes.h:299
 Rtypes.h:300
 Rtypes.h:301
 Rtypes.h:302
 Rtypes.h:303
 Rtypes.h:304
 Rtypes.h:305
 Rtypes.h:306
 Rtypes.h:307
 Rtypes.h:308
 Rtypes.h:309
 Rtypes.h:310
 Rtypes.h:311
 Rtypes.h:312
 Rtypes.h:313
 Rtypes.h:314
 Rtypes.h:315
 Rtypes.h:316
 Rtypes.h:317
 Rtypes.h:318
 Rtypes.h:319
 Rtypes.h:320
 Rtypes.h:321
 Rtypes.h:322
 Rtypes.h:323
 Rtypes.h:324
 Rtypes.h:325
 Rtypes.h:326
 Rtypes.h:327
 Rtypes.h:328
 Rtypes.h:329
 Rtypes.h:330
 Rtypes.h:331
 Rtypes.h:332
 Rtypes.h:333
 Rtypes.h:334
 Rtypes.h:335
 Rtypes.h:336
 Rtypes.h:337
 Rtypes.h:338
 Rtypes.h:339
 Rtypes.h:340
 Rtypes.h:341
 Rtypes.h:342
 Rtypes.h:343
 Rtypes.h:344
 Rtypes.h:345
 Rtypes.h:346
 Rtypes.h:347
 Rtypes.h:348
 Rtypes.h:349
 Rtypes.h:350
 Rtypes.h:351
 Rtypes.h:352
 Rtypes.h:353
 Rtypes.h:354
 Rtypes.h:355
 Rtypes.h:356
 Rtypes.h:357
 Rtypes.h:358
 Rtypes.h:359
 Rtypes.h:360
 Rtypes.h:361
 Rtypes.h:362
 Rtypes.h:363
 Rtypes.h:364
 Rtypes.h:365
 Rtypes.h:366
 Rtypes.h:367
 Rtypes.h:368
 Rtypes.h:369
 Rtypes.h:370
 Rtypes.h:371
 Rtypes.h:372
 Rtypes.h:373
 Rtypes.h:374
 Rtypes.h:375
 Rtypes.h:376
 Rtypes.h:377
 Rtypes.h:378
 Rtypes.h:379
 Rtypes.h:380
 Rtypes.h:381
 Rtypes.h:382
 Rtypes.h:383
 Rtypes.h:384
 Rtypes.h:385
 Rtypes.h:386
 Rtypes.h:387
 Rtypes.h:388
 Rtypes.h:389
 Rtypes.h:390
 Rtypes.h:391
 Rtypes.h:392
 Rtypes.h:393
 Rtypes.h:394
 Rtypes.h:395
 Rtypes.h:396
 Rtypes.h:397
 Rtypes.h:398
 Rtypes.h:399
 Rtypes.h:400
 Rtypes.h:401