00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME dOdOdIBesVisLibdIBesVisLib_rootcint
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
00016 namespace std {} using namespace std;
00017 #include "BesVisLib_rootcint.h"
00018
00019 #include "TCollectionProxyInfo.h"
00020 #include "TClass.h"
00021 #include "TBuffer.h"
00022 #include "TMemberInspector.h"
00023 #include "TError.h"
00024
00025 #ifndef G__ROOT
00026 #define G__ROOT
00027 #endif
00028
00029 #include "RtypesImp.h"
00030 #include "TIsAProxy.h"
00031 #include "TFileMergeInfo.h"
00032
00033
00034
00035 namespace ROOT {
00036 namespace Shadow {
00037 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00038 typedef ::SubDetectorROOTGeo SubDetectorROOTGeo;
00039 #else
00040 class SubDetectorROOTGeo {
00041 public:
00042
00043
00044 virtual ~SubDetectorROOTGeo() throw() {};
00045 ::SAXProcessor m_sxp;
00046 ::ProcessingConfigurator m_config;
00047 int m_ROOTGeoInit;
00048 int m_childNo;
00049 int m_2DGeoInit;
00050 ::TGeoVolume* m_TopVolume;
00051 ::TObjArray* m_DetectorsArray;
00052 ::TObjArray* m_HitsArray;
00053 ::TObjArray* m_2DHitsArray;
00054 };
00055 #endif
00056
00057 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00058 typedef ::MdcROOTGeo MdcROOTGeo;
00059 #else
00060 class MdcROOTGeo : public ::SubDetectorROOTGeo {
00061 public:
00062
00063 typedef ::std::map<int,int, ::less<int>, ::allocator< ::pair<const int,int> > > intMap;
00064
00065 virtual ~MdcROOTGeo() throw() {};
00066 bool k_TFire;
00067 bool k_QFire;
00068 bool k_QNotOverflow;
00069 bool k_ColorfulWire;
00070 bool k_MdcTimeSubEvTime;
00071 int m_MdcColor;
00072 int m_segmentColor;
00073 int m_hypeColor;
00074 int m_tubeColor;
00075 int m_twistedTubsColor;
00076 int m_replicaColor;
00077 map< int, int > m_CorrectMap;
00078 ::TGeoVolume* m_Mdc;
00079 ::TGeoNode* m_NodeLayer[50];
00080 ::TGeoNode* m_NodeReplica[50][288];
00081 ::TGeoPhysicalNode* m_PhysicalSegment[132];
00082 ::TGeoPhysicalNode* m_PhysicalReplica[50][288];
00083 :: TObjArray* m_MdcDigiCol;
00084 ::BesCircle2D* m_MdcXY;
00085 ::BesCircle2D* m_MdcXYSuper[4];
00086 ::Mdc2DWire* m_Mdc2DWire[43][288];
00087 ::BesPolygon2D* m_MdcZR[2];
00088 };
00089 #endif
00090
00091 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00092 typedef ::TofROOTGeo TofROOTGeo;
00093 #else
00094 class TofROOTGeo : public ::SubDetectorROOTGeo {
00095 public:
00096
00097
00098 virtual ~TofROOTGeo() throw() {};
00099 bool k_TMatch;
00100 bool k_QMatch;
00101 int m_TofColor;
00102 int m_BucketColor;
00103 int m_ScinColor;
00104 ::TGeoVolume* m_Tof;
00105 ::TGeoNode* m_NodePVF[3][2][88];
00106 ::TGeoNode* m_NodeAl[3][2];
00107 ::TGeoNode* m_NodeScin[3][2];
00108 ::TGeoPhysicalNode* m_PhysicalScin[3][2][88];
00109 :: TObjArray* m_TofDigiCol;
00110 ::Tof2DScin* m_Tof2DScin[3][2][88];
00111 };
00112 #endif
00113
00114 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00115 typedef ::EmcROOTGeo EmcROOTGeo;
00116 #else
00117 class EmcROOTGeo : public ::SubDetectorROOTGeo {
00118 public:
00119
00120
00121 virtual ~EmcROOTGeo() throw() {};
00122 int m_kPhiEc;
00123 int m_kThetaEc;
00124 int m_kSectorEc;
00125 int m_kNbEc;
00126 int m_kRealNbEc;
00127 int m_EmcColor;
00128 int m_partColor;
00129 int m_phiColor;
00130 int m_thetaColor;
00131 int m_brCrystalColor;
00132 int m_ecCrystalColor;
00133 ::TGeoVolume* m_Emc;
00134 ::TGeoNode* m_NodePart[3];
00135 ::TGeoNode* m_NodePhi[3][120];
00136 ::TGeoNode* m_NodeTheta[3][120][44];
00137 ::TGeoNode* m_NodeTheta2[3][120][44];
00138 ::TGeoPhysicalNode* m_PhysicalCrystal[3][120][44];
00139 ::TGeoPhysicalNode* m_PhysicalCrystal2[3][120][44];
00140 ::TObjArray* m_PhyNodeOrgArray;
00141 :: TObjArray* m_EmcDigiCol;
00142 ::Emc2DCrystal* m_Emc2DCrystal[3][120][44];
00143 };
00144 #endif
00145
00146 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00147 typedef ::MucROOTGeo MucROOTGeo;
00148 #else
00149 class MucROOTGeo : public ::SubDetectorROOTGeo {
00150 public:
00151
00152
00153 virtual ~MucROOTGeo() throw() {};
00154 int m_StripNum[3][8][9];
00155 int m_MucColor;
00156 int m_absorberColor;
00157 int m_gapColor;
00158 int m_gasChamberColor;
00159 int m_bakeliteColor;
00160 int m_stripColor;
00161 ::TGeoVolume* m_Muc;
00162 ::TGeoNode* m_NodeAbsorber[3][8][9];
00163 ::TGeoNode* m_NodeAbsorberPanel[3][8][9][4];
00164 ::TGeoNode* m_NodeGap[3][8][9];
00165 ::TGeoNode* m_NodeStripPlane[3][8][9];
00166 ::TGeoNode* m_NodeStrip[3][8][9][112];
00167 ::TGeoPhysicalNode* m_PhysicalAbsorber[3][8][9][4];
00168 ::TGeoPhysicalNode* m_PhysicalGap[3][8][9];
00169 ::TGeoPhysicalNode* m_PhysicalStrip[3][8][9][112];
00170 :: TObjArray* m_MucDigiCol;
00171 ::BesPolygon2D* m_MucXY[3][8];
00172 ::BesPolygon2D* m_MucZR[3][8];
00173 ::BesPolygon2D* m_MucXYGap[3][8][9];
00174 ::BesPolygon2D* m_MucZRGap[3][8][9];
00175 ::Muc2DStrip* m_Muc2DStrip[3][8][9][112];
00176 };
00177 #endif
00178
00179 #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00180 typedef vector3 vector3;
00181 #else
00182 class vector3 {
00183 public:
00184
00185 float x;
00186 float y;
00187 float z;
00188 };
00189 #endif
00190
00191 }
00192 }
00193
00194
00195 namespace ROOT {
00196 void BesStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
00197 static void *new_BesStatus(void *p = 0);
00198 static void *newArray_BesStatus(Long_t size, void *p);
00199 static void delete_BesStatus(void *p);
00200 static void deleteArray_BesStatus(void *p);
00201 static void destruct_BesStatus(void *p);
00202
00203
00204 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesStatus*)
00205 {
00206 ::BesStatus *ptr = 0;
00207 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesStatus >(0);
00208 static ::ROOT::TGenericClassInfo
00209 instance("BesStatus", ::BesStatus::Class_Version(), "./../BesVisLib/BesStatus.h", 20,
00210 typeid(::BesStatus), DefineBehavior(ptr, ptr),
00211 &::BesStatus::Dictionary, isa_proxy, 4,
00212 sizeof(::BesStatus) );
00213 instance.SetNew(&new_BesStatus);
00214 instance.SetNewArray(&newArray_BesStatus);
00215 instance.SetDelete(&delete_BesStatus);
00216 instance.SetDeleteArray(&deleteArray_BesStatus);
00217 instance.SetDestructor(&destruct_BesStatus);
00218 return &instance;
00219 }
00220 TGenericClassInfo *GenerateInitInstance(const ::BesStatus*)
00221 {
00222 return GenerateInitInstanceLocal((::BesStatus*)0);
00223 }
00224
00225 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00226 }
00227
00228 namespace ROOT {
00229 void BesTView_ShowMembers(void *obj, TMemberInspector &R__insp);
00230 static void *new_BesTView(void *p = 0);
00231 static void *newArray_BesTView(Long_t size, void *p);
00232 static void delete_BesTView(void *p);
00233 static void deleteArray_BesTView(void *p);
00234 static void destruct_BesTView(void *p);
00235 static void streamer_BesTView(TBuffer &buf, void *obj);
00236
00237
00238 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesTView*)
00239 {
00240 ::BesTView *ptr = 0;
00241 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesTView >(0);
00242 static ::ROOT::TGenericClassInfo
00243 instance("BesTView", ::BesTView::Class_Version(), "./../BesVisLib/BesTView.h", 31,
00244 typeid(::BesTView), DefineBehavior(ptr, ptr),
00245 &::BesTView::Dictionary, isa_proxy, 1,
00246 sizeof(::BesTView) );
00247 instance.SetNew(&new_BesTView);
00248 instance.SetNewArray(&newArray_BesTView);
00249 instance.SetDelete(&delete_BesTView);
00250 instance.SetDeleteArray(&deleteArray_BesTView);
00251 instance.SetDestructor(&destruct_BesTView);
00252 instance.SetStreamerFunc(&streamer_BesTView);
00253 return &instance;
00254 }
00255 TGenericClassInfo *GenerateInitInstance(const ::BesTView*)
00256 {
00257 return GenerateInitInstanceLocal((::BesTView*)0);
00258 }
00259
00260 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesTView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00261 }
00262
00263 namespace ROOT {
00264 void Bes2DView_ShowMembers(void *obj, TMemberInspector &R__insp);
00265 static void *new_Bes2DView(void *p = 0);
00266 static void *newArray_Bes2DView(Long_t size, void *p);
00267 static void delete_Bes2DView(void *p);
00268 static void deleteArray_Bes2DView(void *p);
00269 static void destruct_Bes2DView(void *p);
00270
00271
00272 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Bes2DView*)
00273 {
00274 ::Bes2DView *ptr = 0;
00275 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Bes2DView >(0);
00276 static ::ROOT::TGenericClassInfo
00277 instance("Bes2DView", ::Bes2DView::Class_Version(), "./../BesVisLib/Bes2DView.h", 25,
00278 typeid(::Bes2DView), DefineBehavior(ptr, ptr),
00279 &::Bes2DView::Dictionary, isa_proxy, 4,
00280 sizeof(::Bes2DView) );
00281 instance.SetNew(&new_Bes2DView);
00282 instance.SetNewArray(&newArray_Bes2DView);
00283 instance.SetDelete(&delete_Bes2DView);
00284 instance.SetDeleteArray(&deleteArray_Bes2DView);
00285 instance.SetDestructor(&destruct_Bes2DView);
00286 return &instance;
00287 }
00288 TGenericClassInfo *GenerateInitInstance(const ::Bes2DView*)
00289 {
00290 return GenerateInitInstanceLocal((::Bes2DView*)0);
00291 }
00292
00293 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Bes2DView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00294 }
00295
00296 namespace ROOT {
00297 void BesCircle2D_ShowMembers(void *obj, TMemberInspector &R__insp);
00298 static void *new_BesCircle2D(void *p = 0);
00299 static void *newArray_BesCircle2D(Long_t size, void *p);
00300 static void delete_BesCircle2D(void *p);
00301 static void deleteArray_BesCircle2D(void *p);
00302 static void destruct_BesCircle2D(void *p);
00303
00304
00305 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesCircle2D*)
00306 {
00307 ::BesCircle2D *ptr = 0;
00308 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesCircle2D >(0);
00309 static ::ROOT::TGenericClassInfo
00310 instance("BesCircle2D", ::BesCircle2D::Class_Version(), "./../BesVisLib/BesCircle2D.h", 25,
00311 typeid(::BesCircle2D), DefineBehavior(ptr, ptr),
00312 &::BesCircle2D::Dictionary, isa_proxy, 4,
00313 sizeof(::BesCircle2D) );
00314 instance.SetNew(&new_BesCircle2D);
00315 instance.SetNewArray(&newArray_BesCircle2D);
00316 instance.SetDelete(&delete_BesCircle2D);
00317 instance.SetDeleteArray(&deleteArray_BesCircle2D);
00318 instance.SetDestructor(&destruct_BesCircle2D);
00319 return &instance;
00320 }
00321 TGenericClassInfo *GenerateInitInstance(const ::BesCircle2D*)
00322 {
00323 return GenerateInitInstanceLocal((::BesCircle2D*)0);
00324 }
00325
00326 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesCircle2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00327 }
00328
00329 namespace ROOT {
00330 void BesCursor_ShowMembers(void *obj, TMemberInspector &R__insp);
00331 static void *new_BesCursor(void *p = 0);
00332 static void *newArray_BesCursor(Long_t size, void *p);
00333 static void delete_BesCursor(void *p);
00334 static void deleteArray_BesCursor(void *p);
00335 static void destruct_BesCursor(void *p);
00336
00337
00338 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesCursor*)
00339 {
00340 ::BesCursor *ptr = 0;
00341 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesCursor >(0);
00342 static ::ROOT::TGenericClassInfo
00343 instance("BesCursor", ::BesCursor::Class_Version(), "./../BesVisLib/BesCursor.h", 19,
00344 typeid(::BesCursor), DefineBehavior(ptr, ptr),
00345 &::BesCursor::Dictionary, isa_proxy, 4,
00346 sizeof(::BesCursor) );
00347 instance.SetNew(&new_BesCursor);
00348 instance.SetNewArray(&newArray_BesCursor);
00349 instance.SetDelete(&delete_BesCursor);
00350 instance.SetDeleteArray(&deleteArray_BesCursor);
00351 instance.SetDestructor(&destruct_BesCursor);
00352 return &instance;
00353 }
00354 TGenericClassInfo *GenerateInitInstance(const ::BesCursor*)
00355 {
00356 return GenerateInitInstanceLocal((::BesCursor*)0);
00357 }
00358
00359 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesCursor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00360 }
00361
00362 namespace ROOT {
00363 void BesEventHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
00364 static void *new_BesEventHeader(void *p = 0);
00365 static void *newArray_BesEventHeader(Long_t size, void *p);
00366 static void delete_BesEventHeader(void *p);
00367 static void deleteArray_BesEventHeader(void *p);
00368 static void destruct_BesEventHeader(void *p);
00369
00370
00371 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesEventHeader*)
00372 {
00373 ::BesEventHeader *ptr = 0;
00374 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesEventHeader >(0);
00375 static ::ROOT::TGenericClassInfo
00376 instance("BesEventHeader", ::BesEventHeader::Class_Version(), "./../BesVisLib/BesEventHeader.h", 14,
00377 typeid(::BesEventHeader), DefineBehavior(ptr, ptr),
00378 &::BesEventHeader::Dictionary, isa_proxy, 4,
00379 sizeof(::BesEventHeader) );
00380 instance.SetNew(&new_BesEventHeader);
00381 instance.SetNewArray(&newArray_BesEventHeader);
00382 instance.SetDelete(&delete_BesEventHeader);
00383 instance.SetDeleteArray(&deleteArray_BesEventHeader);
00384 instance.SetDestructor(&destruct_BesEventHeader);
00385 return &instance;
00386 }
00387 TGenericClassInfo *GenerateInitInstance(const ::BesEventHeader*)
00388 {
00389 return GenerateInitInstanceLocal((::BesEventHeader*)0);
00390 }
00391
00392 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesEventHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00393 }
00394
00395 namespace ROOT {
00396 void BesView_ShowMembers(void *obj, TMemberInspector &R__insp);
00397 static void *new_BesView(void *p = 0);
00398 static void *newArray_BesView(Long_t size, void *p);
00399 static void delete_BesView(void *p);
00400 static void deleteArray_BesView(void *p);
00401 static void destruct_BesView(void *p);
00402
00403
00404 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesView*)
00405 {
00406 ::BesView *ptr = 0;
00407 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesView >(0);
00408 static ::ROOT::TGenericClassInfo
00409 instance("BesView", ::BesView::Class_Version(), "./../BesVisLib/BesView.h", 26,
00410 typeid(::BesView), DefineBehavior(ptr, ptr),
00411 &::BesView::Dictionary, isa_proxy, 4,
00412 sizeof(::BesView) );
00413 instance.SetNew(&new_BesView);
00414 instance.SetNewArray(&newArray_BesView);
00415 instance.SetDelete(&delete_BesView);
00416 instance.SetDeleteArray(&deleteArray_BesView);
00417 instance.SetDestructor(&destruct_BesView);
00418 return &instance;
00419 }
00420 TGenericClassInfo *GenerateInitInstance(const ::BesView*)
00421 {
00422 return GenerateInitInstanceLocal((::BesView*)0);
00423 }
00424
00425 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesView*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00426 }
00427
00428 namespace ROOT {
00429 void BesMarker2D_ShowMembers(void *obj, TMemberInspector &R__insp);
00430 static void *new_BesMarker2D(void *p = 0);
00431 static void *newArray_BesMarker2D(Long_t size, void *p);
00432 static void delete_BesMarker2D(void *p);
00433 static void deleteArray_BesMarker2D(void *p);
00434 static void destruct_BesMarker2D(void *p);
00435
00436
00437 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesMarker2D*)
00438 {
00439 ::BesMarker2D *ptr = 0;
00440 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesMarker2D >(0);
00441 static ::ROOT::TGenericClassInfo
00442 instance("BesMarker2D", ::BesMarker2D::Class_Version(), "./../BesVisLib/BesMarker2D.h", 13,
00443 typeid(::BesMarker2D), DefineBehavior(ptr, ptr),
00444 &::BesMarker2D::Dictionary, isa_proxy, 4,
00445 sizeof(::BesMarker2D) );
00446 instance.SetNew(&new_BesMarker2D);
00447 instance.SetNewArray(&newArray_BesMarker2D);
00448 instance.SetDelete(&delete_BesMarker2D);
00449 instance.SetDeleteArray(&deleteArray_BesMarker2D);
00450 instance.SetDestructor(&destruct_BesMarker2D);
00451 return &instance;
00452 }
00453 TGenericClassInfo *GenerateInitInstance(const ::BesMarker2D*)
00454 {
00455 return GenerateInitInstanceLocal((::BesMarker2D*)0);
00456 }
00457
00458 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesMarker2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00459 }
00460
00461 namespace ROOT {
00462 void BesPaveText_ShowMembers(void *obj, TMemberInspector &R__insp);
00463 static void *new_BesPaveText(void *p = 0);
00464 static void *newArray_BesPaveText(Long_t size, void *p);
00465 static void delete_BesPaveText(void *p);
00466 static void deleteArray_BesPaveText(void *p);
00467 static void destruct_BesPaveText(void *p);
00468
00469
00470 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesPaveText*)
00471 {
00472 ::BesPaveText *ptr = 0;
00473 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesPaveText >(0);
00474 static ::ROOT::TGenericClassInfo
00475 instance("BesPaveText", ::BesPaveText::Class_Version(), "./../BesVisLib/BesPaveText.h", 11,
00476 typeid(::BesPaveText), DefineBehavior(ptr, ptr),
00477 &::BesPaveText::Dictionary, isa_proxy, 4,
00478 sizeof(::BesPaveText) );
00479 instance.SetNew(&new_BesPaveText);
00480 instance.SetNewArray(&newArray_BesPaveText);
00481 instance.SetDelete(&delete_BesPaveText);
00482 instance.SetDeleteArray(&deleteArray_BesPaveText);
00483 instance.SetDestructor(&destruct_BesPaveText);
00484 return &instance;
00485 }
00486 TGenericClassInfo *GenerateInitInstance(const ::BesPaveText*)
00487 {
00488 return GenerateInitInstanceLocal((::BesPaveText*)0);
00489 }
00490
00491 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesPaveText*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00492 }
00493
00494 namespace ROOT {
00495 void BesGeoTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
00496 static void *new_BesGeoTrack(void *p = 0);
00497 static void *newArray_BesGeoTrack(Long_t size, void *p);
00498 static void delete_BesGeoTrack(void *p);
00499 static void deleteArray_BesGeoTrack(void *p);
00500 static void destruct_BesGeoTrack(void *p);
00501
00502
00503 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGeoTrack*)
00504 {
00505 ::BesGeoTrack *ptr = 0;
00506 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGeoTrack >(0);
00507 static ::ROOT::TGenericClassInfo
00508 instance("BesGeoTrack", ::BesGeoTrack::Class_Version(), "./../BesVisLib/BesGeoTrack.h", 12,
00509 typeid(::BesGeoTrack), DefineBehavior(ptr, ptr),
00510 &::BesGeoTrack::Dictionary, isa_proxy, 4,
00511 sizeof(::BesGeoTrack) );
00512 instance.SetNew(&new_BesGeoTrack);
00513 instance.SetNewArray(&newArray_BesGeoTrack);
00514 instance.SetDelete(&delete_BesGeoTrack);
00515 instance.SetDeleteArray(&deleteArray_BesGeoTrack);
00516 instance.SetDestructor(&destruct_BesGeoTrack);
00517 return &instance;
00518 }
00519 TGenericClassInfo *GenerateInitInstance(const ::BesGeoTrack*)
00520 {
00521 return GenerateInitInstanceLocal((::BesGeoTrack*)0);
00522 }
00523
00524 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00525 }
00526
00527 namespace ROOT {
00528 void BesEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
00529 static void *new_BesEvent(void *p = 0);
00530 static void *newArray_BesEvent(Long_t size, void *p);
00531 static void delete_BesEvent(void *p);
00532 static void deleteArray_BesEvent(void *p);
00533 static void destruct_BesEvent(void *p);
00534
00535
00536 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesEvent*)
00537 {
00538 ::BesEvent *ptr = 0;
00539 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesEvent >(0);
00540 static ::ROOT::TGenericClassInfo
00541 instance("BesEvent", ::BesEvent::Class_Version(), "./../BesVisLib/BesEvent.h", 23,
00542 typeid(::BesEvent), DefineBehavior(ptr, ptr),
00543 &::BesEvent::Dictionary, isa_proxy, 4,
00544 sizeof(::BesEvent) );
00545 instance.SetNew(&new_BesEvent);
00546 instance.SetNewArray(&newArray_BesEvent);
00547 instance.SetDelete(&delete_BesEvent);
00548 instance.SetDeleteArray(&deleteArray_BesEvent);
00549 instance.SetDestructor(&destruct_BesEvent);
00550 return &instance;
00551 }
00552 TGenericClassInfo *GenerateInitInstance(const ::BesEvent*)
00553 {
00554 return GenerateInitInstanceLocal((::BesEvent*)0);
00555 }
00556
00557 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00558 }
00559
00560 namespace ROOT {
00561 void SubDetectorROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
00562 static void SubDetectorROOTGeo_Dictionary();
00563 static void *new_SubDetectorROOTGeo(void *p = 0);
00564 static void *newArray_SubDetectorROOTGeo(Long_t size, void *p);
00565 static void delete_SubDetectorROOTGeo(void *p);
00566 static void deleteArray_SubDetectorROOTGeo(void *p);
00567 static void destruct_SubDetectorROOTGeo(void *p);
00568
00569
00570 static TGenericClassInfo *GenerateInitInstanceLocal(const ::SubDetectorROOTGeo*)
00571 {
00572
00573 R__ASSERT(sizeof(::SubDetectorROOTGeo) == sizeof(::ROOT::Shadow::SubDetectorROOTGeo));
00574 ::SubDetectorROOTGeo *ptr = 0;
00575 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::SubDetectorROOTGeo),0);
00576 static ::ROOT::TGenericClassInfo
00577 instance("SubDetectorROOTGeo", "./../BesVisLib/SubDetectorROOTGeo.h", 30,
00578 typeid(::SubDetectorROOTGeo), DefineBehavior(ptr, ptr),
00579 &SubDetectorROOTGeo_ShowMembers, &SubDetectorROOTGeo_Dictionary, isa_proxy, 4,
00580 sizeof(::SubDetectorROOTGeo) );
00581 instance.SetNew(&new_SubDetectorROOTGeo);
00582 instance.SetNewArray(&newArray_SubDetectorROOTGeo);
00583 instance.SetDelete(&delete_SubDetectorROOTGeo);
00584 instance.SetDeleteArray(&deleteArray_SubDetectorROOTGeo);
00585 instance.SetDestructor(&destruct_SubDetectorROOTGeo);
00586 return &instance;
00587 }
00588 TGenericClassInfo *GenerateInitInstance(const ::SubDetectorROOTGeo*)
00589 {
00590 return GenerateInitInstanceLocal((::SubDetectorROOTGeo*)0);
00591 }
00592
00593 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00594
00595
00596 static void SubDetectorROOTGeo_Dictionary() {
00597 ::ROOT::GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0)->GetClass();
00598 }
00599
00600 }
00601
00602 namespace ROOT {
00603 void BesPolygon2D_ShowMembers(void *obj, TMemberInspector &R__insp);
00604 static void *new_BesPolygon2D(void *p = 0);
00605 static void *newArray_BesPolygon2D(Long_t size, void *p);
00606 static void delete_BesPolygon2D(void *p);
00607 static void deleteArray_BesPolygon2D(void *p);
00608 static void destruct_BesPolygon2D(void *p);
00609
00610
00611 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesPolygon2D*)
00612 {
00613 ::BesPolygon2D *ptr = 0;
00614 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesPolygon2D >(0);
00615 static ::ROOT::TGenericClassInfo
00616 instance("BesPolygon2D", ::BesPolygon2D::Class_Version(), "./../BesVisLib/BesPolygon2D.h", 27,
00617 typeid(::BesPolygon2D), DefineBehavior(ptr, ptr),
00618 &::BesPolygon2D::Dictionary, isa_proxy, 4,
00619 sizeof(::BesPolygon2D) );
00620 instance.SetNew(&new_BesPolygon2D);
00621 instance.SetNewArray(&newArray_BesPolygon2D);
00622 instance.SetDelete(&delete_BesPolygon2D);
00623 instance.SetDeleteArray(&deleteArray_BesPolygon2D);
00624 instance.SetDestructor(&destruct_BesPolygon2D);
00625 return &instance;
00626 }
00627 TGenericClassInfo *GenerateInitInstance(const ::BesPolygon2D*)
00628 {
00629 return GenerateInitInstanceLocal((::BesPolygon2D*)0);
00630 }
00631
00632 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00633 }
00634
00635 namespace ROOT {
00636 void Mdc2DWire_ShowMembers(void *obj, TMemberInspector &R__insp);
00637 static void *new_Mdc2DWire(void *p = 0);
00638 static void *newArray_Mdc2DWire(Long_t size, void *p);
00639 static void delete_Mdc2DWire(void *p);
00640 static void deleteArray_Mdc2DWire(void *p);
00641 static void destruct_Mdc2DWire(void *p);
00642
00643
00644 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Mdc2DWire*)
00645 {
00646 ::Mdc2DWire *ptr = 0;
00647 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Mdc2DWire >(0);
00648 static ::ROOT::TGenericClassInfo
00649 instance("Mdc2DWire", ::Mdc2DWire::Class_Version(), "./../BesVisLib/Mdc2DWire.h", 18,
00650 typeid(::Mdc2DWire), DefineBehavior(ptr, ptr),
00651 &::Mdc2DWire::Dictionary, isa_proxy, 4,
00652 sizeof(::Mdc2DWire) );
00653 instance.SetNew(&new_Mdc2DWire);
00654 instance.SetNewArray(&newArray_Mdc2DWire);
00655 instance.SetDelete(&delete_Mdc2DWire);
00656 instance.SetDeleteArray(&deleteArray_Mdc2DWire);
00657 instance.SetDestructor(&destruct_Mdc2DWire);
00658 return &instance;
00659 }
00660 TGenericClassInfo *GenerateInitInstance(const ::Mdc2DWire*)
00661 {
00662 return GenerateInitInstanceLocal((::Mdc2DWire*)0);
00663 }
00664
00665 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00666 }
00667
00668 namespace ROOT {
00669 void MdcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
00670 static void MdcROOTGeo_Dictionary();
00671 static void *new_MdcROOTGeo(void *p = 0);
00672 static void *newArray_MdcROOTGeo(Long_t size, void *p);
00673 static void delete_MdcROOTGeo(void *p);
00674 static void deleteArray_MdcROOTGeo(void *p);
00675 static void destruct_MdcROOTGeo(void *p);
00676
00677
00678 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MdcROOTGeo*)
00679 {
00680
00681 R__ASSERT(sizeof(::MdcROOTGeo) == sizeof(::ROOT::Shadow::MdcROOTGeo));
00682 ::MdcROOTGeo *ptr = 0;
00683 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MdcROOTGeo),0);
00684 static ::ROOT::TGenericClassInfo
00685 instance("MdcROOTGeo", "./../BesVisLib/MdcROOTGeo.h", 32,
00686 typeid(::MdcROOTGeo), DefineBehavior(ptr, ptr),
00687 &MdcROOTGeo_ShowMembers, &MdcROOTGeo_Dictionary, isa_proxy, 4,
00688 sizeof(::MdcROOTGeo) );
00689 instance.SetNew(&new_MdcROOTGeo);
00690 instance.SetNewArray(&newArray_MdcROOTGeo);
00691 instance.SetDelete(&delete_MdcROOTGeo);
00692 instance.SetDeleteArray(&deleteArray_MdcROOTGeo);
00693 instance.SetDestructor(&destruct_MdcROOTGeo);
00694 return &instance;
00695 }
00696 TGenericClassInfo *GenerateInitInstance(const ::MdcROOTGeo*)
00697 {
00698 return GenerateInitInstanceLocal((::MdcROOTGeo*)0);
00699 }
00700
00701 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00702
00703
00704 static void MdcROOTGeo_Dictionary() {
00705 ::ROOT::GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0)->GetClass();
00706 }
00707
00708 }
00709
00710 namespace ROOT {
00711 void Tof2DScin_ShowMembers(void *obj, TMemberInspector &R__insp);
00712 static void *new_Tof2DScin(void *p = 0);
00713 static void *newArray_Tof2DScin(Long_t size, void *p);
00714 static void delete_Tof2DScin(void *p);
00715 static void deleteArray_Tof2DScin(void *p);
00716 static void destruct_Tof2DScin(void *p);
00717
00718
00719 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Tof2DScin*)
00720 {
00721 ::Tof2DScin *ptr = 0;
00722 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Tof2DScin >(0);
00723 static ::ROOT::TGenericClassInfo
00724 instance("Tof2DScin", ::Tof2DScin::Class_Version(), "./../BesVisLib/Tof2DScin.h", 19,
00725 typeid(::Tof2DScin), DefineBehavior(ptr, ptr),
00726 &::Tof2DScin::Dictionary, isa_proxy, 4,
00727 sizeof(::Tof2DScin) );
00728 instance.SetNew(&new_Tof2DScin);
00729 instance.SetNewArray(&newArray_Tof2DScin);
00730 instance.SetDelete(&delete_Tof2DScin);
00731 instance.SetDeleteArray(&deleteArray_Tof2DScin);
00732 instance.SetDestructor(&destruct_Tof2DScin);
00733 return &instance;
00734 }
00735 TGenericClassInfo *GenerateInitInstance(const ::Tof2DScin*)
00736 {
00737 return GenerateInitInstanceLocal((::Tof2DScin*)0);
00738 }
00739
00740 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Tof2DScin*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00741 }
00742
00743 namespace ROOT {
00744 void TofROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
00745 static void TofROOTGeo_Dictionary();
00746 static void *new_TofROOTGeo(void *p = 0);
00747 static void *newArray_TofROOTGeo(Long_t size, void *p);
00748 static void delete_TofROOTGeo(void *p);
00749 static void deleteArray_TofROOTGeo(void *p);
00750 static void destruct_TofROOTGeo(void *p);
00751
00752
00753 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TofROOTGeo*)
00754 {
00755
00756 R__ASSERT(sizeof(::TofROOTGeo) == sizeof(::ROOT::Shadow::TofROOTGeo));
00757 ::TofROOTGeo *ptr = 0;
00758 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TofROOTGeo),0);
00759 static ::ROOT::TGenericClassInfo
00760 instance("TofROOTGeo", "./../BesVisLib/TofROOTGeo.h", 30,
00761 typeid(::TofROOTGeo), DefineBehavior(ptr, ptr),
00762 &TofROOTGeo_ShowMembers, &TofROOTGeo_Dictionary, isa_proxy, 4,
00763 sizeof(::TofROOTGeo) );
00764 instance.SetNew(&new_TofROOTGeo);
00765 instance.SetNewArray(&newArray_TofROOTGeo);
00766 instance.SetDelete(&delete_TofROOTGeo);
00767 instance.SetDeleteArray(&deleteArray_TofROOTGeo);
00768 instance.SetDestructor(&destruct_TofROOTGeo);
00769 return &instance;
00770 }
00771 TGenericClassInfo *GenerateInitInstance(const ::TofROOTGeo*)
00772 {
00773 return GenerateInitInstanceLocal((::TofROOTGeo*)0);
00774 }
00775
00776 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00777
00778
00779 static void TofROOTGeo_Dictionary() {
00780 ::ROOT::GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0)->GetClass();
00781 }
00782
00783 }
00784
00785 namespace ROOT {
00786 void Emc2DCrystal_ShowMembers(void *obj, TMemberInspector &R__insp);
00787 static void *new_Emc2DCrystal(void *p = 0);
00788 static void *newArray_Emc2DCrystal(Long_t size, void *p);
00789 static void delete_Emc2DCrystal(void *p);
00790 static void deleteArray_Emc2DCrystal(void *p);
00791 static void destruct_Emc2DCrystal(void *p);
00792
00793
00794 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Emc2DCrystal*)
00795 {
00796 ::Emc2DCrystal *ptr = 0;
00797 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Emc2DCrystal >(0);
00798 static ::ROOT::TGenericClassInfo
00799 instance("Emc2DCrystal", ::Emc2DCrystal::Class_Version(), "./../BesVisLib/Emc2DCrystal.h", 19,
00800 typeid(::Emc2DCrystal), DefineBehavior(ptr, ptr),
00801 &::Emc2DCrystal::Dictionary, isa_proxy, 4,
00802 sizeof(::Emc2DCrystal) );
00803 instance.SetNew(&new_Emc2DCrystal);
00804 instance.SetNewArray(&newArray_Emc2DCrystal);
00805 instance.SetDelete(&delete_Emc2DCrystal);
00806 instance.SetDeleteArray(&deleteArray_Emc2DCrystal);
00807 instance.SetDestructor(&destruct_Emc2DCrystal);
00808 return &instance;
00809 }
00810 TGenericClassInfo *GenerateInitInstance(const ::Emc2DCrystal*)
00811 {
00812 return GenerateInitInstanceLocal((::Emc2DCrystal*)0);
00813 }
00814
00815 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00816 }
00817
00818 namespace ROOT {
00819 void EmcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
00820 static void EmcROOTGeo_Dictionary();
00821 static void *new_EmcROOTGeo(void *p = 0);
00822 static void *newArray_EmcROOTGeo(Long_t size, void *p);
00823 static void delete_EmcROOTGeo(void *p);
00824 static void deleteArray_EmcROOTGeo(void *p);
00825 static void destruct_EmcROOTGeo(void *p);
00826
00827
00828 static TGenericClassInfo *GenerateInitInstanceLocal(const ::EmcROOTGeo*)
00829 {
00830
00831 R__ASSERT(sizeof(::EmcROOTGeo) == sizeof(::ROOT::Shadow::EmcROOTGeo));
00832 ::EmcROOTGeo *ptr = 0;
00833 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::EmcROOTGeo),0);
00834 static ::ROOT::TGenericClassInfo
00835 instance("EmcROOTGeo", "./../BesVisLib/EmcROOTGeo.h", 33,
00836 typeid(::EmcROOTGeo), DefineBehavior(ptr, ptr),
00837 &EmcROOTGeo_ShowMembers, &EmcROOTGeo_Dictionary, isa_proxy, 4,
00838 sizeof(::EmcROOTGeo) );
00839 instance.SetNew(&new_EmcROOTGeo);
00840 instance.SetNewArray(&newArray_EmcROOTGeo);
00841 instance.SetDelete(&delete_EmcROOTGeo);
00842 instance.SetDeleteArray(&deleteArray_EmcROOTGeo);
00843 instance.SetDestructor(&destruct_EmcROOTGeo);
00844 return &instance;
00845 }
00846 TGenericClassInfo *GenerateInitInstance(const ::EmcROOTGeo*)
00847 {
00848 return GenerateInitInstanceLocal((::EmcROOTGeo*)0);
00849 }
00850
00851 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00852
00853
00854 static void EmcROOTGeo_Dictionary() {
00855 ::ROOT::GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0)->GetClass();
00856 }
00857
00858 }
00859
00860 namespace ROOT {
00861 void Muc2DStrip_ShowMembers(void *obj, TMemberInspector &R__insp);
00862 static void *new_Muc2DStrip(void *p = 0);
00863 static void *newArray_Muc2DStrip(Long_t size, void *p);
00864 static void delete_Muc2DStrip(void *p);
00865 static void deleteArray_Muc2DStrip(void *p);
00866 static void destruct_Muc2DStrip(void *p);
00867
00868
00869 static TGenericClassInfo *GenerateInitInstanceLocal(const ::Muc2DStrip*)
00870 {
00871 ::Muc2DStrip *ptr = 0;
00872 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Muc2DStrip >(0);
00873 static ::ROOT::TGenericClassInfo
00874 instance("Muc2DStrip", ::Muc2DStrip::Class_Version(), "./../BesVisLib/Muc2DStrip.h", 19,
00875 typeid(::Muc2DStrip), DefineBehavior(ptr, ptr),
00876 &::Muc2DStrip::Dictionary, isa_proxy, 4,
00877 sizeof(::Muc2DStrip) );
00878 instance.SetNew(&new_Muc2DStrip);
00879 instance.SetNewArray(&newArray_Muc2DStrip);
00880 instance.SetDelete(&delete_Muc2DStrip);
00881 instance.SetDeleteArray(&deleteArray_Muc2DStrip);
00882 instance.SetDestructor(&destruct_Muc2DStrip);
00883 return &instance;
00884 }
00885 TGenericClassInfo *GenerateInitInstance(const ::Muc2DStrip*)
00886 {
00887 return GenerateInitInstanceLocal((::Muc2DStrip*)0);
00888 }
00889
00890 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00891 }
00892
00893 namespace ROOT {
00894 void MucROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp);
00895 static void MucROOTGeo_Dictionary();
00896 static void *new_MucROOTGeo(void *p = 0);
00897 static void *newArray_MucROOTGeo(Long_t size, void *p);
00898 static void delete_MucROOTGeo(void *p);
00899 static void deleteArray_MucROOTGeo(void *p);
00900 static void destruct_MucROOTGeo(void *p);
00901
00902
00903 static TGenericClassInfo *GenerateInitInstanceLocal(const ::MucROOTGeo*)
00904 {
00905
00906 R__ASSERT(sizeof(::MucROOTGeo) == sizeof(::ROOT::Shadow::MucROOTGeo));
00907 ::MucROOTGeo *ptr = 0;
00908 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MucROOTGeo),0);
00909 static ::ROOT::TGenericClassInfo
00910 instance("MucROOTGeo", "./../BesVisLib/MucROOTGeo.h", 31,
00911 typeid(::MucROOTGeo), DefineBehavior(ptr, ptr),
00912 &MucROOTGeo_ShowMembers, &MucROOTGeo_Dictionary, isa_proxy, 4,
00913 sizeof(::MucROOTGeo) );
00914 instance.SetNew(&new_MucROOTGeo);
00915 instance.SetNewArray(&newArray_MucROOTGeo);
00916 instance.SetDelete(&delete_MucROOTGeo);
00917 instance.SetDeleteArray(&deleteArray_MucROOTGeo);
00918 instance.SetDestructor(&destruct_MucROOTGeo);
00919 return &instance;
00920 }
00921 TGenericClassInfo *GenerateInitInstance(const ::MucROOTGeo*)
00922 {
00923 return GenerateInitInstanceLocal((::MucROOTGeo*)0);
00924 }
00925
00926 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00927
00928
00929 static void MucROOTGeo_Dictionary() {
00930 ::ROOT::GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0)->GetClass();
00931 }
00932
00933 }
00934
00935 namespace ROOT {
00936 void BesGeometry_ShowMembers(void *obj, TMemberInspector &R__insp);
00937 static void *new_BesGeometry(void *p = 0);
00938 static void *newArray_BesGeometry(Long_t size, void *p);
00939 static void delete_BesGeometry(void *p);
00940 static void deleteArray_BesGeometry(void *p);
00941 static void destruct_BesGeometry(void *p);
00942
00943
00944 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGeometry*)
00945 {
00946 ::BesGeometry *ptr = 0;
00947 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGeometry >(0);
00948 static ::ROOT::TGenericClassInfo
00949 instance("BesGeometry", ::BesGeometry::Class_Version(), "./../BesVisLib/BesGeometry.h", 18,
00950 typeid(::BesGeometry), DefineBehavior(ptr, ptr),
00951 &::BesGeometry::Dictionary, isa_proxy, 4,
00952 sizeof(::BesGeometry) );
00953 instance.SetNew(&new_BesGeometry);
00954 instance.SetNewArray(&newArray_BesGeometry);
00955 instance.SetDelete(&delete_BesGeometry);
00956 instance.SetDeleteArray(&deleteArray_BesGeometry);
00957 instance.SetDestructor(&destruct_BesGeometry);
00958 return &instance;
00959 }
00960 TGenericClassInfo *GenerateInitInstance(const ::BesGeometry*)
00961 {
00962 return GenerateInitInstanceLocal((::BesGeometry*)0);
00963 }
00964
00965 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGeometry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00966 }
00967
00968 namespace ROOT {
00969 void BesGMenuTitle_ShowMembers(void *obj, TMemberInspector &R__insp);
00970 static void *new_BesGMenuTitle(void *p = 0);
00971 static void *newArray_BesGMenuTitle(Long_t size, void *p);
00972 static void delete_BesGMenuTitle(void *p);
00973 static void deleteArray_BesGMenuTitle(void *p);
00974 static void destruct_BesGMenuTitle(void *p);
00975
00976
00977 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGMenuTitle*)
00978 {
00979 ::BesGMenuTitle *ptr = 0;
00980 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGMenuTitle >(0);
00981 static ::ROOT::TGenericClassInfo
00982 instance("BesGMenuTitle", ::BesGMenuTitle::Class_Version(), "./../BesVisLib/BesGMenuTitle.h", 12,
00983 typeid(::BesGMenuTitle), DefineBehavior(ptr, ptr),
00984 &::BesGMenuTitle::Dictionary, isa_proxy, 4,
00985 sizeof(::BesGMenuTitle) );
00986 instance.SetNew(&new_BesGMenuTitle);
00987 instance.SetNewArray(&newArray_BesGMenuTitle);
00988 instance.SetDelete(&delete_BesGMenuTitle);
00989 instance.SetDeleteArray(&deleteArray_BesGMenuTitle);
00990 instance.SetDestructor(&destruct_BesGMenuTitle);
00991 return &instance;
00992 }
00993 TGenericClassInfo *GenerateInitInstance(const ::BesGMenuTitle*)
00994 {
00995 return GenerateInitInstanceLocal((::BesGMenuTitle*)0);
00996 }
00997
00998 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00999 }
01000
01001 namespace ROOT {
01002 void BesGMenuBar_ShowMembers(void *obj, TMemberInspector &R__insp);
01003 static void *new_BesGMenuBar(void *p = 0);
01004 static void *newArray_BesGMenuBar(Long_t size, void *p);
01005 static void delete_BesGMenuBar(void *p);
01006 static void deleteArray_BesGMenuBar(void *p);
01007 static void destruct_BesGMenuBar(void *p);
01008
01009
01010 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGMenuBar*)
01011 {
01012 ::BesGMenuBar *ptr = 0;
01013 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGMenuBar >(0);
01014 static ::ROOT::TGenericClassInfo
01015 instance("BesGMenuBar", ::BesGMenuBar::Class_Version(), "./../BesVisLib/BesGMenuBar.h", 8,
01016 typeid(::BesGMenuBar), DefineBehavior(ptr, ptr),
01017 &::BesGMenuBar::Dictionary, isa_proxy, 4,
01018 sizeof(::BesGMenuBar) );
01019 instance.SetNew(&new_BesGMenuBar);
01020 instance.SetNewArray(&newArray_BesGMenuBar);
01021 instance.SetDelete(&delete_BesGMenuBar);
01022 instance.SetDeleteArray(&deleteArray_BesGMenuBar);
01023 instance.SetDestructor(&destruct_BesGMenuBar);
01024 return &instance;
01025 }
01026 TGenericClassInfo *GenerateInitInstance(const ::BesGMenuBar*)
01027 {
01028 return GenerateInitInstanceLocal((::BesGMenuBar*)0);
01029 }
01030
01031 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01032 }
01033
01034 namespace ROOT {
01035 void BesGPictureButton_ShowMembers(void *obj, TMemberInspector &R__insp);
01036 static void *new_BesGPictureButton(void *p = 0);
01037 static void *newArray_BesGPictureButton(Long_t size, void *p);
01038 static void delete_BesGPictureButton(void *p);
01039 static void deleteArray_BesGPictureButton(void *p);
01040 static void destruct_BesGPictureButton(void *p);
01041
01042
01043 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesGPictureButton*)
01044 {
01045 ::BesGPictureButton *ptr = 0;
01046 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesGPictureButton >(0);
01047 static ::ROOT::TGenericClassInfo
01048 instance("BesGPictureButton", ::BesGPictureButton::Class_Version(), "./../BesVisLib/BesGPictureButton.h", 7,
01049 typeid(::BesGPictureButton), DefineBehavior(ptr, ptr),
01050 &::BesGPictureButton::Dictionary, isa_proxy, 4,
01051 sizeof(::BesGPictureButton) );
01052 instance.SetNew(&new_BesGPictureButton);
01053 instance.SetNewArray(&newArray_BesGPictureButton);
01054 instance.SetDelete(&delete_BesGPictureButton);
01055 instance.SetDeleteArray(&deleteArray_BesGPictureButton);
01056 instance.SetDestructor(&destruct_BesGPictureButton);
01057 return &instance;
01058 }
01059 TGenericClassInfo *GenerateInitInstance(const ::BesGPictureButton*)
01060 {
01061 return GenerateInitInstanceLocal((::BesGPictureButton*)0);
01062 }
01063
01064 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01065 }
01066
01067 namespace ROOT {
01068 void BesHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
01069 static void *new_BesHeader(void *p = 0);
01070 static void *newArray_BesHeader(Long_t size, void *p);
01071 static void delete_BesHeader(void *p);
01072 static void deleteArray_BesHeader(void *p);
01073 static void destruct_BesHeader(void *p);
01074
01075
01076 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesHeader*)
01077 {
01078 ::BesHeader *ptr = 0;
01079 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesHeader >(0);
01080 static ::ROOT::TGenericClassInfo
01081 instance("BesHeader", ::BesHeader::Class_Version(), "./../BesVisLib/BesHeader.h", 12,
01082 typeid(::BesHeader), DefineBehavior(ptr, ptr),
01083 &::BesHeader::Dictionary, isa_proxy, 4,
01084 sizeof(::BesHeader) );
01085 instance.SetNew(&new_BesHeader);
01086 instance.SetNewArray(&newArray_BesHeader);
01087 instance.SetDelete(&delete_BesHeader);
01088 instance.SetDeleteArray(&deleteArray_BesHeader);
01089 instance.SetDestructor(&destruct_BesHeader);
01090 return &instance;
01091 }
01092 TGenericClassInfo *GenerateInitInstance(const ::BesHeader*)
01093 {
01094 return GenerateInitInstanceLocal((::BesHeader*)0);
01095 }
01096
01097 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01098 }
01099
01100 namespace ROOT {
01101 void BesVisDisplay_ShowMembers(void *obj, TMemberInspector &R__insp);
01102 static void *new_BesVisDisplay(void *p = 0);
01103 static void *newArray_BesVisDisplay(Long_t size, void *p);
01104 static void delete_BesVisDisplay(void *p);
01105 static void deleteArray_BesVisDisplay(void *p);
01106 static void destruct_BesVisDisplay(void *p);
01107
01108
01109 static TGenericClassInfo *GenerateInitInstanceLocal(const ::BesVisDisplay*)
01110 {
01111 ::BesVisDisplay *ptr = 0;
01112 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::BesVisDisplay >(0);
01113 static ::ROOT::TGenericClassInfo
01114 instance("BesVisDisplay", ::BesVisDisplay::Class_Version(), "./../BesVisLib/BesVisDisplay.h", 37,
01115 typeid(::BesVisDisplay), DefineBehavior(ptr, ptr),
01116 &::BesVisDisplay::Dictionary, isa_proxy, 4,
01117 sizeof(::BesVisDisplay) );
01118 instance.SetNew(&new_BesVisDisplay);
01119 instance.SetNewArray(&newArray_BesVisDisplay);
01120 instance.SetDelete(&delete_BesVisDisplay);
01121 instance.SetDeleteArray(&deleteArray_BesVisDisplay);
01122 instance.SetDestructor(&destruct_BesVisDisplay);
01123 return &instance;
01124 }
01125 TGenericClassInfo *GenerateInitInstance(const ::BesVisDisplay*)
01126 {
01127 return GenerateInitInstanceLocal((::BesVisDisplay*)0);
01128 }
01129
01130 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01131 }
01132
01133 namespace ROOT {
01134 void ZHelix_ShowMembers(void *obj, TMemberInspector &R__insp);
01135 static void *new_ZHelix(void *p = 0);
01136 static void *newArray_ZHelix(Long_t size, void *p);
01137 static void delete_ZHelix(void *p);
01138 static void deleteArray_ZHelix(void *p);
01139 static void destruct_ZHelix(void *p);
01140 static Long64_t merge_ZHelix(void *obj, TCollection *coll,TFileMergeInfo *info);
01141
01142
01143 static TGenericClassInfo *GenerateInitInstanceLocal(const ::ZHelix*)
01144 {
01145 ::ZHelix *ptr = 0;
01146 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ZHelix >(0);
01147 static ::ROOT::TGenericClassInfo
01148 instance("ZHelix", ::ZHelix::Class_Version(), "./../BesVisLib/ZHelix.h", 42,
01149 typeid(::ZHelix), DefineBehavior(ptr, ptr),
01150 &::ZHelix::Dictionary, isa_proxy, 4,
01151 sizeof(::ZHelix) );
01152 instance.SetNew(&new_ZHelix);
01153 instance.SetNewArray(&newArray_ZHelix);
01154 instance.SetDelete(&delete_ZHelix);
01155 instance.SetDeleteArray(&deleteArray_ZHelix);
01156 instance.SetDestructor(&destruct_ZHelix);
01157 instance.SetMerge(&merge_ZHelix);
01158 return &instance;
01159 }
01160 TGenericClassInfo *GenerateInitInstance(const ::ZHelix*)
01161 {
01162 return GenerateInitInstanceLocal((::ZHelix*)0);
01163 }
01164
01165 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ZHelix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01166 }
01167
01168 namespace ROOT {
01169 void vector3_ShowMembers(void *obj, TMemberInspector &R__insp);
01170 static void vector3_Dictionary();
01171 static void *new_vector3(void *p = 0);
01172 static void *newArray_vector3(Long_t size, void *p);
01173 static void delete_vector3(void *p);
01174 static void deleteArray_vector3(void *p);
01175 static void destruct_vector3(void *p);
01176
01177
01178 static TGenericClassInfo *GenerateInitInstanceLocal(const ::vector3*)
01179 {
01180
01181 R__ASSERT(sizeof(::vector3) == sizeof(::ROOT::Shadow::vector3));
01182 ::vector3 *ptr = 0;
01183 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::vector3),0);
01184 static ::ROOT::TGenericClassInfo
01185 instance("vector3", "./../BesVisLib/vector3.h", 5,
01186 typeid(::vector3), DefineBehavior(ptr, ptr),
01187 &vector3_ShowMembers, &vector3_Dictionary, isa_proxy, 4,
01188 sizeof(::vector3) );
01189 instance.SetNew(&new_vector3);
01190 instance.SetNewArray(&newArray_vector3);
01191 instance.SetDelete(&delete_vector3);
01192 instance.SetDeleteArray(&deleteArray_vector3);
01193 instance.SetDestructor(&destruct_vector3);
01194 return &instance;
01195 }
01196 TGenericClassInfo *GenerateInitInstance(const ::vector3*)
01197 {
01198 return GenerateInitInstanceLocal((::vector3*)0);
01199 }
01200
01201 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::vector3*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01202
01203
01204 static void vector3_Dictionary() {
01205 ::ROOT::GenerateInitInstanceLocal((const ::vector3*)0x0)->GetClass();
01206 }
01207
01208 }
01209
01210
01211 TClass *BesStatus::fgIsA = 0;
01212
01213
01214 const char *BesStatus::Class_Name()
01215 {
01216 return "BesStatus";
01217 }
01218
01219
01220 const char *BesStatus::ImplFileName()
01221 {
01222 return ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetImplFileName();
01223 }
01224
01225
01226 int BesStatus::ImplFileLine()
01227 {
01228 return ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetImplFileLine();
01229 }
01230
01231
01232 void BesStatus::Dictionary()
01233 {
01234 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetClass();
01235 }
01236
01237
01238 TClass *BesStatus::Class()
01239 {
01240 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesStatus*)0x0)->GetClass();
01241 return fgIsA;
01242 }
01243
01244
01245 TClass *BesTView::fgIsA = 0;
01246
01247
01248 const char *BesTView::Class_Name()
01249 {
01250 return "BesTView";
01251 }
01252
01253
01254 const char *BesTView::ImplFileName()
01255 {
01256 return ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetImplFileName();
01257 }
01258
01259
01260 int BesTView::ImplFileLine()
01261 {
01262 return ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetImplFileLine();
01263 }
01264
01265
01266 void BesTView::Dictionary()
01267 {
01268 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetClass();
01269 }
01270
01271
01272 TClass *BesTView::Class()
01273 {
01274 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesTView*)0x0)->GetClass();
01275 return fgIsA;
01276 }
01277
01278
01279 TClass *Bes2DView::fgIsA = 0;
01280
01281
01282 const char *Bes2DView::Class_Name()
01283 {
01284 return "Bes2DView";
01285 }
01286
01287
01288 const char *Bes2DView::ImplFileName()
01289 {
01290 return ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetImplFileName();
01291 }
01292
01293
01294 int Bes2DView::ImplFileLine()
01295 {
01296 return ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetImplFileLine();
01297 }
01298
01299
01300 void Bes2DView::Dictionary()
01301 {
01302 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetClass();
01303 }
01304
01305
01306 TClass *Bes2DView::Class()
01307 {
01308 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Bes2DView*)0x0)->GetClass();
01309 return fgIsA;
01310 }
01311
01312
01313 TClass *BesCircle2D::fgIsA = 0;
01314
01315
01316 const char *BesCircle2D::Class_Name()
01317 {
01318 return "BesCircle2D";
01319 }
01320
01321
01322 const char *BesCircle2D::ImplFileName()
01323 {
01324 return ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetImplFileName();
01325 }
01326
01327
01328 int BesCircle2D::ImplFileLine()
01329 {
01330 return ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetImplFileLine();
01331 }
01332
01333
01334 void BesCircle2D::Dictionary()
01335 {
01336 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetClass();
01337 }
01338
01339
01340 TClass *BesCircle2D::Class()
01341 {
01342 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCircle2D*)0x0)->GetClass();
01343 return fgIsA;
01344 }
01345
01346
01347 TClass *BesCursor::fgIsA = 0;
01348
01349
01350 const char *BesCursor::Class_Name()
01351 {
01352 return "BesCursor";
01353 }
01354
01355
01356 const char *BesCursor::ImplFileName()
01357 {
01358 return ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetImplFileName();
01359 }
01360
01361
01362 int BesCursor::ImplFileLine()
01363 {
01364 return ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetImplFileLine();
01365 }
01366
01367
01368 void BesCursor::Dictionary()
01369 {
01370 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetClass();
01371 }
01372
01373
01374 TClass *BesCursor::Class()
01375 {
01376 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesCursor*)0x0)->GetClass();
01377 return fgIsA;
01378 }
01379
01380
01381 TClass *BesEventHeader::fgIsA = 0;
01382
01383
01384 const char *BesEventHeader::Class_Name()
01385 {
01386 return "BesEventHeader";
01387 }
01388
01389
01390 const char *BesEventHeader::ImplFileName()
01391 {
01392 return ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetImplFileName();
01393 }
01394
01395
01396 int BesEventHeader::ImplFileLine()
01397 {
01398 return ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetImplFileLine();
01399 }
01400
01401
01402 void BesEventHeader::Dictionary()
01403 {
01404 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetClass();
01405 }
01406
01407
01408 TClass *BesEventHeader::Class()
01409 {
01410 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEventHeader*)0x0)->GetClass();
01411 return fgIsA;
01412 }
01413
01414
01415 TClass *BesView::fgIsA = 0;
01416
01417
01418 const char *BesView::Class_Name()
01419 {
01420 return "BesView";
01421 }
01422
01423
01424 const char *BesView::ImplFileName()
01425 {
01426 return ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetImplFileName();
01427 }
01428
01429
01430 int BesView::ImplFileLine()
01431 {
01432 return ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetImplFileLine();
01433 }
01434
01435
01436 void BesView::Dictionary()
01437 {
01438 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetClass();
01439 }
01440
01441
01442 TClass *BesView::Class()
01443 {
01444 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesView*)0x0)->GetClass();
01445 return fgIsA;
01446 }
01447
01448
01449 TClass *BesMarker2D::fgIsA = 0;
01450
01451
01452 const char *BesMarker2D::Class_Name()
01453 {
01454 return "BesMarker2D";
01455 }
01456
01457
01458 const char *BesMarker2D::ImplFileName()
01459 {
01460 return ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetImplFileName();
01461 }
01462
01463
01464 int BesMarker2D::ImplFileLine()
01465 {
01466 return ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetImplFileLine();
01467 }
01468
01469
01470 void BesMarker2D::Dictionary()
01471 {
01472 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetClass();
01473 }
01474
01475
01476 TClass *BesMarker2D::Class()
01477 {
01478 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesMarker2D*)0x0)->GetClass();
01479 return fgIsA;
01480 }
01481
01482
01483 TClass *BesPaveText::fgIsA = 0;
01484
01485
01486 const char *BesPaveText::Class_Name()
01487 {
01488 return "BesPaveText";
01489 }
01490
01491
01492 const char *BesPaveText::ImplFileName()
01493 {
01494 return ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetImplFileName();
01495 }
01496
01497
01498 int BesPaveText::ImplFileLine()
01499 {
01500 return ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetImplFileLine();
01501 }
01502
01503
01504 void BesPaveText::Dictionary()
01505 {
01506 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetClass();
01507 }
01508
01509
01510 TClass *BesPaveText::Class()
01511 {
01512 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPaveText*)0x0)->GetClass();
01513 return fgIsA;
01514 }
01515
01516
01517 TClass *BesGeoTrack::fgIsA = 0;
01518
01519
01520 const char *BesGeoTrack::Class_Name()
01521 {
01522 return "BesGeoTrack";
01523 }
01524
01525
01526 const char *BesGeoTrack::ImplFileName()
01527 {
01528 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetImplFileName();
01529 }
01530
01531
01532 int BesGeoTrack::ImplFileLine()
01533 {
01534 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetImplFileLine();
01535 }
01536
01537
01538 void BesGeoTrack::Dictionary()
01539 {
01540 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetClass();
01541 }
01542
01543
01544 TClass *BesGeoTrack::Class()
01545 {
01546 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeoTrack*)0x0)->GetClass();
01547 return fgIsA;
01548 }
01549
01550
01551 TClass *BesEvent::fgIsA = 0;
01552
01553
01554 const char *BesEvent::Class_Name()
01555 {
01556 return "BesEvent";
01557 }
01558
01559
01560 const char *BesEvent::ImplFileName()
01561 {
01562 return ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetImplFileName();
01563 }
01564
01565
01566 int BesEvent::ImplFileLine()
01567 {
01568 return ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetImplFileLine();
01569 }
01570
01571
01572 void BesEvent::Dictionary()
01573 {
01574 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetClass();
01575 }
01576
01577
01578 TClass *BesEvent::Class()
01579 {
01580 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesEvent*)0x0)->GetClass();
01581 return fgIsA;
01582 }
01583
01584
01585 TClass *BesPolygon2D::fgIsA = 0;
01586
01587
01588 const char *BesPolygon2D::Class_Name()
01589 {
01590 return "BesPolygon2D";
01591 }
01592
01593
01594 const char *BesPolygon2D::ImplFileName()
01595 {
01596 return ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetImplFileName();
01597 }
01598
01599
01600 int BesPolygon2D::ImplFileLine()
01601 {
01602 return ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetImplFileLine();
01603 }
01604
01605
01606 void BesPolygon2D::Dictionary()
01607 {
01608 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetClass();
01609 }
01610
01611
01612 TClass *BesPolygon2D::Class()
01613 {
01614 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesPolygon2D*)0x0)->GetClass();
01615 return fgIsA;
01616 }
01617
01618
01619 TClass *Mdc2DWire::fgIsA = 0;
01620
01621
01622 const char *Mdc2DWire::Class_Name()
01623 {
01624 return "Mdc2DWire";
01625 }
01626
01627
01628 const char *Mdc2DWire::ImplFileName()
01629 {
01630 return ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetImplFileName();
01631 }
01632
01633
01634 int Mdc2DWire::ImplFileLine()
01635 {
01636 return ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetImplFileLine();
01637 }
01638
01639
01640 void Mdc2DWire::Dictionary()
01641 {
01642 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetClass();
01643 }
01644
01645
01646 TClass *Mdc2DWire::Class()
01647 {
01648 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Mdc2DWire*)0x0)->GetClass();
01649 return fgIsA;
01650 }
01651
01652
01653 TClass *Tof2DScin::fgIsA = 0;
01654
01655
01656 const char *Tof2DScin::Class_Name()
01657 {
01658 return "Tof2DScin";
01659 }
01660
01661
01662 const char *Tof2DScin::ImplFileName()
01663 {
01664 return ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetImplFileName();
01665 }
01666
01667
01668 int Tof2DScin::ImplFileLine()
01669 {
01670 return ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetImplFileLine();
01671 }
01672
01673
01674 void Tof2DScin::Dictionary()
01675 {
01676 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetClass();
01677 }
01678
01679
01680 TClass *Tof2DScin::Class()
01681 {
01682 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Tof2DScin*)0x0)->GetClass();
01683 return fgIsA;
01684 }
01685
01686
01687 TClass *Emc2DCrystal::fgIsA = 0;
01688
01689
01690 const char *Emc2DCrystal::Class_Name()
01691 {
01692 return "Emc2DCrystal";
01693 }
01694
01695
01696 const char *Emc2DCrystal::ImplFileName()
01697 {
01698 return ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetImplFileName();
01699 }
01700
01701
01702 int Emc2DCrystal::ImplFileLine()
01703 {
01704 return ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetImplFileLine();
01705 }
01706
01707
01708 void Emc2DCrystal::Dictionary()
01709 {
01710 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetClass();
01711 }
01712
01713
01714 TClass *Emc2DCrystal::Class()
01715 {
01716 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Emc2DCrystal*)0x0)->GetClass();
01717 return fgIsA;
01718 }
01719
01720
01721 TClass *Muc2DStrip::fgIsA = 0;
01722
01723
01724 const char *Muc2DStrip::Class_Name()
01725 {
01726 return "Muc2DStrip";
01727 }
01728
01729
01730 const char *Muc2DStrip::ImplFileName()
01731 {
01732 return ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetImplFileName();
01733 }
01734
01735
01736 int Muc2DStrip::ImplFileLine()
01737 {
01738 return ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetImplFileLine();
01739 }
01740
01741
01742 void Muc2DStrip::Dictionary()
01743 {
01744 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetClass();
01745 }
01746
01747
01748 TClass *Muc2DStrip::Class()
01749 {
01750 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Muc2DStrip*)0x0)->GetClass();
01751 return fgIsA;
01752 }
01753
01754
01755 TClass *BesGeometry::fgIsA = 0;
01756
01757
01758 const char *BesGeometry::Class_Name()
01759 {
01760 return "BesGeometry";
01761 }
01762
01763
01764 const char *BesGeometry::ImplFileName()
01765 {
01766 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetImplFileName();
01767 }
01768
01769
01770 int BesGeometry::ImplFileLine()
01771 {
01772 return ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetImplFileLine();
01773 }
01774
01775
01776 void BesGeometry::Dictionary()
01777 {
01778 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetClass();
01779 }
01780
01781
01782 TClass *BesGeometry::Class()
01783 {
01784 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGeometry*)0x0)->GetClass();
01785 return fgIsA;
01786 }
01787
01788
01789 TClass *BesGMenuTitle::fgIsA = 0;
01790
01791
01792 const char *BesGMenuTitle::Class_Name()
01793 {
01794 return "BesGMenuTitle";
01795 }
01796
01797
01798 const char *BesGMenuTitle::ImplFileName()
01799 {
01800 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetImplFileName();
01801 }
01802
01803
01804 int BesGMenuTitle::ImplFileLine()
01805 {
01806 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetImplFileLine();
01807 }
01808
01809
01810 void BesGMenuTitle::Dictionary()
01811 {
01812 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetClass();
01813 }
01814
01815
01816 TClass *BesGMenuTitle::Class()
01817 {
01818 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuTitle*)0x0)->GetClass();
01819 return fgIsA;
01820 }
01821
01822
01823 TClass *BesGMenuBar::fgIsA = 0;
01824
01825
01826 const char *BesGMenuBar::Class_Name()
01827 {
01828 return "BesGMenuBar";
01829 }
01830
01831
01832 const char *BesGMenuBar::ImplFileName()
01833 {
01834 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetImplFileName();
01835 }
01836
01837
01838 int BesGMenuBar::ImplFileLine()
01839 {
01840 return ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetImplFileLine();
01841 }
01842
01843
01844 void BesGMenuBar::Dictionary()
01845 {
01846 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetClass();
01847 }
01848
01849
01850 TClass *BesGMenuBar::Class()
01851 {
01852 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGMenuBar*)0x0)->GetClass();
01853 return fgIsA;
01854 }
01855
01856
01857 TClass *BesGPictureButton::fgIsA = 0;
01858
01859
01860 const char *BesGPictureButton::Class_Name()
01861 {
01862 return "BesGPictureButton";
01863 }
01864
01865
01866 const char *BesGPictureButton::ImplFileName()
01867 {
01868 return ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetImplFileName();
01869 }
01870
01871
01872 int BesGPictureButton::ImplFileLine()
01873 {
01874 return ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetImplFileLine();
01875 }
01876
01877
01878 void BesGPictureButton::Dictionary()
01879 {
01880 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetClass();
01881 }
01882
01883
01884 TClass *BesGPictureButton::Class()
01885 {
01886 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesGPictureButton*)0x0)->GetClass();
01887 return fgIsA;
01888 }
01889
01890
01891 TClass *BesHeader::fgIsA = 0;
01892
01893
01894 const char *BesHeader::Class_Name()
01895 {
01896 return "BesHeader";
01897 }
01898
01899
01900 const char *BesHeader::ImplFileName()
01901 {
01902 return ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetImplFileName();
01903 }
01904
01905
01906 int BesHeader::ImplFileLine()
01907 {
01908 return ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetImplFileLine();
01909 }
01910
01911
01912 void BesHeader::Dictionary()
01913 {
01914 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetClass();
01915 }
01916
01917
01918 TClass *BesHeader::Class()
01919 {
01920 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesHeader*)0x0)->GetClass();
01921 return fgIsA;
01922 }
01923
01924
01925 TClass *BesVisDisplay::fgIsA = 0;
01926
01927
01928 const char *BesVisDisplay::Class_Name()
01929 {
01930 return "BesVisDisplay";
01931 }
01932
01933
01934 const char *BesVisDisplay::ImplFileName()
01935 {
01936 return ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetImplFileName();
01937 }
01938
01939
01940 int BesVisDisplay::ImplFileLine()
01941 {
01942 return ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetImplFileLine();
01943 }
01944
01945
01946 void BesVisDisplay::Dictionary()
01947 {
01948 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetClass();
01949 }
01950
01951
01952 TClass *BesVisDisplay::Class()
01953 {
01954 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::BesVisDisplay*)0x0)->GetClass();
01955 return fgIsA;
01956 }
01957
01958
01959 TClass *ZHelix::fgIsA = 0;
01960
01961
01962 const char *ZHelix::Class_Name()
01963 {
01964 return "ZHelix";
01965 }
01966
01967
01968 const char *ZHelix::ImplFileName()
01969 {
01970 return ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetImplFileName();
01971 }
01972
01973
01974 int ZHelix::ImplFileLine()
01975 {
01976 return ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetImplFileLine();
01977 }
01978
01979
01980 void ZHelix::Dictionary()
01981 {
01982 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetClass();
01983 }
01984
01985
01986 TClass *ZHelix::Class()
01987 {
01988 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ZHelix*)0x0)->GetClass();
01989 return fgIsA;
01990 }
01991
01992
01993 void BesTView::ShowMembers(TMemberInspector &R__insp)
01994 {
01995
01996 TClass *R__cl = ::BesTView::IsA();
01997 if (R__cl || R__insp.IsA()) { }
01998 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatitude", &fLatitude);
01999 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLongitude", &fLongitude);
02000 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsi", &fPsi);
02001 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDview", &fDview);
02002 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDproj", &fDproj);
02003 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpix", &fUpix);
02004 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVpix", &fVpix);
02005 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTN[16]", fTN);
02006 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTB[16]", fTB);
02007 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax[3]", fRmax);
02008 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin[3]", fRmin);
02009 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUVcoord[4]", fUVcoord);
02010 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTnorm[16]", fTnorm);
02011 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTback[16]", fTback);
02012 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1[3]", fX1);
02013 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX2[3]", fX2);
02014 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1[3]", fY1);
02015 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY2[3]", fY2);
02016 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ1[3]", fZ1);
02017 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ2[3]", fZ2);
02018 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSystem", &fSystem);
02019 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutline", &fOutline);
02020 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultOutline", &fDefaultOutline);
02021 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoRange", &fAutoRange);
02022 R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanged", &fChanged);
02023 TView::ShowMembers(R__insp);
02024 }
02025
02026 namespace ROOT {
02027
02028 static void *new_BesTView(void *p) {
02029 return p ? new(p) ::BesTView : new ::BesTView;
02030 }
02031 static void *newArray_BesTView(Long_t nElements, void *p) {
02032 return p ? new(p) ::BesTView[nElements] : new ::BesTView[nElements];
02033 }
02034
02035 static void delete_BesTView(void *p) {
02036 delete ((::BesTView*)p);
02037 }
02038 static void deleteArray_BesTView(void *p) {
02039 delete [] ((::BesTView*)p);
02040 }
02041 static void destruct_BesTView(void *p) {
02042 typedef ::BesTView current_t;
02043 ((current_t*)p)->~current_t();
02044 }
02045
02046 static void streamer_BesTView(TBuffer &buf, void *obj) {
02047 ((::BesTView*)obj)->::BesTView::Streamer(buf);
02048 }
02049 }
02050
02051
02052 void Bes2DView::Streamer(TBuffer &R__b)
02053 {
02054
02055
02056 if (R__b.IsReading()) {
02057 R__b.ReadClassBuffer(Bes2DView::Class(),this);
02058 } else {
02059 R__b.WriteClassBuffer(Bes2DView::Class(),this);
02060 }
02061 }
02062
02063
02064 void Bes2DView::ShowMembers(TMemberInspector &R__insp)
02065 {
02066
02067 TClass *R__cl = ::Bes2DView::IsA();
02068 if (R__cl || R__insp.IsA()) { }
02069 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFishEye", &fFishEye);
02070 R__insp.Inspect(R__cl, R__insp.GetParent(), "f2DViewType", &f2DViewType);
02071 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMin", &fPhiRangeMin);
02072 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMax", &fPhiRangeMax);
02073 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
02074 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerSize", &fMarkerSize);
02075 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatus3D", &fStatus3D);
02076 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusXY", &fStatusXY);
02077 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusZR", &fStatusZR);
02078 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusCurrent", &fStatusCurrent);
02079 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomFactor", &fZoomFactor);
02080 BesTView::ShowMembers(R__insp);
02081 }
02082
02083 namespace ROOT {
02084
02085 static void *new_Bes2DView(void *p) {
02086 return p ? new(p) ::Bes2DView : new ::Bes2DView;
02087 }
02088 static void *newArray_Bes2DView(Long_t nElements, void *p) {
02089 return p ? new(p) ::Bes2DView[nElements] : new ::Bes2DView[nElements];
02090 }
02091
02092 static void delete_Bes2DView(void *p) {
02093 delete ((::Bes2DView*)p);
02094 }
02095 static void deleteArray_Bes2DView(void *p) {
02096 delete [] ((::Bes2DView*)p);
02097 }
02098 static void destruct_Bes2DView(void *p) {
02099 typedef ::Bes2DView current_t;
02100 ((current_t*)p)->~current_t();
02101 }
02102 }
02103
02104
02105 void BesCircle2D::Streamer(TBuffer &R__b)
02106 {
02107
02108
02109 if (R__b.IsReading()) {
02110 R__b.ReadClassBuffer(BesCircle2D::Class(),this);
02111 } else {
02112 R__b.WriteClassBuffer(BesCircle2D::Class(),this);
02113 }
02114 }
02115
02116
02117 void BesCircle2D::ShowMembers(TMemberInspector &R__insp)
02118 {
02119
02120 TClass *R__cl = ::BesCircle2D::IsA();
02121 if (R__cl || R__insp.IsA()) { }
02122 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_innerCircleX", &f_innerCircleX);
02123 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_innerCircleY", &f_innerCircleY);
02124 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_outerCircleX", &f_outerCircleX);
02125 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_outerCircleY", &f_outerCircleY);
02126 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_areaX", &f_areaX);
02127 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_areaY", &f_areaY);
02128 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInnerRadius", &fInnerRadius);
02129 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOuterRadius", &fOuterRadius);
02130 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenter", &fCenter);
02131 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSegment", &fNSegment);
02132 TNamed::ShowMembers(R__insp);
02133 TAttLine::ShowMembers(R__insp);
02134 TAttFill::ShowMembers(R__insp);
02135 }
02136
02137 namespace ROOT {
02138
02139 static void *new_BesCircle2D(void *p) {
02140 return p ? new(p) ::BesCircle2D : new ::BesCircle2D;
02141 }
02142 static void *newArray_BesCircle2D(Long_t nElements, void *p) {
02143 return p ? new(p) ::BesCircle2D[nElements] : new ::BesCircle2D[nElements];
02144 }
02145
02146 static void delete_BesCircle2D(void *p) {
02147 delete ((::BesCircle2D*)p);
02148 }
02149 static void deleteArray_BesCircle2D(void *p) {
02150 delete [] ((::BesCircle2D*)p);
02151 }
02152 static void destruct_BesCircle2D(void *p) {
02153 typedef ::BesCircle2D current_t;
02154 ((current_t*)p)->~current_t();
02155 }
02156 }
02157
02158
02159 void BesCursor::Streamer(TBuffer &R__b)
02160 {
02161
02162
02163 if (R__b.IsReading()) {
02164 R__b.ReadClassBuffer(BesCursor::Class(),this);
02165 } else {
02166 R__b.WriteClassBuffer(BesCursor::Class(),this);
02167 }
02168 }
02169
02170
02171 void BesCursor::ShowMembers(TMemberInspector &R__insp)
02172 {
02173
02174 TClass *R__cl = ::BesCursor::IsA();
02175 if (R__cl || R__insp.IsA()) { }
02176 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursorType", &fCursorType);
02177 R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowInfo", &fShowInfo);
02178 TObject::ShowMembers(R__insp);
02179 }
02180
02181 namespace ROOT {
02182
02183 static void *new_BesCursor(void *p) {
02184 return p ? new(p) ::BesCursor : new ::BesCursor;
02185 }
02186 static void *newArray_BesCursor(Long_t nElements, void *p) {
02187 return p ? new(p) ::BesCursor[nElements] : new ::BesCursor[nElements];
02188 }
02189
02190 static void delete_BesCursor(void *p) {
02191 delete ((::BesCursor*)p);
02192 }
02193 static void deleteArray_BesCursor(void *p) {
02194 delete [] ((::BesCursor*)p);
02195 }
02196 static void destruct_BesCursor(void *p) {
02197 typedef ::BesCursor current_t;
02198 ((current_t*)p)->~current_t();
02199 }
02200 }
02201
02202
02203 void BesEvent::Streamer(TBuffer &R__b)
02204 {
02205
02206
02207 if (R__b.IsReading()) {
02208 R__b.ReadClassBuffer(BesEvent::Class(),this);
02209 } else {
02210 R__b.WriteClassBuffer(BesEvent::Class(),this);
02211 }
02212 }
02213
02214
02215 void BesEvent::ShowMembers(TMemberInspector &R__insp)
02216 {
02217
02218 TClass *R__cl = ::BesEvent::IsA();
02219 if (R__cl || R__insp.IsA()) { }
02220 R__insp.Inspect(R__cl, R__insp.GetParent(), "f_Magnetic", &f_Magnetic);
02221 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventHeader", &fEventHeader);
02222 R__insp.InspectMember(fEventHeader, "fEventHeader.");
02223 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDigiEvent", &fDigiEvent);
02224 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvtHeader", &fEvtHeader);
02225 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrigEvent", &fTrigEvent);
02226 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRecEvTime", &fRecEvTime);
02227 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdcTrackCol", &fMdcTrackCol);
02228 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTofTrackCol", &fTofTrackCol);
02229 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEmcTrackCol", &fEmcTrackCol);
02230 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMucTrackCol", &fMucTrackCol);
02231 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtTrackCol", &fExtTrackCol);
02232 TObject::ShowMembers(R__insp);
02233 }
02234
02235 namespace ROOT {
02236
02237 static void *new_BesEvent(void *p) {
02238 return p ? new(p) ::BesEvent : new ::BesEvent;
02239 }
02240 static void *newArray_BesEvent(Long_t nElements, void *p) {
02241 return p ? new(p) ::BesEvent[nElements] : new ::BesEvent[nElements];
02242 }
02243
02244 static void delete_BesEvent(void *p) {
02245 delete ((::BesEvent*)p);
02246 }
02247 static void deleteArray_BesEvent(void *p) {
02248 delete [] ((::BesEvent*)p);
02249 }
02250 static void destruct_BesEvent(void *p) {
02251 typedef ::BesEvent current_t;
02252 ((current_t*)p)->~current_t();
02253 }
02254 }
02255
02256
02257 void BesEventHeader::Streamer(TBuffer &R__b)
02258 {
02259
02260
02261 if (R__b.IsReading()) {
02262 R__b.ReadClassBuffer(BesEventHeader::Class(),this);
02263 } else {
02264 R__b.WriteClassBuffer(BesEventHeader::Class(),this);
02265 }
02266 }
02267
02268
02269 void BesEventHeader::ShowMembers(TMemberInspector &R__insp)
02270 {
02271
02272 TClass *R__cl = ::BesEventHeader::IsA();
02273 if (R__cl || R__insp.IsA()) { }
02274 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRun", &fRun);
02275 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvent", &fEvent);
02276 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMC", &fMC);
02277 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDay", &fDay);
02278 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMonth", &fMonth);
02279 R__insp.Inspect(R__cl, R__insp.GetParent(), "fYear", &fYear);
02280 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHour", &fHour);
02281 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
02282 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSec", &fSec);
02283 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvTime", &fEvTime);
02284 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvTimeStatus", &fEvTimeStatus);
02285 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvTimeQuality", &fEvTimeQuality);
02286 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP", &fP);
02287 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPt", &fPt);
02288 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx", &fPx);
02289 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy", &fPy);
02290 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPz", &fPz);
02291 R__insp.Inspect(R__cl, R__insp.GetParent(), "fT", &fT);
02292 R__insp.Inspect(R__cl, R__insp.GetParent(), "fE", &fE);
02293 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeType", &fTimeType);
02294 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrigChannelVector", (void*)&fTrigChannelVector);
02295 R__insp.InspectMember("vector<Int_t>", (void*)&fTrigChannelVector, "fTrigChannelVector.", false);
02296 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrigConditionVector", (void*)&fTrigConditionVector);
02297 R__insp.InspectMember("vector<Int_t>", (void*)&fTrigConditionVector, "fTrigConditionVector.", false);
02298 TObject::ShowMembers(R__insp);
02299 }
02300
02301 namespace ROOT {
02302
02303 static void *new_BesEventHeader(void *p) {
02304 return p ? new(p) ::BesEventHeader : new ::BesEventHeader;
02305 }
02306 static void *newArray_BesEventHeader(Long_t nElements, void *p) {
02307 return p ? new(p) ::BesEventHeader[nElements] : new ::BesEventHeader[nElements];
02308 }
02309
02310 static void delete_BesEventHeader(void *p) {
02311 delete ((::BesEventHeader*)p);
02312 }
02313 static void deleteArray_BesEventHeader(void *p) {
02314 delete [] ((::BesEventHeader*)p);
02315 }
02316 static void destruct_BesEventHeader(void *p) {
02317 typedef ::BesEventHeader current_t;
02318 ((current_t*)p)->~current_t();
02319 }
02320 }
02321
02322
02323 void BesGeometry::Streamer(TBuffer &R__b)
02324 {
02325
02326
02327 if (R__b.IsReading()) {
02328 R__b.ReadClassBuffer(BesGeometry::Class(),this);
02329 } else {
02330 R__b.WriteClassBuffer(BesGeometry::Class(),this);
02331 }
02332 }
02333
02334
02335 void BesGeometry::ShowMembers(TMemberInspector &R__insp)
02336 {
02337
02338 TClass *R__cl = ::BesGeometry::IsA();
02339 if (R__cl || R__insp.IsA()) { }
02340 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesR", &m_BesR);
02341 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesZ", &m_BesZ);
02342 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeRMin", &m_BeamPipeRMin);
02343 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeRMax", &m_BeamPipeRMax);
02344 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BeamPipeZ", &m_BeamPipeZ);
02345 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Bes", &m_Bes);
02346 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_BeamPipe", &m_BeamPipe);
02347 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Mdc", &m_Mdc);
02348 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Tof", &m_Tof);
02349 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Emc", &m_Emc);
02350 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Muc", &m_Muc);
02351 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcROOTGeo", &m_MdcROOTGeo);
02352 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_TofROOTGeo", &m_TofROOTGeo);
02353 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EmcROOTGeo", &m_EmcROOTGeo);
02354 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucROOTGeo", &m_MucROOTGeo);
02355 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_BeamPipeXY", &m_BeamPipeXY);
02356 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_BeamPipeZR", &m_BeamPipeZR);
02357 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_ZRPlaneOnXY", &m_ZRPlaneOnXY);
02358 TObject::ShowMembers(R__insp);
02359 }
02360
02361 namespace ROOT {
02362
02363 static void *new_BesGeometry(void *p) {
02364 return p ? new(p) ::BesGeometry : new ::BesGeometry;
02365 }
02366 static void *newArray_BesGeometry(Long_t nElements, void *p) {
02367 return p ? new(p) ::BesGeometry[nElements] : new ::BesGeometry[nElements];
02368 }
02369
02370 static void delete_BesGeometry(void *p) {
02371 delete ((::BesGeometry*)p);
02372 }
02373 static void deleteArray_BesGeometry(void *p) {
02374 delete [] ((::BesGeometry*)p);
02375 }
02376 static void destruct_BesGeometry(void *p) {
02377 typedef ::BesGeometry current_t;
02378 ((current_t*)p)->~current_t();
02379 }
02380 }
02381
02382
02383 void BesGeoTrack::Streamer(TBuffer &R__b)
02384 {
02385
02386
02387 if (R__b.IsReading()) {
02388 R__b.ReadClassBuffer(BesGeoTrack::Class(),this);
02389 } else {
02390 R__b.WriteClassBuffer(BesGeoTrack::Class(),this);
02391 }
02392 }
02393
02394
02395 void BesGeoTrack::ShowMembers(TMemberInspector &R__insp)
02396 {
02397
02398 TClass *R__cl = ::BesGeoTrack::IsA();
02399 if (R__cl || R__insp.IsA()) { }
02400 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHits", &fHits);
02401 R__insp.InspectMember(fHits, "fHits.");
02402 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
02403 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
02404 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
02405 R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
02406 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
02407 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPolyLine3D", &fPolyLine3D);
02408 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarker", &fMarker);
02409 TGeoTrack::ShowMembers(R__insp);
02410 }
02411
02412 namespace ROOT {
02413
02414 static void *new_BesGeoTrack(void *p) {
02415 return p ? new(p) ::BesGeoTrack : new ::BesGeoTrack;
02416 }
02417 static void *newArray_BesGeoTrack(Long_t nElements, void *p) {
02418 return p ? new(p) ::BesGeoTrack[nElements] : new ::BesGeoTrack[nElements];
02419 }
02420
02421 static void delete_BesGeoTrack(void *p) {
02422 delete ((::BesGeoTrack*)p);
02423 }
02424 static void deleteArray_BesGeoTrack(void *p) {
02425 delete [] ((::BesGeoTrack*)p);
02426 }
02427 static void destruct_BesGeoTrack(void *p) {
02428 typedef ::BesGeoTrack current_t;
02429 ((current_t*)p)->~current_t();
02430 }
02431 }
02432
02433
02434 void BesGMenuBar::Streamer(TBuffer &R__b)
02435 {
02436
02437
02438 if (R__b.IsReading()) {
02439 R__b.ReadClassBuffer(BesGMenuBar::Class(),this);
02440 } else {
02441 R__b.WriteClassBuffer(BesGMenuBar::Class(),this);
02442 }
02443 }
02444
02445
02446 void BesGMenuBar::ShowMembers(TMemberInspector &R__insp)
02447 {
02448
02449 TClass *R__cl = ::BesGMenuBar::IsA();
02450 if (R__cl || R__insp.IsA()) { }
02451 TGMenuBar::ShowMembers(R__insp);
02452 }
02453
02454 namespace ROOT {
02455
02456 static void *new_BesGMenuBar(void *p) {
02457 return p ? new(p) ::BesGMenuBar : new ::BesGMenuBar;
02458 }
02459 static void *newArray_BesGMenuBar(Long_t nElements, void *p) {
02460 return p ? new(p) ::BesGMenuBar[nElements] : new ::BesGMenuBar[nElements];
02461 }
02462
02463 static void delete_BesGMenuBar(void *p) {
02464 delete ((::BesGMenuBar*)p);
02465 }
02466 static void deleteArray_BesGMenuBar(void *p) {
02467 delete [] ((::BesGMenuBar*)p);
02468 }
02469 static void destruct_BesGMenuBar(void *p) {
02470 typedef ::BesGMenuBar current_t;
02471 ((current_t*)p)->~current_t();
02472 }
02473 }
02474
02475
02476 void BesGMenuTitle::Streamer(TBuffer &R__b)
02477 {
02478
02479
02480 if (R__b.IsReading()) {
02481 R__b.ReadClassBuffer(BesGMenuTitle::Class(),this);
02482 } else {
02483 R__b.WriteClassBuffer(BesGMenuTitle::Class(),this);
02484 }
02485 }
02486
02487
02488 void BesGMenuTitle::ShowMembers(TMemberInspector &R__insp)
02489 {
02490
02491 TClass *R__cl = ::BesGMenuTitle::IsA();
02492 if (R__cl || R__insp.IsA()) { }
02493 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPic", &fPic);
02494 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPicHL", &fPicHL);
02495 TGMenuTitle::ShowMembers(R__insp);
02496 }
02497
02498 namespace ROOT {
02499
02500 static void *new_BesGMenuTitle(void *p) {
02501 return p ? new(p) ::BesGMenuTitle : new ::BesGMenuTitle;
02502 }
02503 static void *newArray_BesGMenuTitle(Long_t nElements, void *p) {
02504 return p ? new(p) ::BesGMenuTitle[nElements] : new ::BesGMenuTitle[nElements];
02505 }
02506
02507 static void delete_BesGMenuTitle(void *p) {
02508 delete ((::BesGMenuTitle*)p);
02509 }
02510 static void deleteArray_BesGMenuTitle(void *p) {
02511 delete [] ((::BesGMenuTitle*)p);
02512 }
02513 static void destruct_BesGMenuTitle(void *p) {
02514 typedef ::BesGMenuTitle current_t;
02515 ((current_t*)p)->~current_t();
02516 }
02517 }
02518
02519
02520 void BesGPictureButton::Streamer(TBuffer &R__b)
02521 {
02522
02523
02524 if (R__b.IsReading()) {
02525 R__b.ReadClassBuffer(BesGPictureButton::Class(),this);
02526 } else {
02527 R__b.WriteClassBuffer(BesGPictureButton::Class(),this);
02528 }
02529 }
02530
02531
02532 void BesGPictureButton::ShowMembers(TMemberInspector &R__insp)
02533 {
02534
02535 TClass *R__cl = ::BesGPictureButton::IsA();
02536 if (R__cl || R__insp.IsA()) { }
02537 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicHL", &fPicHL);
02538 R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
02539 TGPictureButton::ShowMembers(R__insp);
02540 }
02541
02542 namespace ROOT {
02543
02544 static void *new_BesGPictureButton(void *p) {
02545 return p ? new(p) ::BesGPictureButton : new ::BesGPictureButton;
02546 }
02547 static void *newArray_BesGPictureButton(Long_t nElements, void *p) {
02548 return p ? new(p) ::BesGPictureButton[nElements] : new ::BesGPictureButton[nElements];
02549 }
02550
02551 static void delete_BesGPictureButton(void *p) {
02552 delete ((::BesGPictureButton*)p);
02553 }
02554 static void deleteArray_BesGPictureButton(void *p) {
02555 delete [] ((::BesGPictureButton*)p);
02556 }
02557 static void destruct_BesGPictureButton(void *p) {
02558 typedef ::BesGPictureButton current_t;
02559 ((current_t*)p)->~current_t();
02560 }
02561 }
02562
02563
02564 void BesHeader::Streamer(TBuffer &R__b)
02565 {
02566
02567
02568 if (R__b.IsReading()) {
02569 R__b.ReadClassBuffer(BesHeader::Class(),this);
02570 } else {
02571 R__b.WriteClassBuffer(BesHeader::Class(),this);
02572 }
02573 }
02574
02575
02576 void BesHeader::ShowMembers(TMemberInspector &R__insp)
02577 {
02578
02579 TClass *R__cl = ::BesHeader::IsA();
02580 if (R__cl || R__insp.IsA()) { }
02581 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcOn", &fMdcOn);
02582 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofOn", &fTofOn);
02583 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcOn", &fEmcOn);
02584 TPaveText::ShowMembers(R__insp);
02585 TQObject::ShowMembers(R__insp);
02586 }
02587
02588 namespace ROOT {
02589
02590 static void *new_BesHeader(void *p) {
02591 return p ? new(p) ::BesHeader : new ::BesHeader;
02592 }
02593 static void *newArray_BesHeader(Long_t nElements, void *p) {
02594 return p ? new(p) ::BesHeader[nElements] : new ::BesHeader[nElements];
02595 }
02596
02597 static void delete_BesHeader(void *p) {
02598 delete ((::BesHeader*)p);
02599 }
02600 static void deleteArray_BesHeader(void *p) {
02601 delete [] ((::BesHeader*)p);
02602 }
02603 static void destruct_BesHeader(void *p) {
02604 typedef ::BesHeader current_t;
02605 ((current_t*)p)->~current_t();
02606 }
02607 }
02608
02609
02610 void BesMarker2D::Streamer(TBuffer &R__b)
02611 {
02612
02613
02614 if (R__b.IsReading()) {
02615 R__b.ReadClassBuffer(BesMarker2D::Class(),this);
02616 } else {
02617 R__b.WriteClassBuffer(BesMarker2D::Class(),this);
02618 }
02619 }
02620
02621
02622 void BesMarker2D::ShowMembers(TMemberInspector &R__insp)
02623 {
02624
02625 TClass *R__cl = ::BesMarker2D::IsA();
02626 if (R__cl || R__insp.IsA()) { }
02627 R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
02628 R__insp.InspectMember(fName, "fName.");
02629 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
02630 R__insp.InspectMember(fTitle, "fTitle.");
02631 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCX", &fWCX);
02632 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCY", &fWCY);
02633 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCZ", &fWCZ);
02634 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizeMultiple", &fSizeMultiple);
02635 TMarker::ShowMembers(R__insp);
02636 }
02637
02638 namespace ROOT {
02639
02640 static void *new_BesMarker2D(void *p) {
02641 return p ? new(p) ::BesMarker2D : new ::BesMarker2D;
02642 }
02643 static void *newArray_BesMarker2D(Long_t nElements, void *p) {
02644 return p ? new(p) ::BesMarker2D[nElements] : new ::BesMarker2D[nElements];
02645 }
02646
02647 static void delete_BesMarker2D(void *p) {
02648 delete ((::BesMarker2D*)p);
02649 }
02650 static void deleteArray_BesMarker2D(void *p) {
02651 delete [] ((::BesMarker2D*)p);
02652 }
02653 static void destruct_BesMarker2D(void *p) {
02654 typedef ::BesMarker2D current_t;
02655 ((current_t*)p)->~current_t();
02656 }
02657 }
02658
02659
02660 void BesPaveText::Streamer(TBuffer &R__b)
02661 {
02662
02663
02664 if (R__b.IsReading()) {
02665 R__b.ReadClassBuffer(BesPaveText::Class(),this);
02666 } else {
02667 R__b.WriteClassBuffer(BesPaveText::Class(),this);
02668 }
02669 }
02670
02671
02672 void BesPaveText::ShowMembers(TMemberInspector &R__insp)
02673 {
02674
02675 TClass *R__cl = ::BesPaveText::IsA();
02676 if (R__cl || R__insp.IsA()) { }
02677 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSize", &fTextSize);
02678 R__insp.Inspect(R__cl, R__insp.GetParent(), "fdxNDC", &fdxNDC);
02679 R__insp.Inspect(R__cl, R__insp.GetParent(), "fdyNDC", &fdyNDC);
02680 TPaveText::ShowMembers(R__insp);
02681 }
02682
02683 namespace ROOT {
02684
02685 static void *new_BesPaveText(void *p) {
02686 return p ? new(p) ::BesPaveText : new ::BesPaveText;
02687 }
02688 static void *newArray_BesPaveText(Long_t nElements, void *p) {
02689 return p ? new(p) ::BesPaveText[nElements] : new ::BesPaveText[nElements];
02690 }
02691
02692 static void delete_BesPaveText(void *p) {
02693 delete ((::BesPaveText*)p);
02694 }
02695 static void deleteArray_BesPaveText(void *p) {
02696 delete [] ((::BesPaveText*)p);
02697 }
02698 static void destruct_BesPaveText(void *p) {
02699 typedef ::BesPaveText current_t;
02700 ((current_t*)p)->~current_t();
02701 }
02702 }
02703
02704
02705 void BesPolygon2D::Streamer(TBuffer &R__b)
02706 {
02707
02708
02709 if (R__b.IsReading()) {
02710 R__b.ReadClassBuffer(BesPolygon2D::Class(),this);
02711 } else {
02712 R__b.WriteClassBuffer(BesPolygon2D::Class(),this);
02713 }
02714 }
02715
02716
02717 void BesPolygon2D::ShowMembers(TMemberInspector &R__insp)
02718 {
02719
02720 TClass *R__cl = ::BesPolygon2D::IsA();
02721 if (R__cl || R__insp.IsA()) { }
02722 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_xx", &f_xx);
02723 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f_yy", &f_yy);
02724 R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
02725 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fP", &fP);
02726 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPBackUp", &fPBackUp);
02727 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCenter[3]", fCenter);
02728 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRotatable", &fRotatable);
02729 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfoBox", &fInfoBox);
02730 TNamed::ShowMembers(R__insp);
02731 TAttLine::ShowMembers(R__insp);
02732 TAttFill::ShowMembers(R__insp);
02733 }
02734
02735 namespace ROOT {
02736
02737 static void *new_BesPolygon2D(void *p) {
02738 return p ? new(p) ::BesPolygon2D : new ::BesPolygon2D;
02739 }
02740 static void *newArray_BesPolygon2D(Long_t nElements, void *p) {
02741 return p ? new(p) ::BesPolygon2D[nElements] : new ::BesPolygon2D[nElements];
02742 }
02743
02744 static void delete_BesPolygon2D(void *p) {
02745 delete ((::BesPolygon2D*)p);
02746 }
02747 static void deleteArray_BesPolygon2D(void *p) {
02748 delete [] ((::BesPolygon2D*)p);
02749 }
02750 static void destruct_BesPolygon2D(void *p) {
02751 typedef ::BesPolygon2D current_t;
02752 ((current_t*)p)->~current_t();
02753 }
02754 }
02755
02756
02757 void BesStatus::Streamer(TBuffer &R__b)
02758 {
02759
02760
02761 if (R__b.IsReading()) {
02762 R__b.ReadClassBuffer(BesStatus::Class(),this);
02763 } else {
02764 R__b.WriteClassBuffer(BesStatus::Class(),this);
02765 }
02766 }
02767
02768
02769 void BesStatus::ShowMembers(TMemberInspector &R__insp)
02770 {
02771
02772 TClass *R__cl = ::BesStatus::IsA();
02773 if (R__cl || R__insp.IsA()) { }
02774 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcGlobal", &fMdcGlobal);
02775 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcTubes", &fMdcTubes);
02776 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcWires", &fMdcWires);
02777 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofGlobal", &fTofGlobal);
02778 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofEast", &fTofEast);
02779 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofBarrel", &fTofBarrel);
02780 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofWest", &fTofWest);
02781 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcGlobal", &fEmcGlobal);
02782 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcEast", &fEmcEast);
02783 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcBarrel", &fEmcBarrel);
02784 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcWest", &fEmcWest);
02785 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcSide", &fEmcSide);
02786 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucGlobal", &fMucGlobal);
02787 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucEast", &fMucEast);
02788 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucBarrel", &fMucBarrel);
02789 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucWest", &fMucWest);
02790 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucStrips", &fMucStrips);
02791 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DMdc", &fFull3DMdc);
02792 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DTof", &fFull3DTof);
02793 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DEmc", &fFull3DEmc);
02794 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull3DMuc", &fFull3DMuc);
02795 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeamPipe", &fBeamPipe);
02796 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRPlaneOnXY", &fZRPlaneOnXY);
02797 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis", &fAxis);
02798 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcHitsGlobal", &fMdcHitsGlobal);
02799 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcHits", &fMdcHits);
02800 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsGlobal", &fTofHitsGlobal);
02801 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsEast", &fTofHitsEast);
02802 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsBarrel", &fTofHitsBarrel);
02803 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofHitsWest", &fTofHitsWest);
02804 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsGlobal", &fEmcHitsGlobal);
02805 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsEast", &fEmcHitsEast);
02806 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsBarrel", &fEmcHitsBarrel);
02807 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsWest", &fEmcHitsWest);
02808 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcHitsSide", &fEmcHitsSide);
02809 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsGlobal", &fMucHitsGlobal);
02810 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsEast", &fMucHitsEast);
02811 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsBarrel", &fMucHitsBarrel);
02812 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucHitsWest", &fMucHitsWest);
02813 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksGlobal", &fTracksGlobal);
02814 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksMdc", &fTracksMdc);
02815 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksTof", &fTracksTof);
02816 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksEmc", &fTracksEmc);
02817 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksMuc", &fTracksMuc);
02818 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTracksExt", &fTracksExt);
02819 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFishEye", &fFishEye);
02820 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMin", &fPhiRangeMin);
02821 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMax", &fPhiRangeMax);
02822 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoom", &fZoom);
02823 TObject::ShowMembers(R__insp);
02824 }
02825
02826 namespace ROOT {
02827
02828 static void *new_BesStatus(void *p) {
02829 return p ? new(p) ::BesStatus : new ::BesStatus;
02830 }
02831 static void *newArray_BesStatus(Long_t nElements, void *p) {
02832 return p ? new(p) ::BesStatus[nElements] : new ::BesStatus[nElements];
02833 }
02834
02835 static void delete_BesStatus(void *p) {
02836 delete ((::BesStatus*)p);
02837 }
02838 static void deleteArray_BesStatus(void *p) {
02839 delete [] ((::BesStatus*)p);
02840 }
02841 static void destruct_BesStatus(void *p) {
02842 typedef ::BesStatus current_t;
02843 ((current_t*)p)->~current_t();
02844 }
02845 }
02846
02847
02848 void BesView::Streamer(TBuffer &R__b)
02849 {
02850
02851
02852 if (R__b.IsReading()) {
02853 R__b.ReadClassBuffer(BesView::Class(),this);
02854 } else {
02855 R__b.WriteClassBuffer(BesView::Class(),this);
02856 }
02857 }
02858
02859
02860 void BesView::ShowMembers(TMemberInspector &R__insp)
02861 {
02862
02863 TClass *R__cl = ::BesView::IsA();
02864 if (R__cl || R__insp.IsA()) { }
02865 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFishEye", &fFishEye);
02866 R__insp.Inspect(R__cl, R__insp.GetParent(), "fViewType", &fViewType);
02867 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMin", &fPhiRangeMin);
02868 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiRangeMax", &fPhiRangeMax);
02869 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
02870 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerSize", &fMarkerSize);
02871 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatus3D", &fStatus3D);
02872 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusXY", &fStatusXY);
02873 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusZR", &fStatusZR);
02874 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusCurrent", &fStatusCurrent);
02875 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomFactor", &fZoomFactor);
02876 R__insp.Inspect(R__cl, R__insp.GetParent(), "fExtentDefault", &fExtentDefault);
02877 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesR", &m_BesR);
02878 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BesZ", &m_BesZ);
02879 BesTView::ShowMembers(R__insp);
02880 }
02881
02882 namespace ROOT {
02883
02884 static void *new_BesView(void *p) {
02885 return p ? new(p) ::BesView : new ::BesView;
02886 }
02887 static void *newArray_BesView(Long_t nElements, void *p) {
02888 return p ? new(p) ::BesView[nElements] : new ::BesView[nElements];
02889 }
02890
02891 static void delete_BesView(void *p) {
02892 delete ((::BesView*)p);
02893 }
02894 static void deleteArray_BesView(void *p) {
02895 delete [] ((::BesView*)p);
02896 }
02897 static void destruct_BesView(void *p) {
02898 typedef ::BesView current_t;
02899 ((current_t*)p)->~current_t();
02900 }
02901 }
02902
02903
02904 void BesVisDisplay::Streamer(TBuffer &R__b)
02905 {
02906
02907
02908 if (R__b.IsReading()) {
02909 R__b.ReadClassBuffer(BesVisDisplay::Class(),this);
02910 } else {
02911 R__b.WriteClassBuffer(BesVisDisplay::Class(),this);
02912 }
02913 }
02914
02915
02916 void BesVisDisplay::ShowMembers(TMemberInspector &R__insp)
02917 {
02918
02919 TClass *R__cl = ::BesVisDisplay::IsA();
02920 if (R__cl || R__insp.IsA()) { }
02921 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisplayMode", &fDisplayMode);
02922 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadHeader", &fPadHeader);
02923 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadXY", &fPadXY);
02924 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadZR", &fPadZR);
02925 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad3D", &fPad3D);
02926 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBesHeader", &fBesHeader);
02927 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderImage", &fHeaderImage);
02928 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderHImage", &fHeaderHImage);
02929 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderVImage", &fHeaderVImage);
02930 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatticeWidth", &fLatticeWidth);
02931 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeTitle", &fTextSizeTitle);
02932 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeTime", &fTextSizeTime);
02933 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeData", &fTextSizeData);
02934 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextSizeFlt", &fTextSizeFlt);
02935 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordx", &fCoordx);
02936 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordy", &fCoordy);
02937 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistanceOfRows", &fDistanceOfRows);
02938 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcOn", &fMdcOn);
02939 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofOn", &fTofOn);
02940 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcOn", &fEmcOn);
02941 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBesGeometry", &fBesGeometry);
02942 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawAllViews", &fDrawAllViews);
02943 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawParticles", &fDrawParticles);
02944 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawParticles2", &fDrawParticles2);
02945 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawClusters", &fDrawClusters);
02946 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPTcut", &fPTcut);
02947 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPTcutEGMUNU", &fPTcutEGMUNU);
02948 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRin", &fRin);
02949 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRout", &fRout);
02950 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZin", &fZin);
02951 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZout", &fZout);
02952 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
02953 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
02954 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBesR", &fBesR);
02955 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBesZ", &fBesZ);
02956 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
02957 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrigPad", &fTrigPad);
02958 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fButtons", &fButtons);
02959 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
02960 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEM1", &fEM1);
02961 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPH1", &fPH1);
02962 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEM2", &fEM2);
02963 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMU1", &fMU1);
02964 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMU2", &fMU2);
02965 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEMU", &fEMU);
02966 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJT1", &fJT1);
02967 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJT3", &fJT3);
02968 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fJT4", &fJT4);
02969 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fALL", &fALL);
02970 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBes", &fBes);
02971 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRayPicCount", &fRayPicCount);
02972 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMdcROOTGeo", &fMdcROOTGeo);
02973 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTofROOTGeo", &fTofROOTGeo);
02974 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEmcROOTGeo", &fEmcROOTGeo);
02975 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMucROOTGeo", &fMucROOTGeo);
02976 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMdcCon", &fMdcCon);
02977 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTofCon", &fTofCon);
02978 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmcCon", &fEmcCon);
02979 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMucCon", &fMucCon);
02980 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllVis", &fAllVis);
02981 R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuarterVis", &fQuarterVis);
02982 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHalfVis", &fHalfVis);
02983 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoEndVis", &fNoEndVis);
02984 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fxyView", &fxyView);
02985 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fzrView", &fzrView);
02986 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3DView", &f3DView);
02987 TQObject::ShowMembers(R__insp);
02988 }
02989
02990 namespace ROOT {
02991
02992 static void *new_BesVisDisplay(void *p) {
02993 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BesVisDisplay : new ::BesVisDisplay;
02994 }
02995 static void *newArray_BesVisDisplay(Long_t nElements, void *p) {
02996 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BesVisDisplay[nElements] : new ::BesVisDisplay[nElements];
02997 }
02998
02999 static void delete_BesVisDisplay(void *p) {
03000 delete ((::BesVisDisplay*)p);
03001 }
03002 static void deleteArray_BesVisDisplay(void *p) {
03003 delete [] ((::BesVisDisplay*)p);
03004 }
03005 static void destruct_BesVisDisplay(void *p) {
03006 typedef ::BesVisDisplay current_t;
03007 ((current_t*)p)->~current_t();
03008 }
03009 }
03010
03011
03012 void Emc2DCrystal::Streamer(TBuffer &R__b)
03013 {
03014
03015
03016 if (R__b.IsReading()) {
03017 R__b.ReadClassBuffer(Emc2DCrystal::Class(),this);
03018 } else {
03019 R__b.WriteClassBuffer(Emc2DCrystal::Class(),this);
03020 }
03021 }
03022
03023
03024 void Emc2DCrystal::ShowMembers(TMemberInspector &R__insp)
03025 {
03026
03027 TClass *R__cl = ::Emc2DCrystal::IsA();
03028 if (R__cl || R__insp.IsA()) { }
03029 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPart", &fPart);
03030 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
03031 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalXY", &fCrystalXY);
03032 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalZR", &fCrystalZR);
03033 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalSide", &fCrystalSide);
03034 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalXYFired", &fCrystalXYFired);
03035 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalZRFired", &fCrystalZRFired);
03036 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrystalSideFired", &fCrystalSideFired);
03037 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &fTime);
03038 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
03039 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionTolerance[3]", fZRSectionTolerance);
03040 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMin", &fPhiMin);
03041 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMax", &fPhiMax);
03042 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
03043 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
03044 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
03045 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
03046 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
03047 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystal", &lcCrystal);
03048 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystal", &lwCrystal);
03049 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystal", &fcCrystal);
03050 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystal", &fsCrystal);
03051 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalTrans", &fsCrystalTrans);
03052 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystalFired", &lcCrystalFired);
03053 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystalFired", &lwCrystalFired);
03054 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystalFired", &fcCrystalFired);
03055 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalFired", &fsCrystalFired);
03056 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystalHL", &lcCrystalHL);
03057 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystalHL", &lwCrystalHL);
03058 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystalHL", &fcCrystalHL);
03059 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalHL", &fsCrystalHL);
03060 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcCrystalFiredHL", &lcCrystalFiredHL);
03061 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCrystalFiredHL", &lwCrystalFiredHL);
03062 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCrystalFiredHL", &fcCrystalFiredHL);
03063 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCrystalFiredHL", &fsCrystalFiredHL);
03064 TNamed::ShowMembers(R__insp);
03065 TAttLine::ShowMembers(R__insp);
03066 TAttFill::ShowMembers(R__insp);
03067 }
03068
03069 namespace ROOT {
03070
03071 static void *new_Emc2DCrystal(void *p) {
03072 return p ? new(p) ::Emc2DCrystal : new ::Emc2DCrystal;
03073 }
03074 static void *newArray_Emc2DCrystal(Long_t nElements, void *p) {
03075 return p ? new(p) ::Emc2DCrystal[nElements] : new ::Emc2DCrystal[nElements];
03076 }
03077
03078 static void delete_Emc2DCrystal(void *p) {
03079 delete ((::Emc2DCrystal*)p);
03080 }
03081 static void deleteArray_Emc2DCrystal(void *p) {
03082 delete [] ((::Emc2DCrystal*)p);
03083 }
03084 static void destruct_Emc2DCrystal(void *p) {
03085 typedef ::Emc2DCrystal current_t;
03086 ((current_t*)p)->~current_t();
03087 }
03088 }
03089
03090
03091 namespace ROOT {
03092 void EmcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
03093 {
03094
03095 typedef ::ROOT::Shadow::EmcROOTGeo ShadowClass;
03096 ShadowClass *sobj = (ShadowClass*)obj;
03097 if (sobj) { }
03098
03099 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::EmcROOTGeo*)0x0)->GetClass();
03100 if (R__cl || R__insp.IsA()) { }
03101 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kPhiEc", &sobj->m_kPhiEc);
03102 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kThetaEc", &sobj->m_kThetaEc);
03103 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kSectorEc", &sobj->m_kSectorEc);
03104 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kNbEc", &sobj->m_kNbEc);
03105 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kRealNbEc", &sobj->m_kRealNbEc);
03106 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_EmcColor", &sobj->m_EmcColor);
03107 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partColor", &sobj->m_partColor);
03108 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phiColor", &sobj->m_phiColor);
03109 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_thetaColor", &sobj->m_thetaColor);
03110 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_brCrystalColor", &sobj->m_brCrystalColor);
03111 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ecCrystalColor", &sobj->m_ecCrystalColor);
03112 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Emc", &sobj->m_Emc);
03113 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodePart[3]", &sobj->m_NodePart);
03114 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodePhi[3][120]", &sobj->m_NodePhi);
03115 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeTheta[3][120][44]", &sobj->m_NodeTheta);
03116 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeTheta2[3][120][44]", &sobj->m_NodeTheta2);
03117 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalCrystal[3][120][44]", &sobj->m_PhysicalCrystal);
03118 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalCrystal2[3][120][44]", &sobj->m_PhysicalCrystal2);
03119 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhyNodeOrgArray", &sobj->m_PhyNodeOrgArray);
03120 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EmcDigiCol", &sobj->m_EmcDigiCol);
03121 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Emc2DCrystal[3][120][44]", &sobj->m_Emc2DCrystal);
03122 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::EmcROOTGeo*) obj ), false);
03123 }
03124
03125 }
03126
03127 namespace ROOT {
03128
03129 static void *new_EmcROOTGeo(void *p) {
03130 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::EmcROOTGeo : new ::EmcROOTGeo;
03131 }
03132 static void *newArray_EmcROOTGeo(Long_t nElements, void *p) {
03133 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::EmcROOTGeo[nElements] : new ::EmcROOTGeo[nElements];
03134 }
03135
03136 static void delete_EmcROOTGeo(void *p) {
03137 delete ((::EmcROOTGeo*)p);
03138 }
03139 static void deleteArray_EmcROOTGeo(void *p) {
03140 delete [] ((::EmcROOTGeo*)p);
03141 }
03142 static void destruct_EmcROOTGeo(void *p) {
03143 typedef ::EmcROOTGeo current_t;
03144 ((current_t*)p)->~current_t();
03145 }
03146 }
03147
03148
03149 void Mdc2DWire::Streamer(TBuffer &R__b)
03150 {
03151
03152
03153 if (R__b.IsReading()) {
03154 R__b.ReadClassBuffer(Mdc2DWire::Class(),this);
03155 } else {
03156 R__b.WriteClassBuffer(Mdc2DWire::Class(),this);
03157 }
03158 }
03159
03160
03161 void Mdc2DWire::ShowMembers(TMemberInspector &R__insp)
03162 {
03163
03164 TClass *R__cl = ::Mdc2DWire::IsA();
03165 if (R__cl || R__insp.IsA()) { }
03166 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWireType", &fWireType);
03167 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTube", &fTube);
03168 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWireCircle", &fWireCircle);
03169 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWireCone", &fWireCone);
03170 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZRPosMarker2D", &fZRPosMarker2D);
03171 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWestHole[3]", fWestHole);
03172 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEastHole[3]", fEastHole);
03173 R__insp.Inspect(R__cl, R__insp.GetParent(), "fWestPhi", &fWestPhi);
03174 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEastPhi", &fEastPhi);
03175 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionPos[3]", fZRSectionPos);
03176 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionFlag", &fZRSectionFlag);
03177 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
03178 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
03179 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
03180 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
03181 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
03182 R__insp.Inspect(R__cl, R__insp.GetParent(), "fColorfulWire", &fColorfulWire);
03183 R__insp.Inspect(R__cl, R__insp.GetParent(), "qOverflow", &qOverflow);
03184 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcTube", &lcTube);
03185 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwTube", &lwTube);
03186 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcTube", &fcTube);
03187 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsTube", &fsTube);
03188 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcWire", &lcWire);
03189 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCircle", &lwCircle);
03190 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCone", &lwCone);
03191 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCircle", &fcCircle);
03192 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCone", &fcCone);
03193 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCircle", &fsCircle);
03194 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCone", &fsCone);
03195 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcWireFired", &lcWireFired);
03196 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCircleFired", &lwCircleFired);
03197 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwConeFired", &lwConeFired);
03198 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCircleFired", &fcCircleFired);
03199 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcConeFired", &fcConeFired);
03200 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCircleFired", &fsCircleFired);
03201 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsConeFired", &fsConeFired);
03202 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcWireHL", &lcWireHL);
03203 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwCircleHL", &lwCircleHL);
03204 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwConeHL", &lwConeHL);
03205 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcCircleHL", &fcCircleHL);
03206 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcConeHL", &fcConeHL);
03207 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsCircleHL", &fsCircleHL);
03208 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsConeHL", &fsConeHL);
03209 R__insp.Inspect(R__cl, R__insp.GetParent(), "sizeMarker", &sizeMarker);
03210 R__insp.Inspect(R__cl, R__insp.GetParent(), "cMarker", &cMarker);
03211 R__insp.Inspect(R__cl, R__insp.GetParent(), "cMarkerFired", &cMarkerFired);
03212 R__insp.Inspect(R__cl, R__insp.GetParent(), "cMarkerHL", &cMarkerHL);
03213 R__insp.Inspect(R__cl, R__insp.GetParent(), "sMarker", &sMarker);
03214 R__insp.Inspect(R__cl, R__insp.GetParent(), "sMarkerFired", &sMarkerFired);
03215 R__insp.Inspect(R__cl, R__insp.GetParent(), "sMarkerHL", &sMarkerHL);
03216 R__insp.Inspect(R__cl, R__insp.GetParent(), "mdcTime", &mdcTime);
03217 R__insp.Inspect(R__cl, R__insp.GetParent(), "mdcCharge", &mdcCharge);
03218 R__insp.Inspect(R__cl, R__insp.GetParent(), "evTime", &evTime);
03219 TNamed::ShowMembers(R__insp);
03220 TAttLine::ShowMembers(R__insp);
03221 TAttFill::ShowMembers(R__insp);
03222 }
03223
03224 namespace ROOT {
03225
03226 static void *new_Mdc2DWire(void *p) {
03227 return p ? new(p) ::Mdc2DWire : new ::Mdc2DWire;
03228 }
03229 static void *newArray_Mdc2DWire(Long_t nElements, void *p) {
03230 return p ? new(p) ::Mdc2DWire[nElements] : new ::Mdc2DWire[nElements];
03231 }
03232
03233 static void delete_Mdc2DWire(void *p) {
03234 delete ((::Mdc2DWire*)p);
03235 }
03236 static void deleteArray_Mdc2DWire(void *p) {
03237 delete [] ((::Mdc2DWire*)p);
03238 }
03239 static void destruct_Mdc2DWire(void *p) {
03240 typedef ::Mdc2DWire current_t;
03241 ((current_t*)p)->~current_t();
03242 }
03243 }
03244
03245
03246 namespace ROOT {
03247 void MdcROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
03248 {
03249
03250 typedef ::ROOT::Shadow::MdcROOTGeo ShadowClass;
03251 ShadowClass *sobj = (ShadowClass*)obj;
03252 if (sobj) { }
03253
03254 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::MdcROOTGeo*)0x0)->GetClass();
03255 if (R__cl || R__insp.IsA()) { }
03256 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_TFire", &sobj->k_TFire);
03257 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_QFire", &sobj->k_QFire);
03258 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_QNotOverflow", &sobj->k_QNotOverflow);
03259 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_ColorfulWire", &sobj->k_ColorfulWire);
03260 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_MdcTimeSubEvTime", &sobj->k_MdcTimeSubEvTime);
03261 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_MdcColor", &sobj->m_MdcColor);
03262 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_segmentColor", &sobj->m_segmentColor);
03263 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hypeColor", &sobj->m_hypeColor);
03264 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tubeColor", &sobj->m_tubeColor);
03265 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_twistedTubsColor", &sobj->m_twistedTubsColor);
03266 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_replicaColor", &sobj->m_replicaColor);
03267 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_CorrectMap", (void*)&sobj->m_CorrectMap);
03268 R__insp.InspectMember("map<int,int>", (void*)&sobj->m_CorrectMap, "m_CorrectMap.", false);
03269 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Mdc", &sobj->m_Mdc);
03270 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeLayer[50]", &sobj->m_NodeLayer);
03271 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeReplica[50][288]", &sobj->m_NodeReplica);
03272 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalSegment[132]", &sobj->m_PhysicalSegment);
03273 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalReplica[50][288]", &sobj->m_PhysicalReplica);
03274 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcDigiCol", &sobj->m_MdcDigiCol);
03275 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcXY", &sobj->m_MdcXY);
03276 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcXYSuper[4]", &sobj->m_MdcXYSuper);
03277 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Mdc2DWire[43][288]", &sobj->m_Mdc2DWire);
03278 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MdcZR[2]", &sobj->m_MdcZR);
03279 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::MdcROOTGeo*) obj ), false);
03280 }
03281
03282 }
03283
03284 namespace ROOT {
03285
03286 static void *new_MdcROOTGeo(void *p) {
03287 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MdcROOTGeo : new ::MdcROOTGeo;
03288 }
03289 static void *newArray_MdcROOTGeo(Long_t nElements, void *p) {
03290 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MdcROOTGeo[nElements] : new ::MdcROOTGeo[nElements];
03291 }
03292
03293 static void delete_MdcROOTGeo(void *p) {
03294 delete ((::MdcROOTGeo*)p);
03295 }
03296 static void deleteArray_MdcROOTGeo(void *p) {
03297 delete [] ((::MdcROOTGeo*)p);
03298 }
03299 static void destruct_MdcROOTGeo(void *p) {
03300 typedef ::MdcROOTGeo current_t;
03301 ((current_t*)p)->~current_t();
03302 }
03303 }
03304
03305
03306 void Muc2DStrip::Streamer(TBuffer &R__b)
03307 {
03308
03309
03310 if (R__b.IsReading()) {
03311 R__b.ReadClassBuffer(Muc2DStrip::Class(),this);
03312 } else {
03313 R__b.WriteClassBuffer(Muc2DStrip::Class(),this);
03314 }
03315 }
03316
03317
03318 void Muc2DStrip::ShowMembers(TMemberInspector &R__insp)
03319 {
03320
03321 TClass *R__cl = ::Muc2DStrip::IsA();
03322 if (R__cl || R__insp.IsA()) { }
03323 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPart", &fPart);
03324 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeg", &fSeg);
03325 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGap", &fGap);
03326 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrip", &fStrip);
03327 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStripXY", &fStripXY);
03328 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStripZR", &fStripZR);
03329 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
03330 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
03331 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
03332 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
03333 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
03334 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcStrip", &lcStrip);
03335 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwStrip", &lwStrip);
03336 R__insp.Inspect(R__cl, R__insp.GetParent(), "lsStrip", &lsStrip);
03337 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcStrip", &fcStrip);
03338 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsStrip", &fsStrip);
03339 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcStripFired", &lcStripFired);
03340 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwStripFired", &lwStripFired);
03341 R__insp.Inspect(R__cl, R__insp.GetParent(), "lsStripFired", &lsStripFired);
03342 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcStripFired", &fcStripFired);
03343 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsStripFired", &fsStripFired);
03344 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcStripHL", &lcStripHL);
03345 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwStripHL", &lwStripHL);
03346 R__insp.Inspect(R__cl, R__insp.GetParent(), "lsStripHL", &lsStripHL);
03347 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcStripHL", &fcStripHL);
03348 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsStripHL", &fsStripHL);
03349 TNamed::ShowMembers(R__insp);
03350 TAttLine::ShowMembers(R__insp);
03351 TAttFill::ShowMembers(R__insp);
03352 }
03353
03354 namespace ROOT {
03355
03356 static void *new_Muc2DStrip(void *p) {
03357 return p ? new(p) ::Muc2DStrip : new ::Muc2DStrip;
03358 }
03359 static void *newArray_Muc2DStrip(Long_t nElements, void *p) {
03360 return p ? new(p) ::Muc2DStrip[nElements] : new ::Muc2DStrip[nElements];
03361 }
03362
03363 static void delete_Muc2DStrip(void *p) {
03364 delete ((::Muc2DStrip*)p);
03365 }
03366 static void deleteArray_Muc2DStrip(void *p) {
03367 delete [] ((::Muc2DStrip*)p);
03368 }
03369 static void destruct_Muc2DStrip(void *p) {
03370 typedef ::Muc2DStrip current_t;
03371 ((current_t*)p)->~current_t();
03372 }
03373 }
03374
03375
03376 namespace ROOT {
03377 void MucROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
03378 {
03379
03380 typedef ::ROOT::Shadow::MucROOTGeo ShadowClass;
03381 ShadowClass *sobj = (ShadowClass*)obj;
03382 if (sobj) { }
03383
03384 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::MucROOTGeo*)0x0)->GetClass();
03385 if (R__cl || R__insp.IsA()) { }
03386 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_StripNum[3][8][9]", sobj->m_StripNum);
03387 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_MucColor", &sobj->m_MucColor);
03388 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_absorberColor", &sobj->m_absorberColor);
03389 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_gapColor", &sobj->m_gapColor);
03390 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_gasChamberColor", &sobj->m_gasChamberColor);
03391 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_bakeliteColor", &sobj->m_bakeliteColor);
03392 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stripColor", &sobj->m_stripColor);
03393 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Muc", &sobj->m_Muc);
03394 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeAbsorber[3][8][9]", &sobj->m_NodeAbsorber);
03395 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeAbsorberPanel[3][8][9][4]", &sobj->m_NodeAbsorberPanel);
03396 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeGap[3][8][9]", &sobj->m_NodeGap);
03397 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeStripPlane[3][8][9]", &sobj->m_NodeStripPlane);
03398 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeStrip[3][8][9][112]", &sobj->m_NodeStrip);
03399 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalAbsorber[3][8][9][4]", &sobj->m_PhysicalAbsorber);
03400 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalGap[3][8][9]", &sobj->m_PhysicalGap);
03401 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalStrip[3][8][9][112]", &sobj->m_PhysicalStrip);
03402 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucDigiCol", &sobj->m_MucDigiCol);
03403 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucXY[3][8]", &sobj->m_MucXY);
03404 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucZR[3][8]", &sobj->m_MucZR);
03405 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucXYGap[3][8][9]", &sobj->m_MucXYGap);
03406 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_MucZRGap[3][8][9]", &sobj->m_MucZRGap);
03407 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Muc2DStrip[3][8][9][112]", &sobj->m_Muc2DStrip);
03408 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::MucROOTGeo*) obj ), false);
03409 }
03410
03411 }
03412
03413 namespace ROOT {
03414
03415 static void *new_MucROOTGeo(void *p) {
03416 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MucROOTGeo : new ::MucROOTGeo;
03417 }
03418 static void *newArray_MucROOTGeo(Long_t nElements, void *p) {
03419 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MucROOTGeo[nElements] : new ::MucROOTGeo[nElements];
03420 }
03421
03422 static void delete_MucROOTGeo(void *p) {
03423 delete ((::MucROOTGeo*)p);
03424 }
03425 static void deleteArray_MucROOTGeo(void *p) {
03426 delete [] ((::MucROOTGeo*)p);
03427 }
03428 static void destruct_MucROOTGeo(void *p) {
03429 typedef ::MucROOTGeo current_t;
03430 ((current_t*)p)->~current_t();
03431 }
03432 }
03433
03434
03435 namespace ROOT {
03436 void SubDetectorROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
03437 {
03438
03439 typedef ::ROOT::Shadow::SubDetectorROOTGeo ShadowClass;
03440 ShadowClass *sobj = (ShadowClass*)obj;
03441 if (sobj) { }
03442
03443 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::SubDetectorROOTGeo*)0x0)->GetClass();
03444 if (R__cl || R__insp.IsA()) { }
03445 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sxp", (void*)&sobj->m_sxp);
03446 R__insp.InspectMember("SAXProcessor", (void*)&sobj->m_sxp, "m_sxp.", false);
03447 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_config", (void*)&sobj->m_config);
03448 R__insp.InspectMember("ProcessingConfigurator", (void*)&sobj->m_config, "m_config.", false);
03449 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ROOTGeoInit", &sobj->m_ROOTGeoInit);
03450 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_childNo", &sobj->m_childNo);
03451 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_2DGeoInit", &sobj->m_2DGeoInit);
03452 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_TopVolume", &sobj->m_TopVolume);
03453 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_DetectorsArray", &sobj->m_DetectorsArray);
03454 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_HitsArray", &sobj->m_HitsArray);
03455 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_2DHitsArray", &sobj->m_2DHitsArray);
03456 }
03457
03458 }
03459
03460 namespace ROOT {
03461
03462 static void *new_SubDetectorROOTGeo(void *p) {
03463 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::SubDetectorROOTGeo : new ::SubDetectorROOTGeo;
03464 }
03465 static void *newArray_SubDetectorROOTGeo(Long_t nElements, void *p) {
03466 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::SubDetectorROOTGeo[nElements] : new ::SubDetectorROOTGeo[nElements];
03467 }
03468
03469 static void delete_SubDetectorROOTGeo(void *p) {
03470 delete ((::SubDetectorROOTGeo*)p);
03471 }
03472 static void deleteArray_SubDetectorROOTGeo(void *p) {
03473 delete [] ((::SubDetectorROOTGeo*)p);
03474 }
03475 static void destruct_SubDetectorROOTGeo(void *p) {
03476 typedef ::SubDetectorROOTGeo current_t;
03477 ((current_t*)p)->~current_t();
03478 }
03479 }
03480
03481
03482 void Tof2DScin::Streamer(TBuffer &R__b)
03483 {
03484
03485
03486 if (R__b.IsReading()) {
03487 R__b.ReadClassBuffer(Tof2DScin::Class(),this);
03488 } else {
03489 R__b.WriteClassBuffer(Tof2DScin::Class(),this);
03490 }
03491 }
03492
03493
03494 void Tof2DScin::ShowMembers(TMemberInspector &R__insp)
03495 {
03496
03497 TClass *R__cl = ::Tof2DScin::IsA();
03498 if (R__cl || R__insp.IsA()) { }
03499 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPart", &fPart);
03500 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinXY", &fScinXY);
03501 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinZR", &fScinZR);
03502 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinXYFired", &fScinXYFired);
03503 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScinZRFired", &fScinZRFired);
03504 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &fTime);
03505 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
03506 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZRSectionTolerance[3]", fZRSectionTolerance);
03507 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMin", &fPhiMin);
03508 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMax", &fPhiMax);
03509 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfoCon", (void*)&fInfoCon);
03510 R__insp.InspectMember("vector<TString>", (void*)&fInfoCon, "fInfoCon.", false);
03511 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
03512 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
03513 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFired", &fFired);
03514 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScin", &lcScin);
03515 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScin", &lwScin);
03516 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScin", &fcScin);
03517 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScin", &fsScin);
03518 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScinFired", &lcScinFired);
03519 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScinFired", &lwScinFired);
03520 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScinFired", &fcScinFired);
03521 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScinFired", &fsScinFired);
03522 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScinHL", &lcScinHL);
03523 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScinHL", &lwScinHL);
03524 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScinHL", &fcScinHL);
03525 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScinHL", &fsScinHL);
03526 R__insp.Inspect(R__cl, R__insp.GetParent(), "lcScinFiredHL", &lcScinFiredHL);
03527 R__insp.Inspect(R__cl, R__insp.GetParent(), "lwScinFiredHL", &lwScinFiredHL);
03528 R__insp.Inspect(R__cl, R__insp.GetParent(), "fcScinFiredHL", &fcScinFiredHL);
03529 R__insp.Inspect(R__cl, R__insp.GetParent(), "fsScinFiredHL", &fsScinFiredHL);
03530 TNamed::ShowMembers(R__insp);
03531 TAttLine::ShowMembers(R__insp);
03532 TAttFill::ShowMembers(R__insp);
03533 }
03534
03535 namespace ROOT {
03536
03537 static void *new_Tof2DScin(void *p) {
03538 return p ? new(p) ::Tof2DScin : new ::Tof2DScin;
03539 }
03540 static void *newArray_Tof2DScin(Long_t nElements, void *p) {
03541 return p ? new(p) ::Tof2DScin[nElements] : new ::Tof2DScin[nElements];
03542 }
03543
03544 static void delete_Tof2DScin(void *p) {
03545 delete ((::Tof2DScin*)p);
03546 }
03547 static void deleteArray_Tof2DScin(void *p) {
03548 delete [] ((::Tof2DScin*)p);
03549 }
03550 static void destruct_Tof2DScin(void *p) {
03551 typedef ::Tof2DScin current_t;
03552 ((current_t*)p)->~current_t();
03553 }
03554 }
03555
03556
03557 namespace ROOT {
03558 void TofROOTGeo_ShowMembers(void *obj, TMemberInspector &R__insp)
03559 {
03560
03561 typedef ::ROOT::Shadow::TofROOTGeo ShadowClass;
03562 ShadowClass *sobj = (ShadowClass*)obj;
03563 if (sobj) { }
03564
03565 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::TofROOTGeo*)0x0)->GetClass();
03566 if (R__cl || R__insp.IsA()) { }
03567 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_TMatch", &sobj->k_TMatch);
03568 R__insp.Inspect(R__cl, R__insp.GetParent(), "k_QMatch", &sobj->k_QMatch);
03569 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_TofColor", &sobj->m_TofColor);
03570 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_BucketColor", &sobj->m_BucketColor);
03571 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ScinColor", &sobj->m_ScinColor);
03572 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Tof", &sobj->m_Tof);
03573 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodePVF[3][2][88]", &sobj->m_NodePVF);
03574 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeAl[3][2]", &sobj->m_NodeAl);
03575 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_NodeScin[3][2]", &sobj->m_NodeScin);
03576 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_PhysicalScin[3][2][88]", &sobj->m_PhysicalScin);
03577 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_TofDigiCol", &sobj->m_TofDigiCol);
03578 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_Tof2DScin[3][2][88]", &sobj->m_Tof2DScin);
03579 R__insp.GenericShowMembers("SubDetectorROOTGeo", ( ::SubDetectorROOTGeo * )( (::TofROOTGeo*) obj ), false);
03580 }
03581
03582 }
03583
03584 namespace ROOT {
03585
03586 static void *new_TofROOTGeo(void *p) {
03587 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TofROOTGeo : new ::TofROOTGeo;
03588 }
03589 static void *newArray_TofROOTGeo(Long_t nElements, void *p) {
03590 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TofROOTGeo[nElements] : new ::TofROOTGeo[nElements];
03591 }
03592
03593 static void delete_TofROOTGeo(void *p) {
03594 delete ((::TofROOTGeo*)p);
03595 }
03596 static void deleteArray_TofROOTGeo(void *p) {
03597 delete [] ((::TofROOTGeo*)p);
03598 }
03599 static void destruct_TofROOTGeo(void *p) {
03600 typedef ::TofROOTGeo current_t;
03601 ((current_t*)p)->~current_t();
03602 }
03603 }
03604
03605
03606 namespace ROOT {
03607 void vector3_ShowMembers(void *obj, TMemberInspector &R__insp)
03608 {
03609
03610 typedef ::ROOT::Shadow::vector3 ShadowClass;
03611 ShadowClass *sobj = (ShadowClass*)obj;
03612 if (sobj) { }
03613
03614 TClass *R__cl = ::ROOT::GenerateInitInstanceLocal((const ::vector3*)0x0)->GetClass();
03615 if (R__cl || R__insp.IsA()) { }
03616 R__insp.Inspect(R__cl, R__insp.GetParent(), "x", &sobj->x);
03617 R__insp.Inspect(R__cl, R__insp.GetParent(), "y", &sobj->y);
03618 R__insp.Inspect(R__cl, R__insp.GetParent(), "z", &sobj->z);
03619 }
03620
03621 }
03622
03623 namespace ROOT {
03624
03625 static void *new_vector3(void *p) {
03626 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector3 : new ::vector3;
03627 }
03628 static void *newArray_vector3(Long_t nElements, void *p) {
03629 return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector3[nElements] : new ::vector3[nElements];
03630 }
03631
03632 static void delete_vector3(void *p) {
03633 delete ((::vector3*)p);
03634 }
03635 static void deleteArray_vector3(void *p) {
03636 delete [] ((::vector3*)p);
03637 }
03638 static void destruct_vector3(void *p) {
03639 typedef ::vector3 current_t;
03640 ((current_t*)p)->~current_t();
03641 }
03642 }
03643
03644
03645 void ZHelix::Streamer(TBuffer &R__b)
03646 {
03647
03648
03649 if (R__b.IsReading()) {
03650 R__b.ReadClassBuffer(ZHelix::Class(),this);
03651 } else {
03652 R__b.WriteClassBuffer(ZHelix::Class(),this);
03653 }
03654 }
03655
03656
03657 void ZHelix::ShowMembers(TMemberInspector &R__insp)
03658 {
03659
03660 TClass *R__cl = ::ZHelix::IsA();
03661 if (R__cl || R__insp.IsA()) { }
03662 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrackType", &fTrackType);
03663 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAzim", &fAzim);
03664 R__insp.Inspect(R__cl, R__insp.GetParent(), "fQovR", &fQovR);
03665 R__insp.Inspect(R__cl, R__insp.GetParent(), "fQxDh", &fQxDh);
03666 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTDip", &fTDip);
03667 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefX", &fRefX);
03668 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefY", &fRefY);
03669 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefZ", &fRefZ);
03670 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRange[2]", fRange);
03671 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRType", &fRType);
03672 R__insp.Inspect(R__cl, R__insp.GetParent(), "fChi2", &fChi2);
03673 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDoF", &fNDoF);
03674 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSinAzim", &fSinAzim);
03675 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosAzim", &fCosAzim);
03676 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRSign", &fRSign);
03677 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiI", &fPhiI);
03678 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiO", &fPhiO);
03679 R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnable", &fEnable);
03680 TPolyLine3D::ShowMembers(R__insp);
03681 }
03682
03683 namespace ROOT {
03684
03685 static void *new_ZHelix(void *p) {
03686 return p ? new(p) ::ZHelix : new ::ZHelix;
03687 }
03688 static void *newArray_ZHelix(Long_t nElements, void *p) {
03689 return p ? new(p) ::ZHelix[nElements] : new ::ZHelix[nElements];
03690 }
03691
03692 static void delete_ZHelix(void *p) {
03693 delete ((::ZHelix*)p);
03694 }
03695 static void deleteArray_ZHelix(void *p) {
03696 delete [] ((::ZHelix*)p);
03697 }
03698 static void destruct_ZHelix(void *p) {
03699 typedef ::ZHelix current_t;
03700 ((current_t*)p)->~current_t();
03701 }
03702
03703 static Long64_t merge_ZHelix(void *obj,TCollection *coll,TFileMergeInfo *) {
03704 return ((::ZHelix*)obj)->Merge(coll);
03705 }
03706 }
03707
03708 namespace ROOT {
03709 void maplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
03710 static void maplEintcOintgR_Dictionary();
03711 static void *new_maplEintcOintgR(void *p = 0);
03712 static void *newArray_maplEintcOintgR(Long_t size, void *p);
03713 static void delete_maplEintcOintgR(void *p);
03714 static void deleteArray_maplEintcOintgR(void *p);
03715 static void destruct_maplEintcOintgR(void *p);
03716
03717
03718 static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,int>*)
03719 {
03720 map<int,int> *ptr = 0;
03721 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,int>),0);
03722 static ::ROOT::TGenericClassInfo
03723 instance("map<int,int>", -2, "map2.dll", 0,
03724 typeid(map<int,int>), DefineBehavior(ptr, ptr),
03725 0, &maplEintcOintgR_Dictionary, isa_proxy, 0,
03726 sizeof(map<int,int>) );
03727 instance.SetNew(&new_maplEintcOintgR);
03728 instance.SetNewArray(&newArray_maplEintcOintgR);
03729 instance.SetDelete(&delete_maplEintcOintgR);
03730 instance.SetDeleteArray(&deleteArray_maplEintcOintgR);
03731 instance.SetDestructor(&destruct_maplEintcOintgR);
03732 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,int> >()));
03733 return &instance;
03734 }
03735
03736 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
03737
03738
03739 static void maplEintcOintgR_Dictionary() {
03740 ::ROOT::GenerateInitInstanceLocal((const map<int,int>*)0x0)->GetClass();
03741 }
03742
03743 }
03744
03745 namespace ROOT {
03746
03747 static void *new_maplEintcOintgR(void *p) {
03748 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,int> : new map<int,int>;
03749 }
03750 static void *newArray_maplEintcOintgR(Long_t nElements, void *p) {
03751 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,int>[nElements] : new map<int,int>[nElements];
03752 }
03753
03754 static void delete_maplEintcOintgR(void *p) {
03755 delete ((map<int,int>*)p);
03756 }
03757 static void deleteArray_maplEintcOintgR(void *p) {
03758 delete [] ((map<int,int>*)p);
03759 }
03760 static void destruct_maplEintcOintgR(void *p) {
03761 typedef map<int,int> current_t;
03762 ((current_t*)p)->~current_t();
03763 }
03764 }
03765
03766 namespace ROOT {
03767 void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
03768 static void vectorlETStringgR_Dictionary();
03769 static void *new_vectorlETStringgR(void *p = 0);
03770 static void *newArray_vectorlETStringgR(Long_t size, void *p);
03771 static void delete_vectorlETStringgR(void *p);
03772 static void deleteArray_vectorlETStringgR(void *p);
03773 static void destruct_vectorlETStringgR(void *p);
03774
03775
03776 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
03777 {
03778 vector<TString> *ptr = 0;
03779 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
03780 static ::ROOT::TGenericClassInfo
03781 instance("vector<TString>", -2, "prec_stl/vector", 49,
03782 typeid(vector<TString>), DefineBehavior(ptr, ptr),
03783 0, &vectorlETStringgR_Dictionary, isa_proxy, 0,
03784 sizeof(vector<TString>) );
03785 instance.SetNew(&new_vectorlETStringgR);
03786 instance.SetNewArray(&newArray_vectorlETStringgR);
03787 instance.SetDelete(&delete_vectorlETStringgR);
03788 instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
03789 instance.SetDestructor(&destruct_vectorlETStringgR);
03790 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
03791 return &instance;
03792 }
03793
03794 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
03795
03796
03797 static void vectorlETStringgR_Dictionary() {
03798 ::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
03799 }
03800
03801 }
03802
03803 namespace ROOT {
03804
03805 static void *new_vectorlETStringgR(void *p) {
03806 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
03807 }
03808 static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
03809 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
03810 }
03811
03812 static void delete_vectorlETStringgR(void *p) {
03813 delete ((vector<TString>*)p);
03814 }
03815 static void deleteArray_vectorlETStringgR(void *p) {
03816 delete [] ((vector<TString>*)p);
03817 }
03818 static void destruct_vectorlETStringgR(void *p) {
03819 typedef vector<TString> current_t;
03820 ((current_t*)p)->~current_t();
03821 }
03822 }
03823
03824
03825
03826
03827
03828
03829
03830
03831 #ifdef G__MEMTEST
03832 #undef malloc
03833 #undef free
03834 #endif
03835
03836 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
03837 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
03838 #endif
03839
03840 extern "C" void G__cpp_reset_tagtableBesVisLib_rootcint();
03841
03842 extern "C" void G__set_cpp_environmentBesVisLib_rootcint() {
03843 G__add_compiledheader("TObject.h");
03844 G__add_compiledheader("TMemberInspector.h");
03845 G__add_compiledheader("../BesVisLib/Bes2DView.h");
03846 G__add_compiledheader("../BesVisLib/BesCircle2D.h");
03847 G__add_compiledheader("../BesVisLib/BesCursor.h");
03848 G__add_compiledheader("../BesVisLib/BesEvent.h");
03849 G__add_compiledheader("../BesVisLib/BesEventHeader.h");
03850 G__add_compiledheader("../BesVisLib/BesGeometry.h");
03851 G__add_compiledheader("../BesVisLib/BesGeoTrack.h");
03852 G__add_compiledheader("../BesVisLib/BesGMenuBar.h");
03853 G__add_compiledheader("../BesVisLib/BesGMenuTitle.h");
03854 G__add_compiledheader("../BesVisLib/BesGPictureButton.h");
03855 G__add_compiledheader("../BesVisLib/BesHeader.h");
03856 G__add_compiledheader("../BesVisLib/BesMarker2D.h");
03857 G__add_compiledheader("../BesVisLib/BesPaveText.h");
03858 G__add_compiledheader("../BesVisLib/BesPolygon2D.h");
03859 G__add_compiledheader("../BesVisLib/BesStatus.h");
03860 G__add_compiledheader("../BesVisLib/BesView.h");
03861 G__add_compiledheader("../BesVisLib/BesVisDisplay.h");
03862 G__add_compiledheader("../BesVisLib/Emc2DCrystal.h");
03863 G__add_compiledheader("../BesVisLib/EmcROOTGeo.h");
03864 G__add_compiledheader("../BesVisLib/Mdc2DWire.h");
03865 G__add_compiledheader("../BesVisLib/BesTView.h");
03866 G__add_compiledheader("../BesVisLib/MdcROOTGeo.h");
03867 G__add_compiledheader("../BesVisLib/Muc2DStrip.h");
03868 G__add_compiledheader("../BesVisLib/MucROOTGeo.h");
03869 G__add_compiledheader("../BesVisLib/SubDetectorROOTGeo.h");
03870 G__add_compiledheader("../BesVisLib/Tof2DScin.h");
03871 G__add_compiledheader("../BesVisLib/TofROOTGeo.h");
03872 G__add_compiledheader("../BesVisLib/ZHelix.h");
03873 G__add_compiledheader("../BesVisLib/vector3.h");
03874 G__cpp_reset_tagtableBesVisLib_rootcint();
03875 }
03876 #include <new>
03877 extern "C" int G__cpp_dllrevBesVisLib_rootcint() { return(30051515); }
03878
03879
03880
03881
03882
03883
03884 static int G__BesVisLib_rootcint_169_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03885 {
03886 BesStatus* p = NULL;
03887 char* gvp = (char*) G__getgvp();
03888 int n = G__getaryconstruct();
03889 if (n) {
03890 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03891 p = new BesStatus[n];
03892 } else {
03893 p = new((void*) gvp) BesStatus[n];
03894 }
03895 } else {
03896 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03897 p = new BesStatus;
03898 } else {
03899 p = new((void*) gvp) BesStatus;
03900 }
03901 }
03902 result7->obj.i = (long) p;
03903 result7->ref = (long) p;
03904 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
03905 return(1 || funcname || hash || result7 || libp) ;
03906 }
03907
03908 static int G__BesVisLib_rootcint_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03909 {
03910 ((BesStatus*) G__getstructoffset())->Transfer((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03911 G__setnull(result7);
03912 return(1 || funcname || hash || result7 || libp) ;
03913 }
03914
03915 static int G__BesVisLib_rootcint_169_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03916 {
03917 ((BesStatus*) G__getstructoffset())->TransferGeometryMdc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03918 G__setnull(result7);
03919 return(1 || funcname || hash || result7 || libp) ;
03920 }
03921
03922 static int G__BesVisLib_rootcint_169_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03923 {
03924 ((BesStatus*) G__getstructoffset())->TransferGeometryTof((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03925 G__setnull(result7);
03926 return(1 || funcname || hash || result7 || libp) ;
03927 }
03928
03929 static int G__BesVisLib_rootcint_169_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03930 {
03931 ((BesStatus*) G__getstructoffset())->TransferGeometryEmc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03932 G__setnull(result7);
03933 return(1 || funcname || hash || result7 || libp) ;
03934 }
03935
03936 static int G__BesVisLib_rootcint_169_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03937 {
03938 ((BesStatus*) G__getstructoffset())->TransferGeometryMuc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03939 G__setnull(result7);
03940 return(1 || funcname || hash || result7 || libp) ;
03941 }
03942
03943 static int G__BesVisLib_rootcint_169_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03944 {
03945 ((BesStatus*) G__getstructoffset())->TransferGeometryFull3D((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03946 G__setnull(result7);
03947 return(1 || funcname || hash || result7 || libp) ;
03948 }
03949
03950 static int G__BesVisLib_rootcint_169_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03951 {
03952 ((BesStatus*) G__getstructoffset())->TransferGeometryOtherParts((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03953 G__setnull(result7);
03954 return(1 || funcname || hash || result7 || libp) ;
03955 }
03956
03957 static int G__BesVisLib_rootcint_169_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03958 {
03959 ((BesStatus*) G__getstructoffset())->TransferHitsMdc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03960 G__setnull(result7);
03961 return(1 || funcname || hash || result7 || libp) ;
03962 }
03963
03964 static int G__BesVisLib_rootcint_169_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03965 {
03966 ((BesStatus*) G__getstructoffset())->TransferHitsTof((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03967 G__setnull(result7);
03968 return(1 || funcname || hash || result7 || libp) ;
03969 }
03970
03971 static int G__BesVisLib_rootcint_169_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03972 {
03973 ((BesStatus*) G__getstructoffset())->TransferHitsEmc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03974 G__setnull(result7);
03975 return(1 || funcname || hash || result7 || libp) ;
03976 }
03977
03978 static int G__BesVisLib_rootcint_169_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03979 {
03980 ((BesStatus*) G__getstructoffset())->TransferHitsMuc((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03981 G__setnull(result7);
03982 return(1 || funcname || hash || result7 || libp) ;
03983 }
03984
03985 static int G__BesVisLib_rootcint_169_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03986 {
03987 ((BesStatus*) G__getstructoffset())->TransferTracks((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03988 G__setnull(result7);
03989 return(1 || funcname || hash || result7 || libp) ;
03990 }
03991
03992 static int G__BesVisLib_rootcint_169_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03993 {
03994 ((BesStatus*) G__getstructoffset())->TransferFishEye((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03995 G__setnull(result7);
03996 return(1 || funcname || hash || result7 || libp) ;
03997 }
03998
03999 static int G__BesVisLib_rootcint_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04000 {
04001 ((BesStatus*) G__getstructoffset())->TransferPhiRange((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
04002 G__setnull(result7);
04003 return(1 || funcname || hash || result7 || libp) ;
04004 }
04005
04006 static int G__BesVisLib_rootcint_169_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04007 {
04008 ((BesStatus*) G__getstructoffset())->TransferZoom((BesStatus*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
04009 G__setnull(result7);
04010 return(1 || funcname || hash || result7 || libp) ;
04011 }
04012
04013 static int G__BesVisLib_rootcint_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04014 {
04015 ((BesStatus*) G__getstructoffset())->Default((EBESViewType) G__int(libp->para[0]));
04016 G__setnull(result7);
04017 return(1 || funcname || hash || result7 || libp) ;
04018 }
04019
04020 static int G__BesVisLib_rootcint_169_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04021 {
04022 G__letint(result7, 85, (long) BesStatus::Class());
04023 return(1 || funcname || hash || result7 || libp) ;
04024 }
04025
04026 static int G__BesVisLib_rootcint_169_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04027 {
04028 G__letint(result7, 67, (long) BesStatus::Class_Name());
04029 return(1 || funcname || hash || result7 || libp) ;
04030 }
04031
04032 static int G__BesVisLib_rootcint_169_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04033 {
04034 G__letint(result7, 115, (long) BesStatus::Class_Version());
04035 return(1 || funcname || hash || result7 || libp) ;
04036 }
04037
04038 static int G__BesVisLib_rootcint_169_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04039 {
04040 BesStatus::Dictionary();
04041 G__setnull(result7);
04042 return(1 || funcname || hash || result7 || libp) ;
04043 }
04044
04045 static int G__BesVisLib_rootcint_169_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04046 {
04047 ((BesStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04048 G__setnull(result7);
04049 return(1 || funcname || hash || result7 || libp) ;
04050 }
04051
04052 static int G__BesVisLib_rootcint_169_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04053 {
04054 G__letint(result7, 67, (long) BesStatus::DeclFileName());
04055 return(1 || funcname || hash || result7 || libp) ;
04056 }
04057
04058 static int G__BesVisLib_rootcint_169_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04059 {
04060 G__letint(result7, 105, (long) BesStatus::ImplFileLine());
04061 return(1 || funcname || hash || result7 || libp) ;
04062 }
04063
04064 static int G__BesVisLib_rootcint_169_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04065 {
04066 G__letint(result7, 67, (long) BesStatus::ImplFileName());
04067 return(1 || funcname || hash || result7 || libp) ;
04068 }
04069
04070 static int G__BesVisLib_rootcint_169_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04071 {
04072 G__letint(result7, 105, (long) BesStatus::DeclFileLine());
04073 return(1 || funcname || hash || result7 || libp) ;
04074 }
04075
04076
04077 static int G__BesVisLib_rootcint_169_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04078
04079 {
04080 BesStatus* p;
04081 void* tmp = (void*) G__int(libp->para[0]);
04082 p = new BesStatus(*(BesStatus*) tmp);
04083 result7->obj.i = (long) p;
04084 result7->ref = (long) p;
04085 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
04086 return(1 || funcname || hash || result7 || libp) ;
04087 }
04088
04089
04090 typedef BesStatus G__TBesStatus;
04091 static int G__BesVisLib_rootcint_169_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04092 {
04093 char* gvp = (char*) G__getgvp();
04094 long soff = G__getstructoffset();
04095 int n = G__getaryconstruct();
04096
04097
04098
04099
04100
04101 if (!soff) {
04102 return(1);
04103 }
04104 if (n) {
04105 if (gvp == (char*)G__PVOID) {
04106 delete[] (BesStatus*) soff;
04107 } else {
04108 G__setgvp((long) G__PVOID);
04109 for (int i = n - 1; i >= 0; --i) {
04110 ((BesStatus*) (soff+(sizeof(BesStatus)*i)))->~G__TBesStatus();
04111 }
04112 G__setgvp((long)gvp);
04113 }
04114 } else {
04115 if (gvp == (char*)G__PVOID) {
04116 delete (BesStatus*) soff;
04117 } else {
04118 G__setgvp((long) G__PVOID);
04119 ((BesStatus*) (soff))->~G__TBesStatus();
04120 G__setgvp((long)gvp);
04121 }
04122 }
04123 G__setnull(result7);
04124 return(1 || funcname || hash || result7 || libp) ;
04125 }
04126
04127
04128 static int G__BesVisLib_rootcint_169_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04129 {
04130 BesStatus* dest = (BesStatus*) G__getstructoffset();
04131 *dest = *(BesStatus*) libp->para[0].ref;
04132 const BesStatus& obj = *dest;
04133 result7->ref = (long) (&obj);
04134 result7->obj.i = (long) (&obj);
04135 return(1 || funcname || hash || result7 || libp) ;
04136 }
04137
04138
04139
04140 static int G__BesVisLib_rootcint_175_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04141 {
04142 BesTView* p = NULL;
04143 char* gvp = (char*) G__getgvp();
04144 int n = G__getaryconstruct();
04145 if (n) {
04146 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04147 p = new BesTView[n];
04148 } else {
04149 p = new((void*) gvp) BesTView[n];
04150 }
04151 } else {
04152 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04153 p = new BesTView;
04154 } else {
04155 p = new((void*) gvp) BesTView;
04156 }
04157 }
04158 result7->obj.i = (long) p;
04159 result7->ref = (long) p;
04160 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
04161 return(1 || funcname || hash || result7 || libp) ;
04162 }
04163
04164 static int G__BesVisLib_rootcint_175_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04165 {
04166 BesTView* p = NULL;
04167 char* gvp = (char*) G__getgvp();
04168
04169 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04170 p = new BesTView((Int_t) G__int(libp->para[0]));
04171 } else {
04172 p = new((void*) gvp) BesTView((Int_t) G__int(libp->para[0]));
04173 }
04174 result7->obj.i = (long) p;
04175 result7->ref = (long) p;
04176 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
04177 return(1 || funcname || hash || result7 || libp) ;
04178 }
04179
04180 static int G__BesVisLib_rootcint_175_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04181 {
04182 BesTView* p = NULL;
04183 char* gvp = (char*) G__getgvp();
04184 switch (libp->paran) {
04185 case 3:
04186
04187 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04188 p = new BesTView(
04189 (Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
04190 , (Int_t) G__int(libp->para[2]));
04191 } else {
04192 p = new((void*) gvp) BesTView(
04193 (Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
04194 , (Int_t) G__int(libp->para[2]));
04195 }
04196 break;
04197 case 2:
04198
04199 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04200 p = new BesTView((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
04201 } else {
04202 p = new((void*) gvp) BesTView((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
04203 }
04204 break;
04205 }
04206 result7->obj.i = (long) p;
04207 result7->ref = (long) p;
04208 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
04209 return(1 || funcname || hash || result7 || libp) ;
04210 }
04211
04212 static int G__BesVisLib_rootcint_175_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04213 {
04214 BesTView* p = NULL;
04215 char* gvp = (char*) G__getgvp();
04216 switch (libp->paran) {
04217 case 3:
04218
04219 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04220 p = new BesTView(
04221 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
04222 , (Int_t) G__int(libp->para[2]));
04223 } else {
04224 p = new((void*) gvp) BesTView(
04225 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
04226 , (Int_t) G__int(libp->para[2]));
04227 }
04228 break;
04229 case 2:
04230
04231 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04232 p = new BesTView((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
04233 } else {
04234 p = new((void*) gvp) BesTView((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
04235 }
04236 break;
04237 }
04238 result7->obj.i = (long) p;
04239 result7->ref = (long) p;
04240 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
04241 return(1 || funcname || hash || result7 || libp) ;
04242 }
04243
04244 static int G__BesVisLib_rootcint_175_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04245 {
04246 switch (libp->paran) {
04247 case 1:
04248 BesTView::AdjustPad((TVirtualPad*) G__int(libp->para[0]));
04249 G__setnull(result7);
04250 break;
04251 case 0:
04252 BesTView::AdjustPad();
04253 G__setnull(result7);
04254 break;
04255 }
04256 return(1 || funcname || hash || result7 || libp) ;
04257 }
04258
04259 static int G__BesVisLib_rootcint_175_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04260 {
04261 G__letint(result7, 85, (long) BesTView::Class());
04262 return(1 || funcname || hash || result7 || libp) ;
04263 }
04264
04265 static int G__BesVisLib_rootcint_175_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04266 {
04267 G__letint(result7, 67, (long) BesTView::Class_Name());
04268 return(1 || funcname || hash || result7 || libp) ;
04269 }
04270
04271 static int G__BesVisLib_rootcint_175_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04272 {
04273 G__letint(result7, 115, (long) BesTView::Class_Version());
04274 return(1 || funcname || hash || result7 || libp) ;
04275 }
04276
04277 static int G__BesVisLib_rootcint_175_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04278 {
04279 BesTView::Dictionary();
04280 G__setnull(result7);
04281 return(1 || funcname || hash || result7 || libp) ;
04282 }
04283
04284 static int G__BesVisLib_rootcint_175_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04285 {
04286 ((BesTView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04287 G__setnull(result7);
04288 return(1 || funcname || hash || result7 || libp) ;
04289 }
04290
04291 static int G__BesVisLib_rootcint_175_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04292 {
04293 G__letint(result7, 67, (long) BesTView::DeclFileName());
04294 return(1 || funcname || hash || result7 || libp) ;
04295 }
04296
04297 static int G__BesVisLib_rootcint_175_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04298 {
04299 G__letint(result7, 105, (long) BesTView::ImplFileLine());
04300 return(1 || funcname || hash || result7 || libp) ;
04301 }
04302
04303 static int G__BesVisLib_rootcint_175_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04304 {
04305 G__letint(result7, 67, (long) BesTView::ImplFileName());
04306 return(1 || funcname || hash || result7 || libp) ;
04307 }
04308
04309 static int G__BesVisLib_rootcint_175_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04310 {
04311 G__letint(result7, 105, (long) BesTView::DeclFileLine());
04312 return(1 || funcname || hash || result7 || libp) ;
04313 }
04314
04315
04316 typedef BesTView G__TBesTView;
04317 static int G__BesVisLib_rootcint_175_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04318 {
04319 char* gvp = (char*) G__getgvp();
04320 long soff = G__getstructoffset();
04321 int n = G__getaryconstruct();
04322
04323
04324
04325
04326
04327 if (!soff) {
04328 return(1);
04329 }
04330 if (n) {
04331 if (gvp == (char*)G__PVOID) {
04332 delete[] (BesTView*) soff;
04333 } else {
04334 G__setgvp((long) G__PVOID);
04335 for (int i = n - 1; i >= 0; --i) {
04336 ((BesTView*) (soff+(sizeof(BesTView)*i)))->~G__TBesTView();
04337 }
04338 G__setgvp((long)gvp);
04339 }
04340 } else {
04341 if (gvp == (char*)G__PVOID) {
04342 delete (BesTView*) soff;
04343 } else {
04344 G__setgvp((long) G__PVOID);
04345 ((BesTView*) (soff))->~G__TBesTView();
04346 G__setgvp((long)gvp);
04347 }
04348 }
04349 G__setnull(result7);
04350 return(1 || funcname || hash || result7 || libp) ;
04351 }
04352
04353
04354
04355 static int G__BesVisLib_rootcint_182_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04356 {
04357 Bes2DView* p = NULL;
04358 char* gvp = (char*) G__getgvp();
04359 int n = G__getaryconstruct();
04360 if (n) {
04361 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04362 p = new Bes2DView[n];
04363 } else {
04364 p = new((void*) gvp) Bes2DView[n];
04365 }
04366 } else {
04367 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04368 p = new Bes2DView;
04369 } else {
04370 p = new((void*) gvp) Bes2DView;
04371 }
04372 }
04373 result7->obj.i = (long) p;
04374 result7->ref = (long) p;
04375 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
04376 return(1 || funcname || hash || result7 || libp) ;
04377 }
04378
04379 static int G__BesVisLib_rootcint_182_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04380 {
04381 ((Bes2DView*) G__getstructoffset())->ClearPad();
04382 G__setnull(result7);
04383 return(1 || funcname || hash || result7 || libp) ;
04384 }
04385
04386 static int G__BesVisLib_rootcint_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04387 {
04388 ((Bes2DView*) G__getstructoffset())->DrawLabel();
04389 G__setnull(result7);
04390 return(1 || funcname || hash || result7 || libp) ;
04391 }
04392
04393 static int G__BesVisLib_rootcint_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04394 {
04395 G__letint(result7, 105, (long) ((Bes2DView*) G__getstructoffset())->GetRSign((Float_t) G__double(libp->para[0])));
04396 return(1 || funcname || hash || result7 || libp) ;
04397 }
04398
04399 static int G__BesVisLib_rootcint_182_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04400 {
04401 switch (libp->paran) {
04402 case 1:
04403 ((Bes2DView*) G__getstructoffset())->UpdateView((Bool_t) G__int(libp->para[0]));
04404 G__setnull(result7);
04405 break;
04406 case 0:
04407 ((Bes2DView*) G__getstructoffset())->UpdateView();
04408 G__setnull(result7);
04409 break;
04410 }
04411 return(1 || funcname || hash || result7 || libp) ;
04412 }
04413
04414 static int G__BesVisLib_rootcint_182_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04415 {
04416 ((Bes2DView*) G__getstructoffset())->Set2DViewType((Int_t) G__int(libp->para[0]));
04417 G__setnull(result7);
04418 return(1 || funcname || hash || result7 || libp) ;
04419 }
04420
04421 static int G__BesVisLib_rootcint_182_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04422 {
04423 G__letint(result7, 105, (long) ((Bes2DView*) G__getstructoffset())->Get2DViewType());
04424 return(1 || funcname || hash || result7 || libp) ;
04425 }
04426
04427 static int G__BesVisLib_rootcint_182_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04428 {
04429 G__letdouble(result7, 102, (double) ((Bes2DView*) G__getstructoffset())->GetMarkerSize());
04430 return(1 || funcname || hash || result7 || libp) ;
04431 }
04432
04433 static int G__BesVisLib_rootcint_182_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04434 {
04435 ((Bes2DView*) G__getstructoffset())->Center();
04436 G__setnull(result7);
04437 return(1 || funcname || hash || result7 || libp) ;
04438 }
04439
04440 static int G__BesVisLib_rootcint_182_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04441 {
04442 ((Bes2DView*) G__getstructoffset())->Move((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04443 G__setnull(result7);
04444 return(1 || funcname || hash || result7 || libp) ;
04445 }
04446
04447 static int G__BesVisLib_rootcint_182_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04448 {
04449 ((Bes2DView*) G__getstructoffset())->Reset();
04450 G__setnull(result7);
04451 return(1 || funcname || hash || result7 || libp) ;
04452 }
04453
04454 static int G__BesVisLib_rootcint_182_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04455 {
04456 ((Bes2DView*) G__getstructoffset())->SetMarkerSize((Float_t) G__double(libp->para[0]));
04457 G__setnull(result7);
04458 return(1 || funcname || hash || result7 || libp) ;
04459 }
04460
04461 static int G__BesVisLib_rootcint_182_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04462 {
04463 G__letint(result7, 103, (long) ((Bes2DView*) G__getstructoffset())->GetFishEyeStatus());
04464 return(1 || funcname || hash || result7 || libp) ;
04465 }
04466
04467 static int G__BesVisLib_rootcint_182_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04468 {
04469 G__letint(result7, 103, (long) ((Bes2DView*) G__getstructoffset())->GetFishEye());
04470 return(1 || funcname || hash || result7 || libp) ;
04471 }
04472
04473 static int G__BesVisLib_rootcint_182_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04474 {
04475 switch (libp->paran) {
04476 case 1:
04477 ((Bes2DView*) G__getstructoffset())->SetFishEye((Bool_t) G__int(libp->para[0]));
04478 G__setnull(result7);
04479 break;
04480 case 0:
04481 ((Bes2DView*) G__getstructoffset())->SetFishEye();
04482 G__setnull(result7);
04483 break;
04484 }
04485 return(1 || funcname || hash || result7 || libp) ;
04486 }
04487
04488 static int G__BesVisLib_rootcint_182_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04489 {
04490 ((Bes2DView*) G__getstructoffset())->PrintCurrent();
04491 G__setnull(result7);
04492 return(1 || funcname || hash || result7 || libp) ;
04493 }
04494
04495 static int G__BesVisLib_rootcint_182_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04496 {
04497 ((Bes2DView*) G__getstructoffset())->DrawClass();
04498 G__setnull(result7);
04499 return(1 || funcname || hash || result7 || libp) ;
04500 }
04501
04502 static int G__BesVisLib_rootcint_182_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04503 {
04504 G__letint(result7, 85, (long) ((Bes2DView*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
04505 return(1 || funcname || hash || result7 || libp) ;
04506 }
04507
04508 static int G__BesVisLib_rootcint_182_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04509 {
04510 ((Bes2DView*) G__getstructoffset())->Dump();
04511 G__setnull(result7);
04512 return(1 || funcname || hash || result7 || libp) ;
04513 }
04514
04515 static int G__BesVisLib_rootcint_182_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04516 {
04517 ((Bes2DView*) G__getstructoffset())->Inspect();
04518 G__setnull(result7);
04519 return(1 || funcname || hash || result7 || libp) ;
04520 }
04521
04522 static int G__BesVisLib_rootcint_182_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04523 {
04524 ((Bes2DView*) G__getstructoffset())->SetZoomFactor((Double_t) G__double(libp->para[0]));
04525 G__setnull(result7);
04526 return(1 || funcname || hash || result7 || libp) ;
04527 }
04528
04529 static int G__BesVisLib_rootcint_182_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04530 {
04531 G__letdouble(result7, 100, (double) ((Bes2DView*) G__getstructoffset())->GetZoomFactor());
04532 return(1 || funcname || hash || result7 || libp) ;
04533 }
04534
04535 static int G__BesVisLib_rootcint_182_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04536 {
04537 G__letint(result7, 85, (long) ((Bes2DView*) G__getstructoffset())->GetStatusCurrent());
04538 return(1 || funcname || hash || result7 || libp) ;
04539 }
04540
04541 static int G__BesVisLib_rootcint_182_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04542 {
04543 G__letint(result7, 85, (long) Bes2DView::Class());
04544 return(1 || funcname || hash || result7 || libp) ;
04545 }
04546
04547 static int G__BesVisLib_rootcint_182_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04548 {
04549 G__letint(result7, 67, (long) Bes2DView::Class_Name());
04550 return(1 || funcname || hash || result7 || libp) ;
04551 }
04552
04553 static int G__BesVisLib_rootcint_182_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04554 {
04555 G__letint(result7, 115, (long) Bes2DView::Class_Version());
04556 return(1 || funcname || hash || result7 || libp) ;
04557 }
04558
04559 static int G__BesVisLib_rootcint_182_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04560 {
04561 Bes2DView::Dictionary();
04562 G__setnull(result7);
04563 return(1 || funcname || hash || result7 || libp) ;
04564 }
04565
04566 static int G__BesVisLib_rootcint_182_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04567 {
04568 ((Bes2DView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04569 G__setnull(result7);
04570 return(1 || funcname || hash || result7 || libp) ;
04571 }
04572
04573 static int G__BesVisLib_rootcint_182_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04574 {
04575 G__letint(result7, 67, (long) Bes2DView::DeclFileName());
04576 return(1 || funcname || hash || result7 || libp) ;
04577 }
04578
04579 static int G__BesVisLib_rootcint_182_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04580 {
04581 G__letint(result7, 105, (long) Bes2DView::ImplFileLine());
04582 return(1 || funcname || hash || result7 || libp) ;
04583 }
04584
04585 static int G__BesVisLib_rootcint_182_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04586 {
04587 G__letint(result7, 67, (long) Bes2DView::ImplFileName());
04588 return(1 || funcname || hash || result7 || libp) ;
04589 }
04590
04591 static int G__BesVisLib_rootcint_182_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04592 {
04593 G__letint(result7, 105, (long) Bes2DView::DeclFileLine());
04594 return(1 || funcname || hash || result7 || libp) ;
04595 }
04596
04597
04598 static int G__BesVisLib_rootcint_182_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04599
04600 {
04601 Bes2DView* p;
04602 void* tmp = (void*) G__int(libp->para[0]);
04603 p = new Bes2DView(*(Bes2DView*) tmp);
04604 result7->obj.i = (long) p;
04605 result7->ref = (long) p;
04606 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
04607 return(1 || funcname || hash || result7 || libp) ;
04608 }
04609
04610
04611 typedef Bes2DView G__TBes2DView;
04612 static int G__BesVisLib_rootcint_182_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04613 {
04614 char* gvp = (char*) G__getgvp();
04615 long soff = G__getstructoffset();
04616 int n = G__getaryconstruct();
04617
04618
04619
04620
04621
04622 if (!soff) {
04623 return(1);
04624 }
04625 if (n) {
04626 if (gvp == (char*)G__PVOID) {
04627 delete[] (Bes2DView*) soff;
04628 } else {
04629 G__setgvp((long) G__PVOID);
04630 for (int i = n - 1; i >= 0; --i) {
04631 ((Bes2DView*) (soff+(sizeof(Bes2DView)*i)))->~G__TBes2DView();
04632 }
04633 G__setgvp((long)gvp);
04634 }
04635 } else {
04636 if (gvp == (char*)G__PVOID) {
04637 delete (Bes2DView*) soff;
04638 } else {
04639 G__setgvp((long) G__PVOID);
04640 ((Bes2DView*) (soff))->~G__TBes2DView();
04641 G__setgvp((long)gvp);
04642 }
04643 }
04644 G__setnull(result7);
04645 return(1 || funcname || hash || result7 || libp) ;
04646 }
04647
04648
04649
04650 static int G__BesVisLib_rootcint_199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04651 {
04652 BesCircle2D* p = NULL;
04653 char* gvp = (char*) G__getgvp();
04654 int n = G__getaryconstruct();
04655 if (n) {
04656 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04657 p = new BesCircle2D[n];
04658 } else {
04659 p = new((void*) gvp) BesCircle2D[n];
04660 }
04661 } else {
04662 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04663 p = new BesCircle2D;
04664 } else {
04665 p = new((void*) gvp) BesCircle2D;
04666 }
04667 }
04668 result7->obj.i = (long) p;
04669 result7->ref = (long) p;
04670 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
04671 return(1 || funcname || hash || result7 || libp) ;
04672 }
04673
04674 static int G__BesVisLib_rootcint_199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04675 {
04676 BesCircle2D* p = NULL;
04677 char* gvp = (char*) G__getgvp();
04678
04679 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04680 p = new BesCircle2D(
04681 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04682 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
04683 , (Double_t*) G__int(libp->para[4]));
04684 } else {
04685 p = new((void*) gvp) BesCircle2D(
04686 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04687 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
04688 , (Double_t*) G__int(libp->para[4]));
04689 }
04690 result7->obj.i = (long) p;
04691 result7->ref = (long) p;
04692 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
04693 return(1 || funcname || hash || result7 || libp) ;
04694 }
04695
04696 static int G__BesVisLib_rootcint_199_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04697 {
04698 ((BesCircle2D*) G__getstructoffset())->SetCenter((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
04699 , (Double_t) G__double(libp->para[2]));
04700 G__setnull(result7);
04701 return(1 || funcname || hash || result7 || libp) ;
04702 }
04703
04704 static int G__BesVisLib_rootcint_199_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04705 {
04706 ((BesCircle2D*) G__getstructoffset())->GetCenter((Double_t*) G__int(libp->para[0]));
04707 G__setnull(result7);
04708 return(1 || funcname || hash || result7 || libp) ;
04709 }
04710
04711 static int G__BesVisLib_rootcint_199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04712 {
04713 ((BesCircle2D*) G__getstructoffset())->SetNSegment((Int_t) G__int(libp->para[0]));
04714 G__setnull(result7);
04715 return(1 || funcname || hash || result7 || libp) ;
04716 }
04717
04718 static int G__BesVisLib_rootcint_199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04719 {
04720 G__letint(result7, 85, (long) BesCircle2D::Class());
04721 return(1 || funcname || hash || result7 || libp) ;
04722 }
04723
04724 static int G__BesVisLib_rootcint_199_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04725 {
04726 G__letint(result7, 67, (long) BesCircle2D::Class_Name());
04727 return(1 || funcname || hash || result7 || libp) ;
04728 }
04729
04730 static int G__BesVisLib_rootcint_199_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04731 {
04732 G__letint(result7, 115, (long) BesCircle2D::Class_Version());
04733 return(1 || funcname || hash || result7 || libp) ;
04734 }
04735
04736 static int G__BesVisLib_rootcint_199_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04737 {
04738 BesCircle2D::Dictionary();
04739 G__setnull(result7);
04740 return(1 || funcname || hash || result7 || libp) ;
04741 }
04742
04743 static int G__BesVisLib_rootcint_199_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04744 {
04745 ((BesCircle2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04746 G__setnull(result7);
04747 return(1 || funcname || hash || result7 || libp) ;
04748 }
04749
04750 static int G__BesVisLib_rootcint_199_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04751 {
04752 G__letint(result7, 67, (long) BesCircle2D::DeclFileName());
04753 return(1 || funcname || hash || result7 || libp) ;
04754 }
04755
04756 static int G__BesVisLib_rootcint_199_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04757 {
04758 G__letint(result7, 105, (long) BesCircle2D::ImplFileLine());
04759 return(1 || funcname || hash || result7 || libp) ;
04760 }
04761
04762 static int G__BesVisLib_rootcint_199_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04763 {
04764 G__letint(result7, 67, (long) BesCircle2D::ImplFileName());
04765 return(1 || funcname || hash || result7 || libp) ;
04766 }
04767
04768 static int G__BesVisLib_rootcint_199_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04769 {
04770 G__letint(result7, 105, (long) BesCircle2D::DeclFileLine());
04771 return(1 || funcname || hash || result7 || libp) ;
04772 }
04773
04774
04775 static int G__BesVisLib_rootcint_199_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04776
04777 {
04778 BesCircle2D* p;
04779 void* tmp = (void*) G__int(libp->para[0]);
04780 p = new BesCircle2D(*(BesCircle2D*) tmp);
04781 result7->obj.i = (long) p;
04782 result7->ref = (long) p;
04783 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
04784 return(1 || funcname || hash || result7 || libp) ;
04785 }
04786
04787
04788 typedef BesCircle2D G__TBesCircle2D;
04789 static int G__BesVisLib_rootcint_199_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04790 {
04791 char* gvp = (char*) G__getgvp();
04792 long soff = G__getstructoffset();
04793 int n = G__getaryconstruct();
04794
04795
04796
04797
04798
04799 if (!soff) {
04800 return(1);
04801 }
04802 if (n) {
04803 if (gvp == (char*)G__PVOID) {
04804 delete[] (BesCircle2D*) soff;
04805 } else {
04806 G__setgvp((long) G__PVOID);
04807 for (int i = n - 1; i >= 0; --i) {
04808 ((BesCircle2D*) (soff+(sizeof(BesCircle2D)*i)))->~G__TBesCircle2D();
04809 }
04810 G__setgvp((long)gvp);
04811 }
04812 } else {
04813 if (gvp == (char*)G__PVOID) {
04814 delete (BesCircle2D*) soff;
04815 } else {
04816 G__setgvp((long) G__PVOID);
04817 ((BesCircle2D*) (soff))->~G__TBesCircle2D();
04818 G__setgvp((long)gvp);
04819 }
04820 }
04821 G__setnull(result7);
04822 return(1 || funcname || hash || result7 || libp) ;
04823 }
04824
04825
04826 static int G__BesVisLib_rootcint_199_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04827 {
04828 BesCircle2D* dest = (BesCircle2D*) G__getstructoffset();
04829 *dest = *(BesCircle2D*) libp->para[0].ref;
04830 const BesCircle2D& obj = *dest;
04831 result7->ref = (long) (&obj);
04832 result7->obj.i = (long) (&obj);
04833 return(1 || funcname || hash || result7 || libp) ;
04834 }
04835
04836
04837
04838 static int G__BesVisLib_rootcint_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04839 {
04840 BesCursor* p = NULL;
04841 char* gvp = (char*) G__getgvp();
04842 int n = G__getaryconstruct();
04843 if (n) {
04844 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04845 p = new BesCursor[n];
04846 } else {
04847 p = new((void*) gvp) BesCursor[n];
04848 }
04849 } else {
04850 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04851 p = new BesCursor;
04852 } else {
04853 p = new((void*) gvp) BesCursor;
04854 }
04855 }
04856 result7->obj.i = (long) p;
04857 result7->ref = (long) p;
04858 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
04859 return(1 || funcname || hash || result7 || libp) ;
04860 }
04861
04862 static int G__BesVisLib_rootcint_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04863 {
04864 ((BesCursor*) G__getstructoffset())->SetType((EBESCursorType) G__int(libp->para[0]));
04865 G__setnull(result7);
04866 return(1 || funcname || hash || result7 || libp) ;
04867 }
04868
04869 static int G__BesVisLib_rootcint_201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04870 {
04871 G__letint(result7, 105, (long) ((BesCursor*) G__getstructoffset())->GetType());
04872 return(1 || funcname || hash || result7 || libp) ;
04873 }
04874
04875 static int G__BesVisLib_rootcint_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04876 {
04877 ((BesCursor*) G__getstructoffset())->SetShowInfo((Bool_t) G__int(libp->para[0]));
04878 G__setnull(result7);
04879 return(1 || funcname || hash || result7 || libp) ;
04880 }
04881
04882 static int G__BesVisLib_rootcint_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04883 {
04884 G__letint(result7, 103, (long) ((BesCursor*) G__getstructoffset())->GetShowInfo());
04885 return(1 || funcname || hash || result7 || libp) ;
04886 }
04887
04888 static int G__BesVisLib_rootcint_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04889 {
04890 G__letint(result7, 85, (long) BesCursor::Class());
04891 return(1 || funcname || hash || result7 || libp) ;
04892 }
04893
04894 static int G__BesVisLib_rootcint_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04895 {
04896 G__letint(result7, 67, (long) BesCursor::Class_Name());
04897 return(1 || funcname || hash || result7 || libp) ;
04898 }
04899
04900 static int G__BesVisLib_rootcint_201_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04901 {
04902 G__letint(result7, 115, (long) BesCursor::Class_Version());
04903 return(1 || funcname || hash || result7 || libp) ;
04904 }
04905
04906 static int G__BesVisLib_rootcint_201_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04907 {
04908 BesCursor::Dictionary();
04909 G__setnull(result7);
04910 return(1 || funcname || hash || result7 || libp) ;
04911 }
04912
04913 static int G__BesVisLib_rootcint_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04914 {
04915 ((BesCursor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04916 G__setnull(result7);
04917 return(1 || funcname || hash || result7 || libp) ;
04918 }
04919
04920 static int G__BesVisLib_rootcint_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04921 {
04922 G__letint(result7, 67, (long) BesCursor::DeclFileName());
04923 return(1 || funcname || hash || result7 || libp) ;
04924 }
04925
04926 static int G__BesVisLib_rootcint_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04927 {
04928 G__letint(result7, 105, (long) BesCursor::ImplFileLine());
04929 return(1 || funcname || hash || result7 || libp) ;
04930 }
04931
04932 static int G__BesVisLib_rootcint_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04933 {
04934 G__letint(result7, 67, (long) BesCursor::ImplFileName());
04935 return(1 || funcname || hash || result7 || libp) ;
04936 }
04937
04938 static int G__BesVisLib_rootcint_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04939 {
04940 G__letint(result7, 105, (long) BesCursor::DeclFileLine());
04941 return(1 || funcname || hash || result7 || libp) ;
04942 }
04943
04944
04945 static int G__BesVisLib_rootcint_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04946
04947 {
04948 BesCursor* p;
04949 void* tmp = (void*) G__int(libp->para[0]);
04950 p = new BesCursor(*(BesCursor*) tmp);
04951 result7->obj.i = (long) p;
04952 result7->ref = (long) p;
04953 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
04954 return(1 || funcname || hash || result7 || libp) ;
04955 }
04956
04957
04958 typedef BesCursor G__TBesCursor;
04959 static int G__BesVisLib_rootcint_201_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04960 {
04961 char* gvp = (char*) G__getgvp();
04962 long soff = G__getstructoffset();
04963 int n = G__getaryconstruct();
04964
04965
04966
04967
04968
04969 if (!soff) {
04970 return(1);
04971 }
04972 if (n) {
04973 if (gvp == (char*)G__PVOID) {
04974 delete[] (BesCursor*) soff;
04975 } else {
04976 G__setgvp((long) G__PVOID);
04977 for (int i = n - 1; i >= 0; --i) {
04978 ((BesCursor*) (soff+(sizeof(BesCursor)*i)))->~G__TBesCursor();
04979 }
04980 G__setgvp((long)gvp);
04981 }
04982 } else {
04983 if (gvp == (char*)G__PVOID) {
04984 delete (BesCursor*) soff;
04985 } else {
04986 G__setgvp((long) G__PVOID);
04987 ((BesCursor*) (soff))->~G__TBesCursor();
04988 G__setgvp((long)gvp);
04989 }
04990 }
04991 G__setnull(result7);
04992 return(1 || funcname || hash || result7 || libp) ;
04993 }
04994
04995
04996 static int G__BesVisLib_rootcint_201_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04997 {
04998 BesCursor* dest = (BesCursor*) G__getstructoffset();
04999 *dest = *(BesCursor*) libp->para[0].ref;
05000 const BesCursor& obj = *dest;
05001 result7->ref = (long) (&obj);
05002 result7->obj.i = (long) (&obj);
05003 return(1 || funcname || hash || result7 || libp) ;
05004 }
05005
05006
05007
05008 static int G__BesVisLib_rootcint_202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05009 {
05010 BesEventHeader* p = NULL;
05011 char* gvp = (char*) G__getgvp();
05012 int n = G__getaryconstruct();
05013 if (n) {
05014 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05015 p = new BesEventHeader[n];
05016 } else {
05017 p = new((void*) gvp) BesEventHeader[n];
05018 }
05019 } else {
05020 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05021 p = new BesEventHeader;
05022 } else {
05023 p = new((void*) gvp) BesEventHeader;
05024 }
05025 }
05026 result7->obj.i = (long) p;
05027 result7->ref = (long) p;
05028 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
05029 return(1 || funcname || hash || result7 || libp) ;
05030 }
05031
05032 static int G__BesVisLib_rootcint_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05033 {
05034 ((BesEventHeader*) G__getstructoffset())->SetEventHeaderGeneral((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
05035 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05036 G__setnull(result7);
05037 return(1 || funcname || hash || result7 || libp) ;
05038 }
05039
05040 static int G__BesVisLib_rootcint_202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05041 {
05042 ((BesEventHeader*) G__getstructoffset())->SetEventTrig((Int_t) G__int(libp->para[0]), *(vector<Int_t>*) libp->para[1].ref
05043 , *(vector<Int_t>*) libp->para[2].ref);
05044 G__setnull(result7);
05045 return(1 || funcname || hash || result7 || libp) ;
05046 }
05047
05048 static int G__BesVisLib_rootcint_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05049 {
05050 ((BesEventHeader*) G__getstructoffset())->SetEventMC((Bool_t) G__int(libp->para[0]));
05051 G__setnull(result7);
05052 return(1 || funcname || hash || result7 || libp) ;
05053 }
05054
05055 static int G__BesVisLib_rootcint_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05056 {
05057 ((BesEventHeader*) G__getstructoffset())->SetEventEvTime((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
05058 , (Double_t) G__double(libp->para[2]));
05059 G__setnull(result7);
05060 return(1 || funcname || hash || result7 || libp) ;
05061 }
05062
05063 static int G__BesVisLib_rootcint_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05064 {
05065 ((BesEventHeader*) G__getstructoffset())->SetEventMdc((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
05066 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
05067 , (Double_t) G__double(libp->para[4]));
05068 G__setnull(result7);
05069 return(1 || funcname || hash || result7 || libp) ;
05070 }
05071
05072 static int G__BesVisLib_rootcint_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05073 {
05074 ((BesEventHeader*) G__getstructoffset())->SetEventTof((Double_t) G__double(libp->para[0]));
05075 G__setnull(result7);
05076 return(1 || funcname || hash || result7 || libp) ;
05077 }
05078
05079 static int G__BesVisLib_rootcint_202_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05080 {
05081 ((BesEventHeader*) G__getstructoffset())->SetEventEmc((Double_t) G__double(libp->para[0]));
05082 G__setnull(result7);
05083 return(1 || funcname || hash || result7 || libp) ;
05084 }
05085
05086 static int G__BesVisLib_rootcint_202_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05087 {
05088 switch (libp->paran) {
05089 case 4:
05090 ((const BesEventHeader*) G__getstructoffset())->PrintWord(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
05091 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05092 G__setnull(result7);
05093 break;
05094 case 3:
05095 ((const BesEventHeader*) G__getstructoffset())->PrintWord(*(TString*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
05096 , (Int_t) G__int(libp->para[2]));
05097 G__setnull(result7);
05098 break;
05099 }
05100 return(1 || funcname || hash || result7 || libp) ;
05101 }
05102
05103 static int G__BesVisLib_rootcint_202_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05104 {
05105 G__letLonglong(result7, 110, (G__int64) ((BesEventHeader*) G__getstructoffset())->GetRunNumber());
05106 return(1 || funcname || hash || result7 || libp) ;
05107 }
05108
05109 static int G__BesVisLib_rootcint_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05110 {
05111 G__letLonglong(result7, 110, (G__int64) ((BesEventHeader*) G__getstructoffset())->GetEventNumber());
05112 return(1 || funcname || hash || result7 || libp) ;
05113 }
05114
05115 static int G__BesVisLib_rootcint_202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05116 {
05117 G__letint(result7, 103, (long) ((BesEventHeader*) G__getstructoffset())->GetEventMC());
05118 return(1 || funcname || hash || result7 || libp) ;
05119 }
05120
05121 static int G__BesVisLib_rootcint_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05122 {
05123 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetTimeType());
05124 return(1 || funcname || hash || result7 || libp) ;
05125 }
05126
05127 static int G__BesVisLib_rootcint_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05128 {
05129 {
05130 const vector<Int_t>& obj = ((BesEventHeader*) G__getstructoffset())->GetTrigChannelVector();
05131 result7->ref = (long) (&obj);
05132 result7->obj.i = (long) (&obj);
05133 }
05134 return(1 || funcname || hash || result7 || libp) ;
05135 }
05136
05137 static int G__BesVisLib_rootcint_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05138 {
05139 {
05140 const vector<Int_t>& obj = ((BesEventHeader*) G__getstructoffset())->GetTrigConditionVector();
05141 result7->ref = (long) (&obj);
05142 result7->obj.i = (long) (&obj);
05143 }
05144 return(1 || funcname || hash || result7 || libp) ;
05145 }
05146
05147 static int G__BesVisLib_rootcint_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05148 {
05149 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventYear());
05150 return(1 || funcname || hash || result7 || libp) ;
05151 }
05152
05153 static int G__BesVisLib_rootcint_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05154 {
05155 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventMonth());
05156 return(1 || funcname || hash || result7 || libp) ;
05157 }
05158
05159 static int G__BesVisLib_rootcint_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05160 {
05161 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventDay());
05162 return(1 || funcname || hash || result7 || libp) ;
05163 }
05164
05165 static int G__BesVisLib_rootcint_202_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05166 {
05167 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventHour());
05168 return(1 || funcname || hash || result7 || libp) ;
05169 }
05170
05171 static int G__BesVisLib_rootcint_202_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05172 {
05173 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventMin());
05174 return(1 || funcname || hash || result7 || libp) ;
05175 }
05176
05177 static int G__BesVisLib_rootcint_202_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05178 {
05179 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEventSec());
05180 return(1 || funcname || hash || result7 || libp) ;
05181 }
05182
05183 static int G__BesVisLib_rootcint_202_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05184 {
05185 G__letdouble(result7, 100, (double) ((BesEventHeader*) G__getstructoffset())->GetEvTime());
05186 return(1 || funcname || hash || result7 || libp) ;
05187 }
05188
05189 static int G__BesVisLib_rootcint_202_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05190 {
05191 G__letint(result7, 105, (long) ((BesEventHeader*) G__getstructoffset())->GetEvTimeStatus());
05192 return(1 || funcname || hash || result7 || libp) ;
05193 }
05194
05195 static int G__BesVisLib_rootcint_202_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05196 {
05197 G__letdouble(result7, 100, (double) ((BesEventHeader*) G__getstructoffset())->GetEvTimeQuality());
05198 return(1 || funcname || hash || result7 || libp) ;
05199 }
05200
05201 static int G__BesVisLib_rootcint_202_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05202 {
05203 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetP());
05204 return(1 || funcname || hash || result7 || libp) ;
05205 }
05206
05207 static int G__BesVisLib_rootcint_202_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05208 {
05209 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPt());
05210 return(1 || funcname || hash || result7 || libp) ;
05211 }
05212
05213 static int G__BesVisLib_rootcint_202_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05214 {
05215 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPx());
05216 return(1 || funcname || hash || result7 || libp) ;
05217 }
05218
05219 static int G__BesVisLib_rootcint_202_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05220 {
05221 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPy());
05222 return(1 || funcname || hash || result7 || libp) ;
05223 }
05224
05225 static int G__BesVisLib_rootcint_202_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05226 {
05227 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetPz());
05228 return(1 || funcname || hash || result7 || libp) ;
05229 }
05230
05231 static int G__BesVisLib_rootcint_202_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05232 {
05233 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetT());
05234 return(1 || funcname || hash || result7 || libp) ;
05235 }
05236
05237 static int G__BesVisLib_rootcint_202_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05238 {
05239 G__letdouble(result7, 102, (double) ((BesEventHeader*) G__getstructoffset())->GetE());
05240 return(1 || funcname || hash || result7 || libp) ;
05241 }
05242
05243 static int G__BesVisLib_rootcint_202_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05244 {
05245 G__letint(result7, 85, (long) BesEventHeader::Class());
05246 return(1 || funcname || hash || result7 || libp) ;
05247 }
05248
05249 static int G__BesVisLib_rootcint_202_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05250 {
05251 G__letint(result7, 67, (long) BesEventHeader::Class_Name());
05252 return(1 || funcname || hash || result7 || libp) ;
05253 }
05254
05255 static int G__BesVisLib_rootcint_202_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05256 {
05257 G__letint(result7, 115, (long) BesEventHeader::Class_Version());
05258 return(1 || funcname || hash || result7 || libp) ;
05259 }
05260
05261 static int G__BesVisLib_rootcint_202_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05262 {
05263 BesEventHeader::Dictionary();
05264 G__setnull(result7);
05265 return(1 || funcname || hash || result7 || libp) ;
05266 }
05267
05268 static int G__BesVisLib_rootcint_202_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05269 {
05270 ((BesEventHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05271 G__setnull(result7);
05272 return(1 || funcname || hash || result7 || libp) ;
05273 }
05274
05275 static int G__BesVisLib_rootcint_202_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05276 {
05277 G__letint(result7, 67, (long) BesEventHeader::DeclFileName());
05278 return(1 || funcname || hash || result7 || libp) ;
05279 }
05280
05281 static int G__BesVisLib_rootcint_202_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05282 {
05283 G__letint(result7, 105, (long) BesEventHeader::ImplFileLine());
05284 return(1 || funcname || hash || result7 || libp) ;
05285 }
05286
05287 static int G__BesVisLib_rootcint_202_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05288 {
05289 G__letint(result7, 67, (long) BesEventHeader::ImplFileName());
05290 return(1 || funcname || hash || result7 || libp) ;
05291 }
05292
05293 static int G__BesVisLib_rootcint_202_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05294 {
05295 G__letint(result7, 105, (long) BesEventHeader::DeclFileLine());
05296 return(1 || funcname || hash || result7 || libp) ;
05297 }
05298
05299
05300 static int G__BesVisLib_rootcint_202_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05301
05302 {
05303 BesEventHeader* p;
05304 void* tmp = (void*) G__int(libp->para[0]);
05305 p = new BesEventHeader(*(BesEventHeader*) tmp);
05306 result7->obj.i = (long) p;
05307 result7->ref = (long) p;
05308 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
05309 return(1 || funcname || hash || result7 || libp) ;
05310 }
05311
05312
05313 typedef BesEventHeader G__TBesEventHeader;
05314 static int G__BesVisLib_rootcint_202_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05315 {
05316 char* gvp = (char*) G__getgvp();
05317 long soff = G__getstructoffset();
05318 int n = G__getaryconstruct();
05319
05320
05321
05322
05323
05324 if (!soff) {
05325 return(1);
05326 }
05327 if (n) {
05328 if (gvp == (char*)G__PVOID) {
05329 delete[] (BesEventHeader*) soff;
05330 } else {
05331 G__setgvp((long) G__PVOID);
05332 for (int i = n - 1; i >= 0; --i) {
05333 ((BesEventHeader*) (soff+(sizeof(BesEventHeader)*i)))->~G__TBesEventHeader();
05334 }
05335 G__setgvp((long)gvp);
05336 }
05337 } else {
05338 if (gvp == (char*)G__PVOID) {
05339 delete (BesEventHeader*) soff;
05340 } else {
05341 G__setgvp((long) G__PVOID);
05342 ((BesEventHeader*) (soff))->~G__TBesEventHeader();
05343 G__setgvp((long)gvp);
05344 }
05345 }
05346 G__setnull(result7);
05347 return(1 || funcname || hash || result7 || libp) ;
05348 }
05349
05350
05351 static int G__BesVisLib_rootcint_202_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05352 {
05353 BesEventHeader* dest = (BesEventHeader*) G__getstructoffset();
05354 *dest = *(BesEventHeader*) libp->para[0].ref;
05355 const BesEventHeader& obj = *dest;
05356 result7->ref = (long) (&obj);
05357 result7->obj.i = (long) (&obj);
05358 return(1 || funcname || hash || result7 || libp) ;
05359 }
05360
05361
05362
05363 static int G__BesVisLib_rootcint_242_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05364 {
05365 BesView* p = NULL;
05366 char* gvp = (char*) G__getgvp();
05367 int n = G__getaryconstruct();
05368 if (n) {
05369 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05370 p = new BesView[n];
05371 } else {
05372 p = new((void*) gvp) BesView[n];
05373 }
05374 } else {
05375 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05376 p = new BesView;
05377 } else {
05378 p = new((void*) gvp) BesView;
05379 }
05380 }
05381 result7->obj.i = (long) p;
05382 result7->ref = (long) p;
05383 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
05384 return(1 || funcname || hash || result7 || libp) ;
05385 }
05386
05387 static int G__BesVisLib_rootcint_242_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05388 {
05389 switch (libp->paran) {
05390 case 2:
05391 ((BesView*) G__getstructoffset())->SetViewType((EBESViewType) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05392 G__setnull(result7);
05393 break;
05394 case 1:
05395 ((BesView*) G__getstructoffset())->SetViewType((EBESViewType) G__int(libp->para[0]));
05396 G__setnull(result7);
05397 break;
05398 }
05399 return(1 || funcname || hash || result7 || libp) ;
05400 }
05401
05402 static int G__BesVisLib_rootcint_242_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05403 {
05404 switch (libp->paran) {
05405 case 2:
05406 ((BesView*) G__getstructoffset())->SetViewTypeBare((EBESViewType) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05407 G__setnull(result7);
05408 break;
05409 case 1:
05410 ((BesView*) G__getstructoffset())->SetViewTypeBare((EBESViewType) G__int(libp->para[0]));
05411 G__setnull(result7);
05412 break;
05413 }
05414 return(1 || funcname || hash || result7 || libp) ;
05415 }
05416
05417 static int G__BesVisLib_rootcint_242_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05418 {
05419 ((BesView*) G__getstructoffset())->DefaultRange();
05420 G__setnull(result7);
05421 return(1 || funcname || hash || result7 || libp) ;
05422 }
05423
05424 static int G__BesVisLib_rootcint_242_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05425 {
05426 ((BesView*) G__getstructoffset())->ClearPad();
05427 G__setnull(result7);
05428 return(1 || funcname || hash || result7 || libp) ;
05429 }
05430
05431 static int G__BesVisLib_rootcint_242_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05432 {
05433 ((BesView*) G__getstructoffset())->DrawLabel();
05434 G__setnull(result7);
05435 return(1 || funcname || hash || result7 || libp) ;
05436 }
05437
05438 static int G__BesVisLib_rootcint_242_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05439 {
05440 G__letint(result7, 105, (long) ((BesView*) G__getstructoffset())->GetRSign((Float_t) G__double(libp->para[0])));
05441 return(1 || funcname || hash || result7 || libp) ;
05442 }
05443
05444 static int G__BesVisLib_rootcint_242_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05445 {
05446 switch (libp->paran) {
05447 case 1:
05448 ((BesView*) G__getstructoffset())->UpdateView((Bool_t) G__int(libp->para[0]));
05449 G__setnull(result7);
05450 break;
05451 case 0:
05452 ((BesView*) G__getstructoffset())->UpdateView();
05453 G__setnull(result7);
05454 break;
05455 }
05456 return(1 || funcname || hash || result7 || libp) ;
05457 }
05458
05459 static int G__BesVisLib_rootcint_242_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05460 {
05461 ((BesView*) G__getstructoffset())->SetZoomRatio((Double_t) G__double(libp->para[0]));
05462 G__setnull(result7);
05463 return(1 || funcname || hash || result7 || libp) ;
05464 }
05465
05466 static int G__BesVisLib_rootcint_242_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05467 {
05468 G__letdouble(result7, 100, (double) ((BesView*) G__getstructoffset())->GetZoomRatio());
05469 return(1 || funcname || hash || result7 || libp) ;
05470 }
05471
05472 static int G__BesVisLib_rootcint_242_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05473 {
05474 G__letint(result7, 105, (long) ((BesView*) G__getstructoffset())->GetViewType());
05475 return(1 || funcname || hash || result7 || libp) ;
05476 }
05477
05478 static int G__BesVisLib_rootcint_242_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05479 {
05480 G__letdouble(result7, 102, (double) ((BesView*) G__getstructoffset())->GetMarkerSize());
05481 return(1 || funcname || hash || result7 || libp) ;
05482 }
05483
05484 static int G__BesVisLib_rootcint_242_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05485 {
05486 ((BesView*) G__getstructoffset())->View3D();
05487 G__setnull(result7);
05488 return(1 || funcname || hash || result7 || libp) ;
05489 }
05490
05491 static int G__BesVisLib_rootcint_242_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05492 {
05493 ((BesView*) G__getstructoffset())->ViewXY();
05494 G__setnull(result7);
05495 return(1 || funcname || hash || result7 || libp) ;
05496 }
05497
05498 static int G__BesVisLib_rootcint_242_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05499 {
05500 ((BesView*) G__getstructoffset())->ViewZR();
05501 G__setnull(result7);
05502 return(1 || funcname || hash || result7 || libp) ;
05503 }
05504
05505 static int G__BesVisLib_rootcint_242_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05506 {
05507 ((BesView*) G__getstructoffset())->Center();
05508 G__setnull(result7);
05509 return(1 || funcname || hash || result7 || libp) ;
05510 }
05511
05512 static int G__BesVisLib_rootcint_242_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05513 {
05514 ((BesView*) G__getstructoffset())->Move((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05515 G__setnull(result7);
05516 return(1 || funcname || hash || result7 || libp) ;
05517 }
05518
05519 static int G__BesVisLib_rootcint_242_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05520 {
05521 ((BesView*) G__getstructoffset())->Front3D();
05522 G__setnull(result7);
05523 return(1 || funcname || hash || result7 || libp) ;
05524 }
05525
05526 static int G__BesVisLib_rootcint_242_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05527 {
05528 ((BesView*) G__getstructoffset())->Side3D();
05529 G__setnull(result7);
05530 return(1 || funcname || hash || result7 || libp) ;
05531 }
05532
05533 static int G__BesVisLib_rootcint_242_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05534 {
05535 ((BesView*) G__getstructoffset())->Top3D();
05536 G__setnull(result7);
05537 return(1 || funcname || hash || result7 || libp) ;
05538 }
05539
05540 static int G__BesVisLib_rootcint_242_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05541 {
05542 switch (libp->paran) {
05543 case 2:
05544 ((BesView*) G__getstructoffset())->SetPhiRange((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
05545 G__setnull(result7);
05546 break;
05547 case 1:
05548 ((BesView*) G__getstructoffset())->SetPhiRange((Float_t) G__double(libp->para[0]));
05549 G__setnull(result7);
05550 break;
05551 case 0:
05552 ((BesView*) G__getstructoffset())->SetPhiRange();
05553 G__setnull(result7);
05554 break;
05555 }
05556 return(1 || funcname || hash || result7 || libp) ;
05557 }
05558
05559 static int G__BesVisLib_rootcint_242_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05560 {
05561 ((BesView*) G__getstructoffset())->Reset();
05562 G__setnull(result7);
05563 return(1 || funcname || hash || result7 || libp) ;
05564 }
05565
05566 static int G__BesVisLib_rootcint_242_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05567 {
05568 ((BesView*) G__getstructoffset())->SetMarkerSize((Float_t) G__double(libp->para[0]));
05569 G__setnull(result7);
05570 return(1 || funcname || hash || result7 || libp) ;
05571 }
05572
05573 static int G__BesVisLib_rootcint_242_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05574 {
05575 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcGlobal());
05576 return(1 || funcname || hash || result7 || libp) ;
05577 }
05578
05579 static int G__BesVisLib_rootcint_242_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05580 {
05581 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcTubes());
05582 return(1 || funcname || hash || result7 || libp) ;
05583 }
05584
05585 static int G__BesVisLib_rootcint_242_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05586 {
05587 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcWires());
05588 return(1 || funcname || hash || result7 || libp) ;
05589 }
05590
05591 static int G__BesVisLib_rootcint_242_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05592 {
05593 ((BesView*) G__getstructoffset())->SetVisMdcGlobal((Bool_t) G__int(libp->para[0]));
05594 G__setnull(result7);
05595 return(1 || funcname || hash || result7 || libp) ;
05596 }
05597
05598 static int G__BesVisLib_rootcint_242_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05599 {
05600 ((BesView*) G__getstructoffset())->SetVisMdcTubes((Bool_t) G__int(libp->para[0]));
05601 G__setnull(result7);
05602 return(1 || funcname || hash || result7 || libp) ;
05603 }
05604
05605 static int G__BesVisLib_rootcint_242_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05606 {
05607 ((BesView*) G__getstructoffset())->SetVisMdcWires((Bool_t) G__int(libp->para[0]));
05608 G__setnull(result7);
05609 return(1 || funcname || hash || result7 || libp) ;
05610 }
05611
05612 static int G__BesVisLib_rootcint_242_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05613 {
05614 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofGlobal());
05615 return(1 || funcname || hash || result7 || libp) ;
05616 }
05617
05618 static int G__BesVisLib_rootcint_242_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05619 {
05620 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofEast());
05621 return(1 || funcname || hash || result7 || libp) ;
05622 }
05623
05624 static int G__BesVisLib_rootcint_242_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05625 {
05626 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofBarrel());
05627 return(1 || funcname || hash || result7 || libp) ;
05628 }
05629
05630 static int G__BesVisLib_rootcint_242_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05631 {
05632 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofWest());
05633 return(1 || funcname || hash || result7 || libp) ;
05634 }
05635
05636 static int G__BesVisLib_rootcint_242_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05637 {
05638 G__letdouble(result7, 102, (double) ((BesView*) G__getstructoffset())->GetVisZoom());
05639 return(1 || funcname || hash || result7 || libp) ;
05640 }
05641
05642 static int G__BesVisLib_rootcint_242_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05643 {
05644 ((BesView*) G__getstructoffset())->SetVisTofGlobal((Bool_t) G__int(libp->para[0]));
05645 G__setnull(result7);
05646 return(1 || funcname || hash || result7 || libp) ;
05647 }
05648
05649 static int G__BesVisLib_rootcint_242_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05650 {
05651 ((BesView*) G__getstructoffset())->SetVisTofEast((Bool_t) G__int(libp->para[0]));
05652 G__setnull(result7);
05653 return(1 || funcname || hash || result7 || libp) ;
05654 }
05655
05656 static int G__BesVisLib_rootcint_242_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05657 {
05658 ((BesView*) G__getstructoffset())->SetVisTofBarrel((Bool_t) G__int(libp->para[0]));
05659 G__setnull(result7);
05660 return(1 || funcname || hash || result7 || libp) ;
05661 }
05662
05663 static int G__BesVisLib_rootcint_242_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05664 {
05665 ((BesView*) G__getstructoffset())->SetVisTofWest((Bool_t) G__int(libp->para[0]));
05666 G__setnull(result7);
05667 return(1 || funcname || hash || result7 || libp) ;
05668 }
05669
05670 static int G__BesVisLib_rootcint_242_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05671 {
05672 ((BesView*) G__getstructoffset())->SetVisZoom((Float_t) G__double(libp->para[0]));
05673 G__setnull(result7);
05674 return(1 || funcname || hash || result7 || libp) ;
05675 }
05676
05677 static int G__BesVisLib_rootcint_242_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05678 {
05679 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcGlobal());
05680 return(1 || funcname || hash || result7 || libp) ;
05681 }
05682
05683 static int G__BesVisLib_rootcint_242_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05684 {
05685 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcEast());
05686 return(1 || funcname || hash || result7 || libp) ;
05687 }
05688
05689 static int G__BesVisLib_rootcint_242_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05690 {
05691 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcBarrel());
05692 return(1 || funcname || hash || result7 || libp) ;
05693 }
05694
05695 static int G__BesVisLib_rootcint_242_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05696 {
05697 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcWest());
05698 return(1 || funcname || hash || result7 || libp) ;
05699 }
05700
05701 static int G__BesVisLib_rootcint_242_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05702 {
05703 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcSide());
05704 return(1 || funcname || hash || result7 || libp) ;
05705 }
05706
05707 static int G__BesVisLib_rootcint_242_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05708 {
05709 ((BesView*) G__getstructoffset())->SetVisEmcGlobal((Bool_t) G__int(libp->para[0]));
05710 G__setnull(result7);
05711 return(1 || funcname || hash || result7 || libp) ;
05712 }
05713
05714 static int G__BesVisLib_rootcint_242_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05715 {
05716 ((BesView*) G__getstructoffset())->SetVisEmcEast((Bool_t) G__int(libp->para[0]));
05717 G__setnull(result7);
05718 return(1 || funcname || hash || result7 || libp) ;
05719 }
05720
05721 static int G__BesVisLib_rootcint_242_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05722 {
05723 ((BesView*) G__getstructoffset())->SetVisEmcBarrel((Bool_t) G__int(libp->para[0]));
05724 G__setnull(result7);
05725 return(1 || funcname || hash || result7 || libp) ;
05726 }
05727
05728 static int G__BesVisLib_rootcint_242_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05729 {
05730 ((BesView*) G__getstructoffset())->SetVisEmcWest((Bool_t) G__int(libp->para[0]));
05731 G__setnull(result7);
05732 return(1 || funcname || hash || result7 || libp) ;
05733 }
05734
05735 static int G__BesVisLib_rootcint_242_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05736 {
05737 ((BesView*) G__getstructoffset())->SetVisEmcSide((Bool_t) G__int(libp->para[0]));
05738 G__setnull(result7);
05739 return(1 || funcname || hash || result7 || libp) ;
05740 }
05741
05742 static int G__BesVisLib_rootcint_242_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05743 {
05744 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucGlobal());
05745 return(1 || funcname || hash || result7 || libp) ;
05746 }
05747
05748 static int G__BesVisLib_rootcint_242_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05749 {
05750 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucEast());
05751 return(1 || funcname || hash || result7 || libp) ;
05752 }
05753
05754 static int G__BesVisLib_rootcint_242_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05755 {
05756 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucBarrel());
05757 return(1 || funcname || hash || result7 || libp) ;
05758 }
05759
05760 static int G__BesVisLib_rootcint_242_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05761 {
05762 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucWest());
05763 return(1 || funcname || hash || result7 || libp) ;
05764 }
05765
05766 static int G__BesVisLib_rootcint_242_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05767 {
05768 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucStrips());
05769 return(1 || funcname || hash || result7 || libp) ;
05770 }
05771
05772 static int G__BesVisLib_rootcint_242_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05773 {
05774 ((BesView*) G__getstructoffset())->SetVisMucGlobal((Bool_t) G__int(libp->para[0]));
05775 G__setnull(result7);
05776 return(1 || funcname || hash || result7 || libp) ;
05777 }
05778
05779 static int G__BesVisLib_rootcint_242_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05780 {
05781 ((BesView*) G__getstructoffset())->SetVisMucEast((Bool_t) G__int(libp->para[0]));
05782 G__setnull(result7);
05783 return(1 || funcname || hash || result7 || libp) ;
05784 }
05785
05786 static int G__BesVisLib_rootcint_242_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05787 {
05788 ((BesView*) G__getstructoffset())->SetVisMucBarrel((Bool_t) G__int(libp->para[0]));
05789 G__setnull(result7);
05790 return(1 || funcname || hash || result7 || libp) ;
05791 }
05792
05793 static int G__BesVisLib_rootcint_242_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05794 {
05795 ((BesView*) G__getstructoffset())->SetVisMucWest((Bool_t) G__int(libp->para[0]));
05796 G__setnull(result7);
05797 return(1 || funcname || hash || result7 || libp) ;
05798 }
05799
05800 static int G__BesVisLib_rootcint_242_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05801 {
05802 ((BesView*) G__getstructoffset())->SetVisMucStrips((Bool_t) G__int(libp->para[0]));
05803 G__setnull(result7);
05804 return(1 || funcname || hash || result7 || libp) ;
05805 }
05806
05807 static int G__BesVisLib_rootcint_242_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05808 {
05809 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DMdc());
05810 return(1 || funcname || hash || result7 || libp) ;
05811 }
05812
05813 static int G__BesVisLib_rootcint_242_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05814 {
05815 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DTof());
05816 return(1 || funcname || hash || result7 || libp) ;
05817 }
05818
05819 static int G__BesVisLib_rootcint_242_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05820 {
05821 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DEmc());
05822 return(1 || funcname || hash || result7 || libp) ;
05823 }
05824
05825 static int G__BesVisLib_rootcint_242_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05826 {
05827 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisFull3DMuc());
05828 return(1 || funcname || hash || result7 || libp) ;
05829 }
05830
05831 static int G__BesVisLib_rootcint_242_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05832 {
05833 ((BesView*) G__getstructoffset())->SetVisFull3DMdc((Bool_t) G__int(libp->para[0]));
05834 G__setnull(result7);
05835 return(1 || funcname || hash || result7 || libp) ;
05836 }
05837
05838 static int G__BesVisLib_rootcint_242_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05839 {
05840 ((BesView*) G__getstructoffset())->SetVisFull3DTof((Bool_t) G__int(libp->para[0]));
05841 G__setnull(result7);
05842 return(1 || funcname || hash || result7 || libp) ;
05843 }
05844
05845 static int G__BesVisLib_rootcint_242_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05846 {
05847 ((BesView*) G__getstructoffset())->SetVisFull3DEmc((Bool_t) G__int(libp->para[0]));
05848 G__setnull(result7);
05849 return(1 || funcname || hash || result7 || libp) ;
05850 }
05851
05852 static int G__BesVisLib_rootcint_242_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05853 {
05854 ((BesView*) G__getstructoffset())->SetVisFull3DMuc((Bool_t) G__int(libp->para[0]));
05855 G__setnull(result7);
05856 return(1 || funcname || hash || result7 || libp) ;
05857 }
05858
05859 static int G__BesVisLib_rootcint_242_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05860 {
05861 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisBeamPipe());
05862 return(1 || funcname || hash || result7 || libp) ;
05863 }
05864
05865 static int G__BesVisLib_rootcint_242_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05866 {
05867 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisZRPlaneOnXY());
05868 return(1 || funcname || hash || result7 || libp) ;
05869 }
05870
05871 static int G__BesVisLib_rootcint_242_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05872 {
05873 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisAxis());
05874 return(1 || funcname || hash || result7 || libp) ;
05875 }
05876
05877 static int G__BesVisLib_rootcint_242_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05878 {
05879 ((BesView*) G__getstructoffset())->SetVisBeamPipe((Bool_t) G__int(libp->para[0]));
05880 G__setnull(result7);
05881 return(1 || funcname || hash || result7 || libp) ;
05882 }
05883
05884 static int G__BesVisLib_rootcint_242_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05885 {
05886 ((BesView*) G__getstructoffset())->SetVisZRPlaneOnXY((Bool_t) G__int(libp->para[0]));
05887 G__setnull(result7);
05888 return(1 || funcname || hash || result7 || libp) ;
05889 }
05890
05891 static int G__BesVisLib_rootcint_242_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05892 {
05893 ((BesView*) G__getstructoffset())->SetVisAxis((Bool_t) G__int(libp->para[0]));
05894 G__setnull(result7);
05895 return(1 || funcname || hash || result7 || libp) ;
05896 }
05897
05898 static int G__BesVisLib_rootcint_242_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05899 {
05900 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcHitsGlobal());
05901 return(1 || funcname || hash || result7 || libp) ;
05902 }
05903
05904 static int G__BesVisLib_rootcint_242_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05905 {
05906 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMdcHits());
05907 return(1 || funcname || hash || result7 || libp) ;
05908 }
05909
05910 static int G__BesVisLib_rootcint_242_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05911 {
05912 ((BesView*) G__getstructoffset())->SetVisMdcHitsGlobal((Bool_t) G__int(libp->para[0]));
05913 G__setnull(result7);
05914 return(1 || funcname || hash || result7 || libp) ;
05915 }
05916
05917 static int G__BesVisLib_rootcint_242_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05918 {
05919 ((BesView*) G__getstructoffset())->SetVisMdcHits((Bool_t) G__int(libp->para[0]));
05920 G__setnull(result7);
05921 return(1 || funcname || hash || result7 || libp) ;
05922 }
05923
05924 static int G__BesVisLib_rootcint_242_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05925 {
05926 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsGlobal());
05927 return(1 || funcname || hash || result7 || libp) ;
05928 }
05929
05930 static int G__BesVisLib_rootcint_242_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05931 {
05932 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsEast());
05933 return(1 || funcname || hash || result7 || libp) ;
05934 }
05935
05936 static int G__BesVisLib_rootcint_242_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05937 {
05938 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsBarrel());
05939 return(1 || funcname || hash || result7 || libp) ;
05940 }
05941
05942 static int G__BesVisLib_rootcint_242_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05943 {
05944 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTofHitsWest());
05945 return(1 || funcname || hash || result7 || libp) ;
05946 }
05947
05948 static int G__BesVisLib_rootcint_242_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05949 {
05950 ((BesView*) G__getstructoffset())->SetVisTofHitsGlobal((Bool_t) G__int(libp->para[0]));
05951 G__setnull(result7);
05952 return(1 || funcname || hash || result7 || libp) ;
05953 }
05954
05955 static int G__BesVisLib_rootcint_242_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05956 {
05957 ((BesView*) G__getstructoffset())->SetVisTofHitsEast((Bool_t) G__int(libp->para[0]));
05958 G__setnull(result7);
05959 return(1 || funcname || hash || result7 || libp) ;
05960 }
05961
05962 static int G__BesVisLib_rootcint_242_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05963 {
05964 ((BesView*) G__getstructoffset())->SetVisTofHitsBarrel((Bool_t) G__int(libp->para[0]));
05965 G__setnull(result7);
05966 return(1 || funcname || hash || result7 || libp) ;
05967 }
05968
05969 static int G__BesVisLib_rootcint_242_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05970 {
05971 ((BesView*) G__getstructoffset())->SetVisTofHitsWest((Bool_t) G__int(libp->para[0]));
05972 G__setnull(result7);
05973 return(1 || funcname || hash || result7 || libp) ;
05974 }
05975
05976 static int G__BesVisLib_rootcint_242_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05977 {
05978 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsGlobal());
05979 return(1 || funcname || hash || result7 || libp) ;
05980 }
05981
05982 static int G__BesVisLib_rootcint_242_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05983 {
05984 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsEast());
05985 return(1 || funcname || hash || result7 || libp) ;
05986 }
05987
05988 static int G__BesVisLib_rootcint_242_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05989 {
05990 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsBarrel());
05991 return(1 || funcname || hash || result7 || libp) ;
05992 }
05993
05994 static int G__BesVisLib_rootcint_242_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05995 {
05996 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsWest());
05997 return(1 || funcname || hash || result7 || libp) ;
05998 }
05999
06000 static int G__BesVisLib_rootcint_242_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06001 {
06002 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisEmcHitsSide());
06003 return(1 || funcname || hash || result7 || libp) ;
06004 }
06005
06006 static int G__BesVisLib_rootcint_242_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06007 {
06008 ((BesView*) G__getstructoffset())->SetVisEmcHitsGlobal((Bool_t) G__int(libp->para[0]));
06009 G__setnull(result7);
06010 return(1 || funcname || hash || result7 || libp) ;
06011 }
06012
06013 static int G__BesVisLib_rootcint_242_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06014 {
06015 ((BesView*) G__getstructoffset())->SetVisEmcHitsEast((Bool_t) G__int(libp->para[0]));
06016 G__setnull(result7);
06017 return(1 || funcname || hash || result7 || libp) ;
06018 }
06019
06020 static int G__BesVisLib_rootcint_242_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06021 {
06022 ((BesView*) G__getstructoffset())->SetVisEmcHitsBarrel((Bool_t) G__int(libp->para[0]));
06023 G__setnull(result7);
06024 return(1 || funcname || hash || result7 || libp) ;
06025 }
06026
06027 static int G__BesVisLib_rootcint_242_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06028 {
06029 ((BesView*) G__getstructoffset())->SetVisEmcHitsWest((Bool_t) G__int(libp->para[0]));
06030 G__setnull(result7);
06031 return(1 || funcname || hash || result7 || libp) ;
06032 }
06033
06034 static int G__BesVisLib_rootcint_242_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06035 {
06036 ((BesView*) G__getstructoffset())->SetVisEmcHitsSide((Bool_t) G__int(libp->para[0]));
06037 G__setnull(result7);
06038 return(1 || funcname || hash || result7 || libp) ;
06039 }
06040
06041 static int G__BesVisLib_rootcint_242_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06042 {
06043 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsGlobal());
06044 return(1 || funcname || hash || result7 || libp) ;
06045 }
06046
06047 static int G__BesVisLib_rootcint_242_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06048 {
06049 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsEast());
06050 return(1 || funcname || hash || result7 || libp) ;
06051 }
06052
06053 static int G__BesVisLib_rootcint_242_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06054 {
06055 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsBarrel());
06056 return(1 || funcname || hash || result7 || libp) ;
06057 }
06058
06059 static int G__BesVisLib_rootcint_242_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06060 {
06061 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisMucHitsWest());
06062 return(1 || funcname || hash || result7 || libp) ;
06063 }
06064
06065 static int G__BesVisLib_rootcint_242_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06066 {
06067 ((BesView*) G__getstructoffset())->SetVisMucHitsGlobal((Bool_t) G__int(libp->para[0]));
06068 G__setnull(result7);
06069 return(1 || funcname || hash || result7 || libp) ;
06070 }
06071
06072 static int G__BesVisLib_rootcint_242_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06073 {
06074 ((BesView*) G__getstructoffset())->SetVisMucHitsEast((Bool_t) G__int(libp->para[0]));
06075 G__setnull(result7);
06076 return(1 || funcname || hash || result7 || libp) ;
06077 }
06078
06079 static int G__BesVisLib_rootcint_242_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06080 {
06081 ((BesView*) G__getstructoffset())->SetVisMucHitsBarrel((Bool_t) G__int(libp->para[0]));
06082 G__setnull(result7);
06083 return(1 || funcname || hash || result7 || libp) ;
06084 }
06085
06086 static int G__BesVisLib_rootcint_242_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06087 {
06088 ((BesView*) G__getstructoffset())->SetVisMucHitsWest((Bool_t) G__int(libp->para[0]));
06089 G__setnull(result7);
06090 return(1 || funcname || hash || result7 || libp) ;
06091 }
06092
06093 static int G__BesVisLib_rootcint_242_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06094 {
06095 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksGlobal());
06096 return(1 || funcname || hash || result7 || libp) ;
06097 }
06098
06099 static int G__BesVisLib_rootcint_242_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06100 {
06101 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksMdc());
06102 return(1 || funcname || hash || result7 || libp) ;
06103 }
06104
06105 static int G__BesVisLib_rootcint_242_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06106 {
06107 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksTof());
06108 return(1 || funcname || hash || result7 || libp) ;
06109 }
06110
06111 static int G__BesVisLib_rootcint_242_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06112 {
06113 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksEmc());
06114 return(1 || funcname || hash || result7 || libp) ;
06115 }
06116
06117 static int G__BesVisLib_rootcint_242_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06118 {
06119 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksMuc());
06120 return(1 || funcname || hash || result7 || libp) ;
06121 }
06122
06123 static int G__BesVisLib_rootcint_242_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06124 {
06125 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetVisTracksExt());
06126 return(1 || funcname || hash || result7 || libp) ;
06127 }
06128
06129 static int G__BesVisLib_rootcint_242_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06130 {
06131 ((BesView*) G__getstructoffset())->SetVisTracksGlobal((Bool_t) G__int(libp->para[0]));
06132 G__setnull(result7);
06133 return(1 || funcname || hash || result7 || libp) ;
06134 }
06135
06136 static int G__BesVisLib_rootcint_242_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06137 {
06138 ((BesView*) G__getstructoffset())->SetVisTracksMdc((Bool_t) G__int(libp->para[0]));
06139 G__setnull(result7);
06140 return(1 || funcname || hash || result7 || libp) ;
06141 }
06142
06143 static int G__BesVisLib_rootcint_242_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06144 {
06145 ((BesView*) G__getstructoffset())->SetVisTracksTof((Bool_t) G__int(libp->para[0]));
06146 G__setnull(result7);
06147 return(1 || funcname || hash || result7 || libp) ;
06148 }
06149
06150 static int G__BesVisLib_rootcint_242_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06151 {
06152 ((BesView*) G__getstructoffset())->SetVisTracksEmc((Bool_t) G__int(libp->para[0]));
06153 G__setnull(result7);
06154 return(1 || funcname || hash || result7 || libp) ;
06155 }
06156
06157 static int G__BesVisLib_rootcint_242_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06158 {
06159 ((BesView*) G__getstructoffset())->SetVisTracksMuc((Bool_t) G__int(libp->para[0]));
06160 G__setnull(result7);
06161 return(1 || funcname || hash || result7 || libp) ;
06162 }
06163
06164 static int G__BesVisLib_rootcint_242_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06165 {
06166 ((BesView*) G__getstructoffset())->SetVisTracksExt((Bool_t) G__int(libp->para[0]));
06167 G__setnull(result7);
06168 return(1 || funcname || hash || result7 || libp) ;
06169 }
06170
06171 static int G__BesVisLib_rootcint_242_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06172 {
06173 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetFishEyeStatus());
06174 return(1 || funcname || hash || result7 || libp) ;
06175 }
06176
06177 static int G__BesVisLib_rootcint_242_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06178 {
06179 G__letint(result7, 103, (long) ((BesView*) G__getstructoffset())->GetFishEye());
06180 return(1 || funcname || hash || result7 || libp) ;
06181 }
06182
06183 static int G__BesVisLib_rootcint_242_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06184 {
06185 switch (libp->paran) {
06186 case 1:
06187 ((BesView*) G__getstructoffset())->SetFishEye((Bool_t) G__int(libp->para[0]));
06188 G__setnull(result7);
06189 break;
06190 case 0:
06191 ((BesView*) G__getstructoffset())->SetFishEye();
06192 G__setnull(result7);
06193 break;
06194 }
06195 return(1 || funcname || hash || result7 || libp) ;
06196 }
06197
06198 static int G__BesVisLib_rootcint_242_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06199 {
06200 ((BesView*) G__getstructoffset())->PrintCurrent();
06201 G__setnull(result7);
06202 return(1 || funcname || hash || result7 || libp) ;
06203 }
06204
06205 static int G__BesVisLib_rootcint_242_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06206 {
06207 ((BesView*) G__getstructoffset())->DrawClass();
06208 G__setnull(result7);
06209 return(1 || funcname || hash || result7 || libp) ;
06210 }
06211
06212 static int G__BesVisLib_rootcint_242_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06213 {
06214 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
06215 return(1 || funcname || hash || result7 || libp) ;
06216 }
06217
06218 static int G__BesVisLib_rootcint_242_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06219 {
06220 ((BesView*) G__getstructoffset())->Dump();
06221 G__setnull(result7);
06222 return(1 || funcname || hash || result7 || libp) ;
06223 }
06224
06225 static int G__BesVisLib_rootcint_242_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06226 {
06227 ((BesView*) G__getstructoffset())->Inspect();
06228 G__setnull(result7);
06229 return(1 || funcname || hash || result7 || libp) ;
06230 }
06231
06232 static int G__BesVisLib_rootcint_242_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06233 {
06234 ((BesView*) G__getstructoffset())->SetZoomFactor((Double_t) G__double(libp->para[0]));
06235 G__setnull(result7);
06236 return(1 || funcname || hash || result7 || libp) ;
06237 }
06238
06239 static int G__BesVisLib_rootcint_242_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06240 {
06241 G__letdouble(result7, 100, (double) ((BesView*) G__getstructoffset())->GetZoomFactor());
06242 return(1 || funcname || hash || result7 || libp) ;
06243 }
06244
06245 static int G__BesVisLib_rootcint_242_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06246 {
06247 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatusCurrent());
06248 return(1 || funcname || hash || result7 || libp) ;
06249 }
06250
06251 static int G__BesVisLib_rootcint_242_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06252 {
06253 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatus3D());
06254 return(1 || funcname || hash || result7 || libp) ;
06255 }
06256
06257 static int G__BesVisLib_rootcint_242_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06258 {
06259 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatusXY());
06260 return(1 || funcname || hash || result7 || libp) ;
06261 }
06262
06263 static int G__BesVisLib_rootcint_242_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06264 {
06265 G__letint(result7, 85, (long) ((BesView*) G__getstructoffset())->GetStatusZR());
06266 return(1 || funcname || hash || result7 || libp) ;
06267 }
06268
06269 static int G__BesVisLib_rootcint_242_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06270 {
06271 G__letint(result7, 85, (long) BesView::Class());
06272 return(1 || funcname || hash || result7 || libp) ;
06273 }
06274
06275 static int G__BesVisLib_rootcint_242_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06276 {
06277 G__letint(result7, 67, (long) BesView::Class_Name());
06278 return(1 || funcname || hash || result7 || libp) ;
06279 }
06280
06281 static int G__BesVisLib_rootcint_242_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06282 {
06283 G__letint(result7, 115, (long) BesView::Class_Version());
06284 return(1 || funcname || hash || result7 || libp) ;
06285 }
06286
06287 static int G__BesVisLib_rootcint_242_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06288 {
06289 BesView::Dictionary();
06290 G__setnull(result7);
06291 return(1 || funcname || hash || result7 || libp) ;
06292 }
06293
06294 static int G__BesVisLib_rootcint_242_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06295 {
06296 ((BesView*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06297 G__setnull(result7);
06298 return(1 || funcname || hash || result7 || libp) ;
06299 }
06300
06301 static int G__BesVisLib_rootcint_242_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06302 {
06303 G__letint(result7, 67, (long) BesView::DeclFileName());
06304 return(1 || funcname || hash || result7 || libp) ;
06305 }
06306
06307 static int G__BesVisLib_rootcint_242_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06308 {
06309 G__letint(result7, 105, (long) BesView::ImplFileLine());
06310 return(1 || funcname || hash || result7 || libp) ;
06311 }
06312
06313 static int G__BesVisLib_rootcint_242_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06314 {
06315 G__letint(result7, 67, (long) BesView::ImplFileName());
06316 return(1 || funcname || hash || result7 || libp) ;
06317 }
06318
06319 static int G__BesVisLib_rootcint_242_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06320 {
06321 G__letint(result7, 105, (long) BesView::DeclFileLine());
06322 return(1 || funcname || hash || result7 || libp) ;
06323 }
06324
06325
06326 static int G__BesVisLib_rootcint_242_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06327
06328 {
06329 BesView* p;
06330 void* tmp = (void*) G__int(libp->para[0]);
06331 p = new BesView(*(BesView*) tmp);
06332 result7->obj.i = (long) p;
06333 result7->ref = (long) p;
06334 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
06335 return(1 || funcname || hash || result7 || libp) ;
06336 }
06337
06338
06339 typedef BesView G__TBesView;
06340 static int G__BesVisLib_rootcint_242_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06341 {
06342 char* gvp = (char*) G__getgvp();
06343 long soff = G__getstructoffset();
06344 int n = G__getaryconstruct();
06345
06346
06347
06348
06349
06350 if (!soff) {
06351 return(1);
06352 }
06353 if (n) {
06354 if (gvp == (char*)G__PVOID) {
06355 delete[] (BesView*) soff;
06356 } else {
06357 G__setgvp((long) G__PVOID);
06358 for (int i = n - 1; i >= 0; --i) {
06359 ((BesView*) (soff+(sizeof(BesView)*i)))->~G__TBesView();
06360 }
06361 G__setgvp((long)gvp);
06362 }
06363 } else {
06364 if (gvp == (char*)G__PVOID) {
06365 delete (BesView*) soff;
06366 } else {
06367 G__setgvp((long) G__PVOID);
06368 ((BesView*) (soff))->~G__TBesView();
06369 G__setgvp((long)gvp);
06370 }
06371 }
06372 G__setnull(result7);
06373 return(1 || funcname || hash || result7 || libp) ;
06374 }
06375
06376
06377
06378 static int G__BesVisLib_rootcint_243_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06379 {
06380 BesMarker2D* p = NULL;
06381 char* gvp = (char*) G__getgvp();
06382 int n = G__getaryconstruct();
06383 if (n) {
06384 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06385 p = new BesMarker2D[n];
06386 } else {
06387 p = new((void*) gvp) BesMarker2D[n];
06388 }
06389 } else {
06390 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06391 p = new BesMarker2D;
06392 } else {
06393 p = new((void*) gvp) BesMarker2D;
06394 }
06395 }
06396 result7->obj.i = (long) p;
06397 result7->ref = (long) p;
06398 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
06399 return(1 || funcname || hash || result7 || libp) ;
06400 }
06401
06402 static int G__BesVisLib_rootcint_243_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06403 {
06404 BesMarker2D* p = NULL;
06405 char* gvp = (char*) G__getgvp();
06406
06407 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06408 p = new BesMarker2D(
06409 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06410 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
06411 , (Float_t) G__double(libp->para[4]));
06412 } else {
06413 p = new((void*) gvp) BesMarker2D(
06414 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06415 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
06416 , (Float_t) G__double(libp->para[4]));
06417 }
06418 result7->obj.i = (long) p;
06419 result7->ref = (long) p;
06420 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
06421 return(1 || funcname || hash || result7 || libp) ;
06422 }
06423
06424 static int G__BesVisLib_rootcint_243_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06425 {
06426 BesMarker2D* p = NULL;
06427 char* gvp = (char*) G__getgvp();
06428
06429 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06430 p = new BesMarker2D(
06431 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06432 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06433 , (Double_t) G__double(libp->para[4]));
06434 } else {
06435 p = new((void*) gvp) BesMarker2D(
06436 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06437 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06438 , (Double_t) G__double(libp->para[4]));
06439 }
06440 result7->obj.i = (long) p;
06441 result7->ref = (long) p;
06442 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
06443 return(1 || funcname || hash || result7 || libp) ;
06444 }
06445
06446 static int G__BesVisLib_rootcint_243_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06447 {
06448 ((BesMarker2D*) G__getstructoffset())->GetCenterPixel(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
06449 G__setnull(result7);
06450 return(1 || funcname || hash || result7 || libp) ;
06451 }
06452
06453 static int G__BesVisLib_rootcint_243_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06454 {
06455 ((BesMarker2D*) G__getstructoffset())->SetMarkerSizeMultiple((Int_t) G__int(libp->para[0]));
06456 G__setnull(result7);
06457 return(1 || funcname || hash || result7 || libp) ;
06458 }
06459
06460 static int G__BesVisLib_rootcint_243_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06461 {
06462 G__letint(result7, 105, (long) ((BesMarker2D*) G__getstructoffset())->GetMarkerSizeMultiple());
06463 return(1 || funcname || hash || result7 || libp) ;
06464 }
06465
06466 static int G__BesVisLib_rootcint_243_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06467 {
06468 G__letdouble(result7, 102, (double) ((BesMarker2D*) G__getstructoffset())->GetWCX());
06469 return(1 || funcname || hash || result7 || libp) ;
06470 }
06471
06472 static int G__BesVisLib_rootcint_243_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06473 {
06474 G__letdouble(result7, 102, (double) ((BesMarker2D*) G__getstructoffset())->GetWCY());
06475 return(1 || funcname || hash || result7 || libp) ;
06476 }
06477
06478 static int G__BesVisLib_rootcint_243_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06479 {
06480 G__letdouble(result7, 102, (double) ((BesMarker2D*) G__getstructoffset())->GetWCZ());
06481 return(1 || funcname || hash || result7 || libp) ;
06482 }
06483
06484 static int G__BesVisLib_rootcint_243_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06485 {
06486 ((BesMarker2D*) G__getstructoffset())->SetWCX((Float_t) G__double(libp->para[0]));
06487 G__setnull(result7);
06488 return(1 || funcname || hash || result7 || libp) ;
06489 }
06490
06491 static int G__BesVisLib_rootcint_243_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06492 {
06493 ((BesMarker2D*) G__getstructoffset())->SetWCY((Float_t) G__double(libp->para[0]));
06494 G__setnull(result7);
06495 return(1 || funcname || hash || result7 || libp) ;
06496 }
06497
06498 static int G__BesVisLib_rootcint_243_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06499 {
06500 ((BesMarker2D*) G__getstructoffset())->SetWCZ((Float_t) G__double(libp->para[0]));
06501 G__setnull(result7);
06502 return(1 || funcname || hash || result7 || libp) ;
06503 }
06504
06505 static int G__BesVisLib_rootcint_243_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06506 {
06507 ((BesMarker2D*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06508 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
06509 , (Float_t) G__double(libp->para[4]));
06510 G__setnull(result7);
06511 return(1 || funcname || hash || result7 || libp) ;
06512 }
06513
06514 static int G__BesVisLib_rootcint_243_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06515 {
06516 G__letint(result7, 85, (long) BesMarker2D::Class());
06517 return(1 || funcname || hash || result7 || libp) ;
06518 }
06519
06520 static int G__BesVisLib_rootcint_243_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06521 {
06522 G__letint(result7, 67, (long) BesMarker2D::Class_Name());
06523 return(1 || funcname || hash || result7 || libp) ;
06524 }
06525
06526 static int G__BesVisLib_rootcint_243_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06527 {
06528 G__letint(result7, 115, (long) BesMarker2D::Class_Version());
06529 return(1 || funcname || hash || result7 || libp) ;
06530 }
06531
06532 static int G__BesVisLib_rootcint_243_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06533 {
06534 BesMarker2D::Dictionary();
06535 G__setnull(result7);
06536 return(1 || funcname || hash || result7 || libp) ;
06537 }
06538
06539 static int G__BesVisLib_rootcint_243_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06540 {
06541 ((BesMarker2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06542 G__setnull(result7);
06543 return(1 || funcname || hash || result7 || libp) ;
06544 }
06545
06546 static int G__BesVisLib_rootcint_243_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06547 {
06548 G__letint(result7, 67, (long) BesMarker2D::DeclFileName());
06549 return(1 || funcname || hash || result7 || libp) ;
06550 }
06551
06552 static int G__BesVisLib_rootcint_243_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06553 {
06554 G__letint(result7, 105, (long) BesMarker2D::ImplFileLine());
06555 return(1 || funcname || hash || result7 || libp) ;
06556 }
06557
06558 static int G__BesVisLib_rootcint_243_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06559 {
06560 G__letint(result7, 67, (long) BesMarker2D::ImplFileName());
06561 return(1 || funcname || hash || result7 || libp) ;
06562 }
06563
06564 static int G__BesVisLib_rootcint_243_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06565 {
06566 G__letint(result7, 105, (long) BesMarker2D::DeclFileLine());
06567 return(1 || funcname || hash || result7 || libp) ;
06568 }
06569
06570
06571 static int G__BesVisLib_rootcint_243_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06572
06573 {
06574 BesMarker2D* p;
06575 void* tmp = (void*) G__int(libp->para[0]);
06576 p = new BesMarker2D(*(BesMarker2D*) tmp);
06577 result7->obj.i = (long) p;
06578 result7->ref = (long) p;
06579 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
06580 return(1 || funcname || hash || result7 || libp) ;
06581 }
06582
06583
06584 typedef BesMarker2D G__TBesMarker2D;
06585 static int G__BesVisLib_rootcint_243_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06586 {
06587 char* gvp = (char*) G__getgvp();
06588 long soff = G__getstructoffset();
06589 int n = G__getaryconstruct();
06590
06591
06592
06593
06594
06595 if (!soff) {
06596 return(1);
06597 }
06598 if (n) {
06599 if (gvp == (char*)G__PVOID) {
06600 delete[] (BesMarker2D*) soff;
06601 } else {
06602 G__setgvp((long) G__PVOID);
06603 for (int i = n - 1; i >= 0; --i) {
06604 ((BesMarker2D*) (soff+(sizeof(BesMarker2D)*i)))->~G__TBesMarker2D();
06605 }
06606 G__setgvp((long)gvp);
06607 }
06608 } else {
06609 if (gvp == (char*)G__PVOID) {
06610 delete (BesMarker2D*) soff;
06611 } else {
06612 G__setgvp((long) G__PVOID);
06613 ((BesMarker2D*) (soff))->~G__TBesMarker2D();
06614 G__setgvp((long)gvp);
06615 }
06616 }
06617 G__setnull(result7);
06618 return(1 || funcname || hash || result7 || libp) ;
06619 }
06620
06621
06622 static int G__BesVisLib_rootcint_243_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06623 {
06624 BesMarker2D* dest = (BesMarker2D*) G__getstructoffset();
06625 *dest = *(BesMarker2D*) libp->para[0].ref;
06626 const BesMarker2D& obj = *dest;
06627 result7->ref = (long) (&obj);
06628 result7->obj.i = (long) (&obj);
06629 return(1 || funcname || hash || result7 || libp) ;
06630 }
06631
06632
06633
06634 static int G__BesVisLib_rootcint_244_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06635 {
06636 BesPaveText* p = NULL;
06637 char* gvp = (char*) G__getgvp();
06638 int n = G__getaryconstruct();
06639 if (n) {
06640 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06641 p = new BesPaveText[n];
06642 } else {
06643 p = new((void*) gvp) BesPaveText[n];
06644 }
06645 } else {
06646 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06647 p = new BesPaveText;
06648 } else {
06649 p = new((void*) gvp) BesPaveText;
06650 }
06651 }
06652 result7->obj.i = (long) p;
06653 result7->ref = (long) p;
06654 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
06655 return(1 || funcname || hash || result7 || libp) ;
06656 }
06657
06658 static int G__BesVisLib_rootcint_244_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06659 {
06660 BesPaveText* p = NULL;
06661 char* gvp = (char*) G__getgvp();
06662 switch (libp->paran) {
06663 case 5:
06664
06665 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06666 p = new BesPaveText(
06667 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
06668 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06669 , (Option_t*) G__int(libp->para[4]));
06670 } else {
06671 p = new((void*) gvp) BesPaveText(
06672 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
06673 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06674 , (Option_t*) G__int(libp->para[4]));
06675 }
06676 break;
06677 case 4:
06678
06679 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06680 p = new BesPaveText(
06681 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
06682 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
06683 } else {
06684 p = new((void*) gvp) BesPaveText(
06685 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
06686 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
06687 }
06688 break;
06689 }
06690 result7->obj.i = (long) p;
06691 result7->ref = (long) p;
06692 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
06693 return(1 || funcname || hash || result7 || libp) ;
06694 }
06695
06696 static int G__BesVisLib_rootcint_244_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06697 {
06698 BesPaveText* p = NULL;
06699 char* gvp = (char*) G__getgvp();
06700
06701 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06702 p = new BesPaveText(*(BesPaveText*) libp->para[0].ref);
06703 } else {
06704 p = new((void*) gvp) BesPaveText(*(BesPaveText*) libp->para[0].ref);
06705 }
06706 result7->obj.i = (long) p;
06707 result7->ref = (long) p;
06708 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
06709 return(1 || funcname || hash || result7 || libp) ;
06710 }
06711
06712 static int G__BesVisLib_rootcint_244_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06713 {
06714 ((BesPaveText*) G__getstructoffset())->SetText(*((vector<TString>*) G__int(libp->para[0])));
06715 G__setnull(result7);
06716 return(1 || funcname || hash || result7 || libp) ;
06717 }
06718
06719 static int G__BesVisLib_rootcint_244_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06720 {
06721 ((BesPaveText*) G__getstructoffset())->SetPos((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06722 G__setnull(result7);
06723 return(1 || funcname || hash || result7 || libp) ;
06724 }
06725
06726 static int G__BesVisLib_rootcint_244_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06727 {
06728 G__letint(result7, 85, (long) BesPaveText::Class());
06729 return(1 || funcname || hash || result7 || libp) ;
06730 }
06731
06732 static int G__BesVisLib_rootcint_244_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06733 {
06734 G__letint(result7, 67, (long) BesPaveText::Class_Name());
06735 return(1 || funcname || hash || result7 || libp) ;
06736 }
06737
06738 static int G__BesVisLib_rootcint_244_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06739 {
06740 G__letint(result7, 115, (long) BesPaveText::Class_Version());
06741 return(1 || funcname || hash || result7 || libp) ;
06742 }
06743
06744 static int G__BesVisLib_rootcint_244_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06745 {
06746 BesPaveText::Dictionary();
06747 G__setnull(result7);
06748 return(1 || funcname || hash || result7 || libp) ;
06749 }
06750
06751 static int G__BesVisLib_rootcint_244_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06752 {
06753 ((BesPaveText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06754 G__setnull(result7);
06755 return(1 || funcname || hash || result7 || libp) ;
06756 }
06757
06758 static int G__BesVisLib_rootcint_244_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06759 {
06760 G__letint(result7, 67, (long) BesPaveText::DeclFileName());
06761 return(1 || funcname || hash || result7 || libp) ;
06762 }
06763
06764 static int G__BesVisLib_rootcint_244_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06765 {
06766 G__letint(result7, 105, (long) BesPaveText::ImplFileLine());
06767 return(1 || funcname || hash || result7 || libp) ;
06768 }
06769
06770 static int G__BesVisLib_rootcint_244_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06771 {
06772 G__letint(result7, 67, (long) BesPaveText::ImplFileName());
06773 return(1 || funcname || hash || result7 || libp) ;
06774 }
06775
06776 static int G__BesVisLib_rootcint_244_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06777 {
06778 G__letint(result7, 105, (long) BesPaveText::DeclFileLine());
06779 return(1 || funcname || hash || result7 || libp) ;
06780 }
06781
06782
06783 typedef BesPaveText G__TBesPaveText;
06784 static int G__BesVisLib_rootcint_244_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06785 {
06786 char* gvp = (char*) G__getgvp();
06787 long soff = G__getstructoffset();
06788 int n = G__getaryconstruct();
06789
06790
06791
06792
06793
06794 if (!soff) {
06795 return(1);
06796 }
06797 if (n) {
06798 if (gvp == (char*)G__PVOID) {
06799 delete[] (BesPaveText*) soff;
06800 } else {
06801 G__setgvp((long) G__PVOID);
06802 for (int i = n - 1; i >= 0; --i) {
06803 ((BesPaveText*) (soff+(sizeof(BesPaveText)*i)))->~G__TBesPaveText();
06804 }
06805 G__setgvp((long)gvp);
06806 }
06807 } else {
06808 if (gvp == (char*)G__PVOID) {
06809 delete (BesPaveText*) soff;
06810 } else {
06811 G__setgvp((long) G__PVOID);
06812 ((BesPaveText*) (soff))->~G__TBesPaveText();
06813 G__setgvp((long)gvp);
06814 }
06815 }
06816 G__setnull(result7);
06817 return(1 || funcname || hash || result7 || libp) ;
06818 }
06819
06820
06821 static int G__BesVisLib_rootcint_244_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06822 {
06823 BesPaveText* dest = (BesPaveText*) G__getstructoffset();
06824 *dest = *(BesPaveText*) libp->para[0].ref;
06825 const BesPaveText& obj = *dest;
06826 result7->ref = (long) (&obj);
06827 result7->obj.i = (long) (&obj);
06828 return(1 || funcname || hash || result7 || libp) ;
06829 }
06830
06831
06832
06833 static int G__BesVisLib_rootcint_249_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06834 {
06835 BesGeoTrack* p = NULL;
06836 char* gvp = (char*) G__getgvp();
06837 int n = G__getaryconstruct();
06838 if (n) {
06839 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06840 p = new BesGeoTrack[n];
06841 } else {
06842 p = new((void*) gvp) BesGeoTrack[n];
06843 }
06844 } else {
06845 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06846 p = new BesGeoTrack;
06847 } else {
06848 p = new((void*) gvp) BesGeoTrack;
06849 }
06850 }
06851 result7->obj.i = (long) p;
06852 result7->ref = (long) p;
06853 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
06854 return(1 || funcname || hash || result7 || libp) ;
06855 }
06856
06857 static int G__BesVisLib_rootcint_249_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06858 {
06859 BesGeoTrack* p = NULL;
06860 char* gvp = (char*) G__getgvp();
06861 switch (libp->paran) {
06862 case 4:
06863
06864 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06865 p = new BesGeoTrack(
06866 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06867 , (TVirtualGeoTrack*) G__int(libp->para[2]), (TObject*) G__int(libp->para[3]));
06868 } else {
06869 p = new((void*) gvp) BesGeoTrack(
06870 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06871 , (TVirtualGeoTrack*) G__int(libp->para[2]), (TObject*) G__int(libp->para[3]));
06872 }
06873 break;
06874 case 3:
06875
06876 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06877 p = new BesGeoTrack(
06878 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06879 , (TVirtualGeoTrack*) G__int(libp->para[2]));
06880 } else {
06881 p = new((void*) gvp) BesGeoTrack(
06882 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06883 , (TVirtualGeoTrack*) G__int(libp->para[2]));
06884 }
06885 break;
06886 case 2:
06887
06888 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06889 p = new BesGeoTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06890 } else {
06891 p = new((void*) gvp) BesGeoTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06892 }
06893 break;
06894 }
06895 result7->obj.i = (long) p;
06896 result7->ref = (long) p;
06897 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
06898 return(1 || funcname || hash || result7 || libp) ;
06899 }
06900
06901 static int G__BesVisLib_rootcint_249_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06902 {
06903 ((BesGeoTrack*) G__getstructoffset())->Init();
06904 G__setnull(result7);
06905 return(1 || funcname || hash || result7 || libp) ;
06906 }
06907
06908 static int G__BesVisLib_rootcint_249_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06909 {
06910 ((BesGeoTrack*) G__getstructoffset())->AddHit((TObject*) G__int(libp->para[0]));
06911 G__setnull(result7);
06912 return(1 || funcname || hash || result7 || libp) ;
06913 }
06914
06915 static int G__BesVisLib_rootcint_249_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06916 {
06917 ((BesGeoTrack*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
06918 G__setnull(result7);
06919 return(1 || funcname || hash || result7 || libp) ;
06920 }
06921
06922 static int G__BesVisLib_rootcint_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06923 {
06924 ((BesGeoTrack*) G__getstructoffset())->CloseInfo();
06925 G__setnull(result7);
06926 return(1 || funcname || hash || result7 || libp) ;
06927 }
06928
06929 static int G__BesVisLib_rootcint_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06930 {
06931 ((BesGeoTrack*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
06932 G__setnull(result7);
06933 return(1 || funcname || hash || result7 || libp) ;
06934 }
06935
06936 static int G__BesVisLib_rootcint_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06937 {
06938 ((BesGeoTrack*) G__getstructoffset())->SetTrackType((Int_t) G__int(libp->para[0]));
06939 G__setnull(result7);
06940 return(1 || funcname || hash || result7 || libp) ;
06941 }
06942
06943 static int G__BesVisLib_rootcint_249_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06944 {
06945 ((BesGeoTrack*) G__getstructoffset())->SetMarker((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
06946 , (Double_t) G__double(libp->para[2]));
06947 G__setnull(result7);
06948 return(1 || funcname || hash || result7 || libp) ;
06949 }
06950
06951 static int G__BesVisLib_rootcint_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06952 {
06953 G__letint(result7, 85, (long) BesGeoTrack::Class());
06954 return(1 || funcname || hash || result7 || libp) ;
06955 }
06956
06957 static int G__BesVisLib_rootcint_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06958 {
06959 G__letint(result7, 67, (long) BesGeoTrack::Class_Name());
06960 return(1 || funcname || hash || result7 || libp) ;
06961 }
06962
06963 static int G__BesVisLib_rootcint_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06964 {
06965 G__letint(result7, 115, (long) BesGeoTrack::Class_Version());
06966 return(1 || funcname || hash || result7 || libp) ;
06967 }
06968
06969 static int G__BesVisLib_rootcint_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06970 {
06971 BesGeoTrack::Dictionary();
06972 G__setnull(result7);
06973 return(1 || funcname || hash || result7 || libp) ;
06974 }
06975
06976 static int G__BesVisLib_rootcint_249_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06977 {
06978 ((BesGeoTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06979 G__setnull(result7);
06980 return(1 || funcname || hash || result7 || libp) ;
06981 }
06982
06983 static int G__BesVisLib_rootcint_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06984 {
06985 G__letint(result7, 67, (long) BesGeoTrack::DeclFileName());
06986 return(1 || funcname || hash || result7 || libp) ;
06987 }
06988
06989 static int G__BesVisLib_rootcint_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06990 {
06991 G__letint(result7, 105, (long) BesGeoTrack::ImplFileLine());
06992 return(1 || funcname || hash || result7 || libp) ;
06993 }
06994
06995 static int G__BesVisLib_rootcint_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06996 {
06997 G__letint(result7, 67, (long) BesGeoTrack::ImplFileName());
06998 return(1 || funcname || hash || result7 || libp) ;
06999 }
07000
07001 static int G__BesVisLib_rootcint_249_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07002 {
07003 G__letint(result7, 105, (long) BesGeoTrack::DeclFileLine());
07004 return(1 || funcname || hash || result7 || libp) ;
07005 }
07006
07007
07008 typedef BesGeoTrack G__TBesGeoTrack;
07009 static int G__BesVisLib_rootcint_249_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07010 {
07011 char* gvp = (char*) G__getgvp();
07012 long soff = G__getstructoffset();
07013 int n = G__getaryconstruct();
07014
07015
07016
07017
07018
07019 if (!soff) {
07020 return(1);
07021 }
07022 if (n) {
07023 if (gvp == (char*)G__PVOID) {
07024 delete[] (BesGeoTrack*) soff;
07025 } else {
07026 G__setgvp((long) G__PVOID);
07027 for (int i = n - 1; i >= 0; --i) {
07028 ((BesGeoTrack*) (soff+(sizeof(BesGeoTrack)*i)))->~G__TBesGeoTrack();
07029 }
07030 G__setgvp((long)gvp);
07031 }
07032 } else {
07033 if (gvp == (char*)G__PVOID) {
07034 delete (BesGeoTrack*) soff;
07035 } else {
07036 G__setgvp((long) G__PVOID);
07037 ((BesGeoTrack*) (soff))->~G__TBesGeoTrack();
07038 G__setgvp((long)gvp);
07039 }
07040 }
07041 G__setnull(result7);
07042 return(1 || funcname || hash || result7 || libp) ;
07043 }
07044
07045
07046
07047 static int G__BesVisLib_rootcint_529_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07048 {
07049 BesEvent* p = NULL;
07050 char* gvp = (char*) G__getgvp();
07051 int n = G__getaryconstruct();
07052 if (n) {
07053 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07054 p = new BesEvent[n];
07055 } else {
07056 p = new((void*) gvp) BesEvent[n];
07057 }
07058 } else {
07059 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07060 p = new BesEvent;
07061 } else {
07062 p = new((void*) gvp) BesEvent;
07063 }
07064 }
07065 result7->obj.i = (long) p;
07066 result7->ref = (long) p;
07067 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
07068 return(1 || funcname || hash || result7 || libp) ;
07069 }
07070
07071 static int G__BesVisLib_rootcint_529_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07072 {
07073 switch (libp->paran) {
07074 case 1:
07075 ((BesEvent*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
07076 G__setnull(result7);
07077 break;
07078 case 0:
07079 ((BesEvent*) G__getstructoffset())->Print();
07080 G__setnull(result7);
07081 break;
07082 }
07083 return(1 || funcname || hash || result7 || libp) ;
07084 }
07085
07086 static int G__BesVisLib_rootcint_529_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07087 {
07088 ((BesEvent*) G__getstructoffset())->SetEvent((TDigiEvent*) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])
07089 , (TEvtHeader*) G__int(libp->para[2]), (TRecEvTime*) G__int(libp->para[3]));
07090 G__setnull(result7);
07091 return(1 || funcname || hash || result7 || libp) ;
07092 }
07093
07094 static int G__BesVisLib_rootcint_529_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07095 {
07096 ((BesEvent*) G__getstructoffset())->SetHits();
07097 G__setnull(result7);
07098 return(1 || funcname || hash || result7 || libp) ;
07099 }
07100
07101 static int G__BesVisLib_rootcint_529_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07102 {
07103 ((BesEvent*) G__getstructoffset())->SetTracks((TDisTrack*) G__int(libp->para[0]));
07104 G__setnull(result7);
07105 return(1 || funcname || hash || result7 || libp) ;
07106 }
07107
07108 static int G__BesVisLib_rootcint_529_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07109 {
07110 ((BesEvent*) G__getstructoffset())->SetMdcTracks((TDisTrack*) G__int(libp->para[0]));
07111 G__setnull(result7);
07112 return(1 || funcname || hash || result7 || libp) ;
07113 }
07114
07115 static int G__BesVisLib_rootcint_529_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07116 {
07117 ((BesEvent*) G__getstructoffset())->SetTofTracks((TDisTrack*) G__int(libp->para[0]));
07118 G__setnull(result7);
07119 return(1 || funcname || hash || result7 || libp) ;
07120 }
07121
07122 static int G__BesVisLib_rootcint_529_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07123 {
07124 ((BesEvent*) G__getstructoffset())->SetEmcShowers((TDisTrack*) G__int(libp->para[0]));
07125 G__setnull(result7);
07126 return(1 || funcname || hash || result7 || libp) ;
07127 }
07128
07129 static int G__BesVisLib_rootcint_529_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07130 {
07131 ((BesEvent*) G__getstructoffset())->SetMucTracks((TDisTrack*) G__int(libp->para[0]));
07132 G__setnull(result7);
07133 return(1 || funcname || hash || result7 || libp) ;
07134 }
07135
07136 static int G__BesVisLib_rootcint_529_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07137 {
07138 ((BesEvent*) G__getstructoffset())->SetExtTracks((TDisTrack*) G__int(libp->para[0]));
07139 G__setnull(result7);
07140 return(1 || funcname || hash || result7 || libp) ;
07141 }
07142
07143 static int G__BesVisLib_rootcint_529_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07144 {
07145 ((BesEvent*) G__getstructoffset())->ConstructMdcTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecMdcTrack*) G__int(libp->para[1])
07146 , (TDisTrack*) G__int(libp->para[2]));
07147 G__setnull(result7);
07148 return(1 || funcname || hash || result7 || libp) ;
07149 }
07150
07151 static int G__BesVisLib_rootcint_529_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07152 {
07153 ((BesEvent*) G__getstructoffset())->ConstructMucTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecMucTrack*) G__int(libp->para[1]));
07154 G__setnull(result7);
07155 return(1 || funcname || hash || result7 || libp) ;
07156 }
07157
07158 static int G__BesVisLib_rootcint_529_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07159 {
07160 ((BesEvent*) G__getstructoffset())->ConstructEmcTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecEmcShower*) G__int(libp->para[1]));
07161 G__setnull(result7);
07162 return(1 || funcname || hash || result7 || libp) ;
07163 }
07164
07165 static int G__BesVisLib_rootcint_529_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07166 {
07167 ((BesEvent*) G__getstructoffset())->ConstructTofTrackFromRec((BesGeoTrack*) G__int(libp->para[0]), (TRecTofTrack*) G__int(libp->para[1])
07168 , (TDisTrack*) G__int(libp->para[2]));
07169 G__setnull(result7);
07170 return(1 || funcname || hash || result7 || libp) ;
07171 }
07172
07173 static int G__BesVisLib_rootcint_529_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07174 {
07175 ((BesEvent*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
07176 G__setnull(result7);
07177 return(1 || funcname || hash || result7 || libp) ;
07178 }
07179
07180 static int G__BesVisLib_rootcint_529_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07181 {
07182 ((BesEvent*) G__getstructoffset())->DrawTracks((Option_t*) G__int(libp->para[0]));
07183 G__setnull(result7);
07184 return(1 || funcname || hash || result7 || libp) ;
07185 }
07186
07187 static int G__BesVisLib_rootcint_529_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07188 {
07189 ((BesEvent*) G__getstructoffset())->SetMagnetic((Double_t) G__double(libp->para[0]));
07190 G__setnull(result7);
07191 return(1 || funcname || hash || result7 || libp) ;
07192 }
07193
07194 static int G__BesVisLib_rootcint_529_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07195 {
07196 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcDigiCol());
07197 return(1 || funcname || hash || result7 || libp) ;
07198 }
07199
07200 static int G__BesVisLib_rootcint_529_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07201 {
07202 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofDigiCol());
07203 return(1 || funcname || hash || result7 || libp) ;
07204 }
07205
07206 static int G__BesVisLib_rootcint_529_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07207 {
07208 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcDigiCol());
07209 return(1 || funcname || hash || result7 || libp) ;
07210 }
07211
07212 static int G__BesVisLib_rootcint_529_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07213 {
07214 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucDigiCol());
07215 return(1 || funcname || hash || result7 || libp) ;
07216 }
07217
07218 static int G__BesVisLib_rootcint_529_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07219 {
07220 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMdcDigiNum());
07221 return(1 || funcname || hash || result7 || libp) ;
07222 }
07223
07224 static int G__BesVisLib_rootcint_529_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07225 {
07226 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetTofDigiNum());
07227 return(1 || funcname || hash || result7 || libp) ;
07228 }
07229
07230 static int G__BesVisLib_rootcint_529_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07231 {
07232 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetEmcDigiNum());
07233 return(1 || funcname || hash || result7 || libp) ;
07234 }
07235
07236 static int G__BesVisLib_rootcint_529_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07237 {
07238 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMucDigiNum());
07239 return(1 || funcname || hash || result7 || libp) ;
07240 }
07241
07242 static int G__BesVisLib_rootcint_529_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07243 {
07244 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcDigi((Int_t) G__int(libp->para[0])));
07245 return(1 || funcname || hash || result7 || libp) ;
07246 }
07247
07248 static int G__BesVisLib_rootcint_529_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07249 {
07250 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofDigi((Int_t) G__int(libp->para[0])));
07251 return(1 || funcname || hash || result7 || libp) ;
07252 }
07253
07254 static int G__BesVisLib_rootcint_529_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07255 {
07256 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcDigi((Int_t) G__int(libp->para[0])));
07257 return(1 || funcname || hash || result7 || libp) ;
07258 }
07259
07260 static int G__BesVisLib_rootcint_529_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07261 {
07262 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucDigi((Int_t) G__int(libp->para[0])));
07263 return(1 || funcname || hash || result7 || libp) ;
07264 }
07265
07266 static int G__BesVisLib_rootcint_529_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07267 {
07268 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcTrackCol((TDisTrack*) G__int(libp->para[0])));
07269 return(1 || funcname || hash || result7 || libp) ;
07270 }
07271
07272 static int G__BesVisLib_rootcint_529_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07273 {
07274 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofTrackCol((TDisTrack*) G__int(libp->para[0])));
07275 return(1 || funcname || hash || result7 || libp) ;
07276 }
07277
07278 static int G__BesVisLib_rootcint_529_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07279 {
07280 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcShowerCol((TDisTrack*) G__int(libp->para[0])));
07281 return(1 || funcname || hash || result7 || libp) ;
07282 }
07283
07284 static int G__BesVisLib_rootcint_529_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07285 {
07286 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucTrackCol((TDisTrack*) G__int(libp->para[0])));
07287 return(1 || funcname || hash || result7 || libp) ;
07288 }
07289
07290 static int G__BesVisLib_rootcint_529_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07291 {
07292 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetExtTrackCol());
07293 return(1 || funcname || hash || result7 || libp) ;
07294 }
07295
07296 static int G__BesVisLib_rootcint_529_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07297 {
07298 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetDedxCol((TDisTrack*) G__int(libp->para[0])));
07299 return(1 || funcname || hash || result7 || libp) ;
07300 }
07301
07302 static int G__BesVisLib_rootcint_529_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07303 {
07304 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMdcTrackNum((TDisTrack*) G__int(libp->para[0])));
07305 return(1 || funcname || hash || result7 || libp) ;
07306 }
07307
07308 static int G__BesVisLib_rootcint_529_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07309 {
07310 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetTofTrackNum((TDisTrack*) G__int(libp->para[0])));
07311 return(1 || funcname || hash || result7 || libp) ;
07312 }
07313
07314 static int G__BesVisLib_rootcint_529_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07315 {
07316 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetEmcShowerNum((TDisTrack*) G__int(libp->para[0])));
07317 return(1 || funcname || hash || result7 || libp) ;
07318 }
07319
07320 static int G__BesVisLib_rootcint_529_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07321 {
07322 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetMucTrackNum((TDisTrack*) G__int(libp->para[0])));
07323 return(1 || funcname || hash || result7 || libp) ;
07324 }
07325
07326 static int G__BesVisLib_rootcint_529_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07327 {
07328 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetExtTrackNum());
07329 return(1 || funcname || hash || result7 || libp) ;
07330 }
07331
07332 static int G__BesVisLib_rootcint_529_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07333 {
07334 G__letint(result7, 105, (long) ((const BesEvent*) G__getstructoffset())->GetDedxNum((TDisTrack*) G__int(libp->para[0])));
07335 return(1 || funcname || hash || result7 || libp) ;
07336 }
07337
07338 static int G__BesVisLib_rootcint_529_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07339 {
07340 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMdcTrack((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
07341 return(1 || funcname || hash || result7 || libp) ;
07342 }
07343
07344 static int G__BesVisLib_rootcint_529_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07345 {
07346 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetTofTrack((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
07347 return(1 || funcname || hash || result7 || libp) ;
07348 }
07349
07350 static int G__BesVisLib_rootcint_529_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07351 {
07352 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetEmcShower((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
07353 return(1 || funcname || hash || result7 || libp) ;
07354 }
07355
07356 static int G__BesVisLib_rootcint_529_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07357 {
07358 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetMucTrack((Int_t) G__int(libp->para[0]), (TDisTrack*) G__int(libp->para[1])));
07359 return(1 || funcname || hash || result7 || libp) ;
07360 }
07361
07362 static int G__BesVisLib_rootcint_529_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07363 {
07364 G__letint(result7, 85, (long) ((const BesEvent*) G__getstructoffset())->GetDedx((Int_t) G__int(libp->para[0])));
07365 return(1 || funcname || hash || result7 || libp) ;
07366 }
07367
07368 static int G__BesVisLib_rootcint_529_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07369 {
07370 G__letLonglong(result7, 110, (G__int64) ((BesEvent*) G__getstructoffset())->GetRun());
07371 return(1 || funcname || hash || result7 || libp) ;
07372 }
07373
07374 static int G__BesVisLib_rootcint_529_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07375 {
07376 G__letLonglong(result7, 110, (G__int64) ((BesEvent*) G__getstructoffset())->GetEvent());
07377 return(1 || funcname || hash || result7 || libp) ;
07378 }
07379
07380 static int G__BesVisLib_rootcint_529_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07381 {
07382 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetYear());
07383 return(1 || funcname || hash || result7 || libp) ;
07384 }
07385
07386 static int G__BesVisLib_rootcint_529_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07387 {
07388 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetMonth());
07389 return(1 || funcname || hash || result7 || libp) ;
07390 }
07391
07392 static int G__BesVisLib_rootcint_529_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07393 {
07394 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetDay());
07395 return(1 || funcname || hash || result7 || libp) ;
07396 }
07397
07398 static int G__BesVisLib_rootcint_529_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07399 {
07400 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetHour());
07401 return(1 || funcname || hash || result7 || libp) ;
07402 }
07403
07404 static int G__BesVisLib_rootcint_529_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07405 {
07406 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetMin());
07407 return(1 || funcname || hash || result7 || libp) ;
07408 }
07409
07410 static int G__BesVisLib_rootcint_529_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07411 {
07412 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetSec());
07413 return(1 || funcname || hash || result7 || libp) ;
07414 }
07415
07416 static int G__BesVisLib_rootcint_529_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07417 {
07418 G__letint(result7, 105, (long) ((BesEvent*) G__getstructoffset())->GetMC());
07419 return(1 || funcname || hash || result7 || libp) ;
07420 }
07421
07422 static int G__BesVisLib_rootcint_529_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07423 {
07424 {
07425 BesEventHeader* pobj;
07426 BesEventHeader xobj = ((BesEvent*) G__getstructoffset())->GetHeader();
07427 pobj = new BesEventHeader(xobj);
07428 result7->obj.i = (long) ((void*) pobj);
07429 result7->ref = result7->obj.i;
07430 G__store_tempobject(*result7);
07431 }
07432 return(1 || funcname || hash || result7 || libp) ;
07433 }
07434
07435 static int G__BesVisLib_rootcint_529_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07436 {
07437 G__letint(result7, 85, (long) BesEvent::Class());
07438 return(1 || funcname || hash || result7 || libp) ;
07439 }
07440
07441 static int G__BesVisLib_rootcint_529_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07442 {
07443 G__letint(result7, 67, (long) BesEvent::Class_Name());
07444 return(1 || funcname || hash || result7 || libp) ;
07445 }
07446
07447 static int G__BesVisLib_rootcint_529_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07448 {
07449 G__letint(result7, 115, (long) BesEvent::Class_Version());
07450 return(1 || funcname || hash || result7 || libp) ;
07451 }
07452
07453 static int G__BesVisLib_rootcint_529_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07454 {
07455 BesEvent::Dictionary();
07456 G__setnull(result7);
07457 return(1 || funcname || hash || result7 || libp) ;
07458 }
07459
07460 static int G__BesVisLib_rootcint_529_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07461 {
07462 ((BesEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07463 G__setnull(result7);
07464 return(1 || funcname || hash || result7 || libp) ;
07465 }
07466
07467 static int G__BesVisLib_rootcint_529_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07468 {
07469 G__letint(result7, 67, (long) BesEvent::DeclFileName());
07470 return(1 || funcname || hash || result7 || libp) ;
07471 }
07472
07473 static int G__BesVisLib_rootcint_529_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07474 {
07475 G__letint(result7, 105, (long) BesEvent::ImplFileLine());
07476 return(1 || funcname || hash || result7 || libp) ;
07477 }
07478
07479 static int G__BesVisLib_rootcint_529_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07480 {
07481 G__letint(result7, 67, (long) BesEvent::ImplFileName());
07482 return(1 || funcname || hash || result7 || libp) ;
07483 }
07484
07485 static int G__BesVisLib_rootcint_529_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07486 {
07487 G__letint(result7, 105, (long) BesEvent::DeclFileLine());
07488 return(1 || funcname || hash || result7 || libp) ;
07489 }
07490
07491
07492 static int G__BesVisLib_rootcint_529_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07493
07494 {
07495 BesEvent* p;
07496 void* tmp = (void*) G__int(libp->para[0]);
07497 p = new BesEvent(*(BesEvent*) tmp);
07498 result7->obj.i = (long) p;
07499 result7->ref = (long) p;
07500 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
07501 return(1 || funcname || hash || result7 || libp) ;
07502 }
07503
07504
07505 typedef BesEvent G__TBesEvent;
07506 static int G__BesVisLib_rootcint_529_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07507 {
07508 char* gvp = (char*) G__getgvp();
07509 long soff = G__getstructoffset();
07510 int n = G__getaryconstruct();
07511
07512
07513
07514
07515
07516 if (!soff) {
07517 return(1);
07518 }
07519 if (n) {
07520 if (gvp == (char*)G__PVOID) {
07521 delete[] (BesEvent*) soff;
07522 } else {
07523 G__setgvp((long) G__PVOID);
07524 for (int i = n - 1; i >= 0; --i) {
07525 ((BesEvent*) (soff+(sizeof(BesEvent)*i)))->~G__TBesEvent();
07526 }
07527 G__setgvp((long)gvp);
07528 }
07529 } else {
07530 if (gvp == (char*)G__PVOID) {
07531 delete (BesEvent*) soff;
07532 } else {
07533 G__setgvp((long) G__PVOID);
07534 ((BesEvent*) (soff))->~G__TBesEvent();
07535 G__setgvp((long)gvp);
07536 }
07537 }
07538 G__setnull(result7);
07539 return(1 || funcname || hash || result7 || libp) ;
07540 }
07541
07542
07543 static int G__BesVisLib_rootcint_529_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07544 {
07545 BesEvent* dest = (BesEvent*) G__getstructoffset();
07546 *dest = *(BesEvent*) libp->para[0].ref;
07547 const BesEvent& obj = *dest;
07548 result7->ref = (long) (&obj);
07549 result7->obj.i = (long) (&obj);
07550 return(1 || funcname || hash || result7 || libp) ;
07551 }
07552
07553
07554
07555 static int G__BesVisLib_rootcint_798_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07556 {
07557 SubDetectorROOTGeo* p = NULL;
07558 char* gvp = (char*) G__getgvp();
07559 int n = G__getaryconstruct();
07560 if (n) {
07561 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07562 p = new SubDetectorROOTGeo[n];
07563 } else {
07564 p = new((void*) gvp) SubDetectorROOTGeo[n];
07565 }
07566 } else {
07567 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07568 p = new SubDetectorROOTGeo;
07569 } else {
07570 p = new((void*) gvp) SubDetectorROOTGeo;
07571 }
07572 }
07573 result7->obj.i = (long) p;
07574 result7->ref = (long) p;
07575 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
07576 return(1 || funcname || hash || result7 || libp) ;
07577 }
07578
07579 static int G__BesVisLib_rootcint_798_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07580 {
07581 ((SubDetectorROOTGeo*) G__getstructoffset())->ReadGdml((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07582 G__setnull(result7);
07583 return(1 || funcname || hash || result7 || libp) ;
07584 }
07585
07586 static int G__BesVisLib_rootcint_798_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07587 {
07588 G__letint(result7, 105, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->IsInitialized());
07589 return(1 || funcname || hash || result7 || libp) ;
07590 }
07591
07592 static int G__BesVisLib_rootcint_798_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07593 {
07594 ((SubDetectorROOTGeo*) G__getstructoffset())->SetChildNo((int) G__int(libp->para[0]));
07595 G__setnull(result7);
07596 return(1 || funcname || hash || result7 || libp) ;
07597 }
07598
07599 static int G__BesVisLib_rootcint_798_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07600 {
07601 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetLogicalVolume(*(string*) libp->para[0].ref));
07602 return(1 || funcname || hash || result7 || libp) ;
07603 }
07604
07605 static int G__BesVisLib_rootcint_798_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07606 {
07607 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetTopVolume());
07608 return(1 || funcname || hash || result7 || libp) ;
07609 }
07610
07611 static int G__BesVisLib_rootcint_798_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07612 {
07613 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetAssemblyVolume(*(string*) libp->para[0].ref));
07614 return(1 || funcname || hash || result7 || libp) ;
07615 }
07616
07617 static int G__BesVisLib_rootcint_798_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07618 {
07619 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetNode(*(string*) libp->para[0].ref));
07620 return(1 || funcname || hash || result7 || libp) ;
07621 }
07622
07623 static int G__BesVisLib_rootcint_798_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07624 {
07625 G__letint(result7, 105, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetHitsNum());
07626 return(1 || funcname || hash || result7 || libp) ;
07627 }
07628
07629 static int G__BesVisLib_rootcint_798_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07630 {
07631 G__letint(result7, 85, (long) ((SubDetectorROOTGeo*) G__getstructoffset())->GetHit((int) G__int(libp->para[0])));
07632 return(1 || funcname || hash || result7 || libp) ;
07633 }
07634
07635 static int G__BesVisLib_rootcint_798_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07636 {
07637 ((SubDetectorROOTGeo*) G__getstructoffset())->SetDetectorOn();
07638 G__setnull(result7);
07639 return(1 || funcname || hash || result7 || libp) ;
07640 }
07641
07642
07643 static int G__BesVisLib_rootcint_798_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07644
07645 {
07646 SubDetectorROOTGeo* p;
07647 void* tmp = (void*) G__int(libp->para[0]);
07648 p = new SubDetectorROOTGeo(*(SubDetectorROOTGeo*) tmp);
07649 result7->obj.i = (long) p;
07650 result7->ref = (long) p;
07651 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
07652 return(1 || funcname || hash || result7 || libp) ;
07653 }
07654
07655
07656 typedef SubDetectorROOTGeo G__TSubDetectorROOTGeo;
07657 static int G__BesVisLib_rootcint_798_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07658 {
07659 char* gvp = (char*) G__getgvp();
07660 long soff = G__getstructoffset();
07661 int n = G__getaryconstruct();
07662
07663
07664
07665
07666
07667 if (!soff) {
07668 return(1);
07669 }
07670 if (n) {
07671 if (gvp == (char*)G__PVOID) {
07672 delete[] (SubDetectorROOTGeo*) soff;
07673 } else {
07674 G__setgvp((long) G__PVOID);
07675 for (int i = n - 1; i >= 0; --i) {
07676 ((SubDetectorROOTGeo*) (soff+(sizeof(SubDetectorROOTGeo)*i)))->~G__TSubDetectorROOTGeo();
07677 }
07678 G__setgvp((long)gvp);
07679 }
07680 } else {
07681 if (gvp == (char*)G__PVOID) {
07682 delete (SubDetectorROOTGeo*) soff;
07683 } else {
07684 G__setgvp((long) G__PVOID);
07685 ((SubDetectorROOTGeo*) (soff))->~G__TSubDetectorROOTGeo();
07686 G__setgvp((long)gvp);
07687 }
07688 }
07689 G__setnull(result7);
07690 return(1 || funcname || hash || result7 || libp) ;
07691 }
07692
07693
07694
07695 static int G__BesVisLib_rootcint_836_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07696 {
07697 BesPolygon2D* p = NULL;
07698 char* gvp = (char*) G__getgvp();
07699 int n = G__getaryconstruct();
07700 if (n) {
07701 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07702 p = new BesPolygon2D[n];
07703 } else {
07704 p = new((void*) gvp) BesPolygon2D[n];
07705 }
07706 } else {
07707 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07708 p = new BesPolygon2D;
07709 } else {
07710 p = new((void*) gvp) BesPolygon2D;
07711 }
07712 }
07713 result7->obj.i = (long) p;
07714 result7->ref = (long) p;
07715 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
07716 return(1 || funcname || hash || result7 || libp) ;
07717 }
07718
07719 static int G__BesVisLib_rootcint_836_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07720 {
07721 BesPolygon2D* p = NULL;
07722 char* gvp = (char*) G__getgvp();
07723
07724 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07725 p = new BesPolygon2D(
07726 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07727 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
07728 } else {
07729 p = new((void*) gvp) BesPolygon2D(
07730 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07731 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
07732 }
07733 result7->obj.i = (long) p;
07734 result7->ref = (long) p;
07735 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
07736 return(1 || funcname || hash || result7 || libp) ;
07737 }
07738
07739 static int G__BesVisLib_rootcint_836_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07740 {
07741 ((BesPolygon2D*) G__getstructoffset())->SetZRSign((Int_t) G__int(libp->para[0]));
07742 G__setnull(result7);
07743 return(1 || funcname || hash || result7 || libp) ;
07744 }
07745
07746 static int G__BesVisLib_rootcint_836_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07747 {
07748 ((BesPolygon2D*) G__getstructoffset())->Resize((Double_t) G__double(libp->para[0]));
07749 G__setnull(result7);
07750 return(1 || funcname || hash || result7 || libp) ;
07751 }
07752
07753 static int G__BesVisLib_rootcint_836_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07754 {
07755 ((BesPolygon2D*) G__getstructoffset())->SetInfoBox();
07756 G__setnull(result7);
07757 return(1 || funcname || hash || result7 || libp) ;
07758 }
07759
07760 static int G__BesVisLib_rootcint_836_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07761 {
07762 ((const BesPolygon2D*) G__getstructoffset())->GetCenter((Double_t*) G__int(libp->para[0]));
07763 G__setnull(result7);
07764 return(1 || funcname || hash || result7 || libp) ;
07765 }
07766
07767 static int G__BesVisLib_rootcint_836_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07768 {
07769 ((BesPolygon2D*) G__getstructoffset())->RotatePhi((Double_t) G__double(libp->para[0]));
07770 G__setnull(result7);
07771 return(1 || funcname || hash || result7 || libp) ;
07772 }
07773
07774 static int G__BesVisLib_rootcint_836_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07775 {
07776 ((BesPolygon2D*) G__getstructoffset())->Restore();
07777 G__setnull(result7);
07778 return(1 || funcname || hash || result7 || libp) ;
07779 }
07780
07781 static int G__BesVisLib_rootcint_836_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07782 {
07783 ((BesPolygon2D*) G__getstructoffset())->SetSize((Double_t) G__double(libp->para[0]));
07784 G__setnull(result7);
07785 return(1 || funcname || hash || result7 || libp) ;
07786 }
07787
07788 static int G__BesVisLib_rootcint_836_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07789 {
07790 G__letint(result7, 103, (long) ((BesPolygon2D*) G__getstructoffset())->IsRotatable());
07791 return(1 || funcname || hash || result7 || libp) ;
07792 }
07793
07794 static int G__BesVisLib_rootcint_836_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07795 {
07796 ((BesPolygon2D*) G__getstructoffset())->SetRotatable((Bool_t) G__int(libp->para[0]));
07797 G__setnull(result7);
07798 return(1 || funcname || hash || result7 || libp) ;
07799 }
07800
07801 static int G__BesVisLib_rootcint_836_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07802 {
07803 ((BesPolygon2D*) G__getstructoffset())->DrawClass();
07804 G__setnull(result7);
07805 return(1 || funcname || hash || result7 || libp) ;
07806 }
07807
07808 static int G__BesVisLib_rootcint_836_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07809 {
07810 ((BesPolygon2D*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0]));
07811 G__setnull(result7);
07812 return(1 || funcname || hash || result7 || libp) ;
07813 }
07814
07815 static int G__BesVisLib_rootcint_836_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07816 {
07817 ((BesPolygon2D*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
07818 G__setnull(result7);
07819 return(1 || funcname || hash || result7 || libp) ;
07820 }
07821
07822 static int G__BesVisLib_rootcint_836_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07823 {
07824 G__letint(result7, 85, (long) BesPolygon2D::Class());
07825 return(1 || funcname || hash || result7 || libp) ;
07826 }
07827
07828 static int G__BesVisLib_rootcint_836_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07829 {
07830 G__letint(result7, 67, (long) BesPolygon2D::Class_Name());
07831 return(1 || funcname || hash || result7 || libp) ;
07832 }
07833
07834 static int G__BesVisLib_rootcint_836_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07835 {
07836 G__letint(result7, 115, (long) BesPolygon2D::Class_Version());
07837 return(1 || funcname || hash || result7 || libp) ;
07838 }
07839
07840 static int G__BesVisLib_rootcint_836_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07841 {
07842 BesPolygon2D::Dictionary();
07843 G__setnull(result7);
07844 return(1 || funcname || hash || result7 || libp) ;
07845 }
07846
07847 static int G__BesVisLib_rootcint_836_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07848 {
07849 ((BesPolygon2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07850 G__setnull(result7);
07851 return(1 || funcname || hash || result7 || libp) ;
07852 }
07853
07854 static int G__BesVisLib_rootcint_836_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07855 {
07856 G__letint(result7, 67, (long) BesPolygon2D::DeclFileName());
07857 return(1 || funcname || hash || result7 || libp) ;
07858 }
07859
07860 static int G__BesVisLib_rootcint_836_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07861 {
07862 G__letint(result7, 105, (long) BesPolygon2D::ImplFileLine());
07863 return(1 || funcname || hash || result7 || libp) ;
07864 }
07865
07866 static int G__BesVisLib_rootcint_836_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07867 {
07868 G__letint(result7, 67, (long) BesPolygon2D::ImplFileName());
07869 return(1 || funcname || hash || result7 || libp) ;
07870 }
07871
07872 static int G__BesVisLib_rootcint_836_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07873 {
07874 G__letint(result7, 105, (long) BesPolygon2D::DeclFileLine());
07875 return(1 || funcname || hash || result7 || libp) ;
07876 }
07877
07878
07879 static int G__BesVisLib_rootcint_836_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07880
07881 {
07882 BesPolygon2D* p;
07883 void* tmp = (void*) G__int(libp->para[0]);
07884 p = new BesPolygon2D(*(BesPolygon2D*) tmp);
07885 result7->obj.i = (long) p;
07886 result7->ref = (long) p;
07887 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
07888 return(1 || funcname || hash || result7 || libp) ;
07889 }
07890
07891
07892 typedef BesPolygon2D G__TBesPolygon2D;
07893 static int G__BesVisLib_rootcint_836_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07894 {
07895 char* gvp = (char*) G__getgvp();
07896 long soff = G__getstructoffset();
07897 int n = G__getaryconstruct();
07898
07899
07900
07901
07902
07903 if (!soff) {
07904 return(1);
07905 }
07906 if (n) {
07907 if (gvp == (char*)G__PVOID) {
07908 delete[] (BesPolygon2D*) soff;
07909 } else {
07910 G__setgvp((long) G__PVOID);
07911 for (int i = n - 1; i >= 0; --i) {
07912 ((BesPolygon2D*) (soff+(sizeof(BesPolygon2D)*i)))->~G__TBesPolygon2D();
07913 }
07914 G__setgvp((long)gvp);
07915 }
07916 } else {
07917 if (gvp == (char*)G__PVOID) {
07918 delete (BesPolygon2D*) soff;
07919 } else {
07920 G__setgvp((long) G__PVOID);
07921 ((BesPolygon2D*) (soff))->~G__TBesPolygon2D();
07922 G__setgvp((long)gvp);
07923 }
07924 }
07925 G__setnull(result7);
07926 return(1 || funcname || hash || result7 || libp) ;
07927 }
07928
07929
07930 static int G__BesVisLib_rootcint_836_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07931 {
07932 BesPolygon2D* dest = (BesPolygon2D*) G__getstructoffset();
07933 *dest = *(BesPolygon2D*) libp->para[0].ref;
07934 const BesPolygon2D& obj = *dest;
07935 result7->ref = (long) (&obj);
07936 result7->obj.i = (long) (&obj);
07937 return(1 || funcname || hash || result7 || libp) ;
07938 }
07939
07940
07941
07942 static int G__BesVisLib_rootcint_837_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07943 {
07944 Mdc2DWire* p = NULL;
07945 char* gvp = (char*) G__getgvp();
07946 int n = G__getaryconstruct();
07947 if (n) {
07948 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07949 p = new Mdc2DWire[n];
07950 } else {
07951 p = new((void*) gvp) Mdc2DWire[n];
07952 }
07953 } else {
07954 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07955 p = new Mdc2DWire;
07956 } else {
07957 p = new((void*) gvp) Mdc2DWire;
07958 }
07959 }
07960 result7->obj.i = (long) p;
07961 result7->ref = (long) p;
07962 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
07963 return(1 || funcname || hash || result7 || libp) ;
07964 }
07965
07966 static int G__BesVisLib_rootcint_837_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07967 {
07968 Mdc2DWire* p = NULL;
07969 char* gvp = (char*) G__getgvp();
07970
07971 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07972 p = new Mdc2DWire(
07973 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07974 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
07975 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
07976 , (Double_t*) G__int(libp->para[6]));
07977 } else {
07978 p = new((void*) gvp) Mdc2DWire(
07979 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07980 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
07981 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
07982 , (Double_t*) G__int(libp->para[6]));
07983 }
07984 result7->obj.i = (long) p;
07985 result7->ref = (long) p;
07986 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
07987 return(1 || funcname || hash || result7 || libp) ;
07988 }
07989
07990 static int G__BesVisLib_rootcint_837_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07991 {
07992 Mdc2DWire* p = NULL;
07993 char* gvp = (char*) G__getgvp();
07994
07995 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07996 p = new Mdc2DWire(
07997 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07998 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
07999 } else {
08000 p = new((void*) gvp) Mdc2DWire(
08001 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08002 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
08003 }
08004 result7->obj.i = (long) p;
08005 result7->ref = (long) p;
08006 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
08007 return(1 || funcname || hash || result7 || libp) ;
08008 }
08009
08010 static int G__BesVisLib_rootcint_837_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08011 {
08012 ((Mdc2DWire*) G__getstructoffset())->Init();
08013 G__setnull(result7);
08014 return(1 || funcname || hash || result7 || libp) ;
08015 }
08016
08017 static int G__BesVisLib_rootcint_837_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08018 {
08019 ((Mdc2DWire*) G__getstructoffset())->SetStyle();
08020 G__setnull(result7);
08021 return(1 || funcname || hash || result7 || libp) ;
08022 }
08023
08024 static int G__BesVisLib_rootcint_837_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08025 {
08026 switch (libp->paran) {
08027 case 1:
08028 ((Mdc2DWire*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
08029 G__setnull(result7);
08030 break;
08031 case 0:
08032 ((Mdc2DWire*) G__getstructoffset())->SetHighlighted();
08033 G__setnull(result7);
08034 break;
08035 }
08036 return(1 || funcname || hash || result7 || libp) ;
08037 }
08038
08039 static int G__BesVisLib_rootcint_837_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08040 {
08041 switch (libp->paran) {
08042 case 1:
08043 ((Mdc2DWire*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
08044 G__setnull(result7);
08045 break;
08046 case 0:
08047 ((Mdc2DWire*) G__getstructoffset())->SetFired();
08048 G__setnull(result7);
08049 break;
08050 }
08051 return(1 || funcname || hash || result7 || libp) ;
08052 }
08053
08054 static int G__BesVisLib_rootcint_837_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08055 {
08056 G__letint(result7, 103, (long) ((Mdc2DWire*) G__getstructoffset())->IsHighlighted());
08057 return(1 || funcname || hash || result7 || libp) ;
08058 }
08059
08060 static int G__BesVisLib_rootcint_837_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08061 {
08062 G__letint(result7, 103, (long) ((Mdc2DWire*) G__getstructoffset())->IsFired());
08063 return(1 || funcname || hash || result7 || libp) ;
08064 }
08065
08066 static int G__BesVisLib_rootcint_837_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08067 {
08068 ((Mdc2DWire*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
08069 G__setnull(result7);
08070 return(1 || funcname || hash || result7 || libp) ;
08071 }
08072
08073 static int G__BesVisLib_rootcint_837_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08074 {
08075 ((Mdc2DWire*) G__getstructoffset())->CloseInfo();
08076 G__setnull(result7);
08077 return(1 || funcname || hash || result7 || libp) ;
08078 }
08079
08080 static int G__BesVisLib_rootcint_837_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08081 {
08082 ((Mdc2DWire*) G__getstructoffset())->ClearInfo();
08083 G__setnull(result7);
08084 return(1 || funcname || hash || result7 || libp) ;
08085 }
08086
08087 static int G__BesVisLib_rootcint_837_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08088 {
08089 G__letint(result7, 103, (long) ((Mdc2DWire*) G__getstructoffset())->HasZRSection());
08090 return(1 || funcname || hash || result7 || libp) ;
08091 }
08092
08093 static int G__BesVisLib_rootcint_837_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08094 {
08095 G__letdouble(result7, 100, (double) ((Mdc2DWire*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
08096 return(1 || funcname || hash || result7 || libp) ;
08097 }
08098
08099 static int G__BesVisLib_rootcint_837_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08100 {
08101 ((Mdc2DWire*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
08102 G__setnull(result7);
08103 return(1 || funcname || hash || result7 || libp) ;
08104 }
08105
08106 static int G__BesVisLib_rootcint_837_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08107 {
08108 ((Mdc2DWire*) G__getstructoffset())->SetCharge((Double_t) G__double(libp->para[0]));
08109 G__setnull(result7);
08110 return(1 || funcname || hash || result7 || libp) ;
08111 }
08112
08113 static int G__BesVisLib_rootcint_837_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08114 {
08115 ((Mdc2DWire*) G__getstructoffset())->SetColorfulWire((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
08116 G__setnull(result7);
08117 return(1 || funcname || hash || result7 || libp) ;
08118 }
08119
08120 static int G__BesVisLib_rootcint_837_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08121 {
08122 ((Mdc2DWire*) G__getstructoffset())->SetQOverflow((Bool_t) G__int(libp->para[0]));
08123 G__setnull(result7);
08124 return(1 || funcname || hash || result7 || libp) ;
08125 }
08126
08127 static int G__BesVisLib_rootcint_837_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08128 {
08129 ((Mdc2DWire*) G__getstructoffset())->SetEvTime((Double_t) G__double(libp->para[0]));
08130 G__setnull(result7);
08131 return(1 || funcname || hash || result7 || libp) ;
08132 }
08133
08134 static int G__BesVisLib_rootcint_837_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08135 {
08136 G__letint(result7, 85, (long) Mdc2DWire::Class());
08137 return(1 || funcname || hash || result7 || libp) ;
08138 }
08139
08140 static int G__BesVisLib_rootcint_837_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08141 {
08142 G__letint(result7, 67, (long) Mdc2DWire::Class_Name());
08143 return(1 || funcname || hash || result7 || libp) ;
08144 }
08145
08146 static int G__BesVisLib_rootcint_837_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08147 {
08148 G__letint(result7, 115, (long) Mdc2DWire::Class_Version());
08149 return(1 || funcname || hash || result7 || libp) ;
08150 }
08151
08152 static int G__BesVisLib_rootcint_837_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08153 {
08154 Mdc2DWire::Dictionary();
08155 G__setnull(result7);
08156 return(1 || funcname || hash || result7 || libp) ;
08157 }
08158
08159 static int G__BesVisLib_rootcint_837_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08160 {
08161 ((Mdc2DWire*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08162 G__setnull(result7);
08163 return(1 || funcname || hash || result7 || libp) ;
08164 }
08165
08166 static int G__BesVisLib_rootcint_837_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08167 {
08168 G__letint(result7, 67, (long) Mdc2DWire::DeclFileName());
08169 return(1 || funcname || hash || result7 || libp) ;
08170 }
08171
08172 static int G__BesVisLib_rootcint_837_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08173 {
08174 G__letint(result7, 105, (long) Mdc2DWire::ImplFileLine());
08175 return(1 || funcname || hash || result7 || libp) ;
08176 }
08177
08178 static int G__BesVisLib_rootcint_837_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08179 {
08180 G__letint(result7, 67, (long) Mdc2DWire::ImplFileName());
08181 return(1 || funcname || hash || result7 || libp) ;
08182 }
08183
08184 static int G__BesVisLib_rootcint_837_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08185 {
08186 G__letint(result7, 105, (long) Mdc2DWire::DeclFileLine());
08187 return(1 || funcname || hash || result7 || libp) ;
08188 }
08189
08190
08191 static int G__BesVisLib_rootcint_837_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08192
08193 {
08194 Mdc2DWire* p;
08195 void* tmp = (void*) G__int(libp->para[0]);
08196 p = new Mdc2DWire(*(Mdc2DWire*) tmp);
08197 result7->obj.i = (long) p;
08198 result7->ref = (long) p;
08199 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
08200 return(1 || funcname || hash || result7 || libp) ;
08201 }
08202
08203
08204 typedef Mdc2DWire G__TMdc2DWire;
08205 static int G__BesVisLib_rootcint_837_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08206 {
08207 char* gvp = (char*) G__getgvp();
08208 long soff = G__getstructoffset();
08209 int n = G__getaryconstruct();
08210
08211
08212
08213
08214
08215 if (!soff) {
08216 return(1);
08217 }
08218 if (n) {
08219 if (gvp == (char*)G__PVOID) {
08220 delete[] (Mdc2DWire*) soff;
08221 } else {
08222 G__setgvp((long) G__PVOID);
08223 for (int i = n - 1; i >= 0; --i) {
08224 ((Mdc2DWire*) (soff+(sizeof(Mdc2DWire)*i)))->~G__TMdc2DWire();
08225 }
08226 G__setgvp((long)gvp);
08227 }
08228 } else {
08229 if (gvp == (char*)G__PVOID) {
08230 delete (Mdc2DWire*) soff;
08231 } else {
08232 G__setgvp((long) G__PVOID);
08233 ((Mdc2DWire*) (soff))->~G__TMdc2DWire();
08234 G__setgvp((long)gvp);
08235 }
08236 }
08237 G__setnull(result7);
08238 return(1 || funcname || hash || result7 || libp) ;
08239 }
08240
08241
08242 static int G__BesVisLib_rootcint_837_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08243 {
08244 Mdc2DWire* dest = (Mdc2DWire*) G__getstructoffset();
08245 *dest = *(Mdc2DWire*) libp->para[0].ref;
08246 const Mdc2DWire& obj = *dest;
08247 result7->ref = (long) (&obj);
08248 result7->obj.i = (long) (&obj);
08249 return(1 || funcname || hash || result7 || libp) ;
08250 }
08251
08252
08253
08254 static int G__BesVisLib_rootcint_838_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08255 {
08256 MdcROOTGeo* p = NULL;
08257 char* gvp = (char*) G__getgvp();
08258 int n = G__getaryconstruct();
08259 if (n) {
08260 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08261 p = new MdcROOTGeo[n];
08262 } else {
08263 p = new((void*) gvp) MdcROOTGeo[n];
08264 }
08265 } else {
08266 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08267 p = new MdcROOTGeo;
08268 } else {
08269 p = new((void*) gvp) MdcROOTGeo;
08270 }
08271 }
08272 result7->obj.i = (long) p;
08273 result7->ref = (long) p;
08274 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
08275 return(1 || funcname || hash || result7 || libp) ;
08276 }
08277
08278 static int G__BesVisLib_rootcint_838_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08279 {
08280 ((MdcROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
08281 G__setnull(result7);
08282 return(1 || funcname || hash || result7 || libp) ;
08283 }
08284
08285 static int G__BesVisLib_rootcint_838_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08286 {
08287 ((MdcROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
08288 G__setnull(result7);
08289 return(1 || funcname || hash || result7 || libp) ;
08290 }
08291
08292 static int G__BesVisLib_rootcint_838_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08293 {
08294 ((MdcROOTGeo*) G__getstructoffset())->Init2DGeometry();
08295 G__setnull(result7);
08296 return(1 || funcname || hash || result7 || libp) ;
08297 }
08298
08299 static int G__BesVisLib_rootcint_838_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08300 {
08301 ((MdcROOTGeo*) G__getstructoffset())->SetNode();
08302 G__setnull(result7);
08303 return(1 || funcname || hash || result7 || libp) ;
08304 }
08305
08306 static int G__BesVisLib_rootcint_838_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08307 {
08308 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->CorrectReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
08309 return(1 || funcname || hash || result7 || libp) ;
08310 }
08311
08312 static int G__BesVisLib_rootcint_838_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08313 {
08314 ((MdcROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
08315 G__setnull(result7);
08316 return(1 || funcname || hash || result7 || libp) ;
08317 }
08318
08319 static int G__BesVisLib_rootcint_838_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08320 {
08321 ((MdcROOTGeo*) G__getstructoffset())->SetAllVisible();
08322 G__setnull(result7);
08323 return(1 || funcname || hash || result7 || libp) ;
08324 }
08325
08326 static int G__BesVisLib_rootcint_838_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08327 {
08328 ((MdcROOTGeo*) G__getstructoffset())->SetQuarterVisible();
08329 G__setnull(result7);
08330 return(1 || funcname || hash || result7 || libp) ;
08331 }
08332
08333 static int G__BesVisLib_rootcint_838_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08334 {
08335 ((MdcROOTGeo*) G__getstructoffset())->SetHalfVisible();
08336 G__setnull(result7);
08337 return(1 || funcname || hash || result7 || libp) ;
08338 }
08339
08340 static int G__BesVisLib_rootcint_838_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08341 {
08342 ((MdcROOTGeo*) G__getstructoffset())->SetPhysicalNode();
08343 G__setnull(result7);
08344 return(1 || funcname || hash || result7 || libp) ;
08345 }
08346
08347 static int G__BesVisLib_rootcint_838_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08348 {
08349 ((MdcROOTGeo*) G__getstructoffset())->SetDetector();
08350 G__setnull(result7);
08351 return(1 || funcname || hash || result7 || libp) ;
08352 }
08353
08354 static int G__BesVisLib_rootcint_838_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08355 {
08356 ((MdcROOTGeo*) G__getstructoffset())->SetHits();
08357 G__setnull(result7);
08358 return(1 || funcname || hash || result7 || libp) ;
08359 }
08360
08361 static int G__BesVisLib_rootcint_838_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08362 {
08363 ((MdcROOTGeo*) G__getstructoffset())->SetTFire((Bool_t) G__int(libp->para[0]));
08364 G__setnull(result7);
08365 return(1 || funcname || hash || result7 || libp) ;
08366 }
08367
08368 static int G__BesVisLib_rootcint_838_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08369 {
08370 ((MdcROOTGeo*) G__getstructoffset())->SetQFire((Bool_t) G__int(libp->para[0]));
08371 G__setnull(result7);
08372 return(1 || funcname || hash || result7 || libp) ;
08373 }
08374
08375 static int G__BesVisLib_rootcint_838_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08376 {
08377 ((MdcROOTGeo*) G__getstructoffset())->SetQNotOverflow((Bool_t) G__int(libp->para[0]));
08378 G__setnull(result7);
08379 return(1 || funcname || hash || result7 || libp) ;
08380 }
08381
08382 static int G__BesVisLib_rootcint_838_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08383 {
08384 ((MdcROOTGeo*) G__getstructoffset())->SetColorfulWire((Bool_t) G__int(libp->para[0]));
08385 G__setnull(result7);
08386 return(1 || funcname || hash || result7 || libp) ;
08387 }
08388
08389 static int G__BesVisLib_rootcint_838_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08390 {
08391 ((MdcROOTGeo*) G__getstructoffset())->SetMdcTimeSubEvTime((Bool_t) G__int(libp->para[0]));
08392 G__setnull(result7);
08393 return(1 || funcname || hash || result7 || libp) ;
08394 }
08395
08396 static int G__BesVisLib_rootcint_838_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08397 {
08398 ((MdcROOTGeo*) G__getstructoffset())->SetVisMdcDetector();
08399 G__setnull(result7);
08400 return(1 || funcname || hash || result7 || libp) ;
08401 }
08402
08403 static int G__BesVisLib_rootcint_838_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08404 {
08405 ((MdcROOTGeo*) G__getstructoffset())->SetVisMdcHits();
08406 G__setnull(result7);
08407 return(1 || funcname || hash || result7 || libp) ;
08408 }
08409
08410 static int G__BesVisLib_rootcint_838_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08411 {
08412 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetSegmentNb());
08413 return(1 || funcname || hash || result7 || libp) ;
08414 }
08415
08416 static int G__BesVisLib_rootcint_838_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08417 {
08418 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetLayerNb());
08419 return(1 || funcname || hash || result7 || libp) ;
08420 }
08421
08422 static int G__BesVisLib_rootcint_838_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08423 {
08424 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetReplicaNb((int) G__int(libp->para[0])));
08425 return(1 || funcname || hash || result7 || libp) ;
08426 }
08427
08428 static int G__BesVisLib_rootcint_838_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08429 {
08430 ((MdcROOTGeo*) G__getstructoffset())->SetVolumeMdc((TGeoVolume*) G__int(libp->para[0]));
08431 G__setnull(result7);
08432 return(1 || funcname || hash || result7 || libp) ;
08433 }
08434
08435 static int G__BesVisLib_rootcint_838_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08436 {
08437 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeMdc());
08438 return(1 || funcname || hash || result7 || libp) ;
08439 }
08440
08441 static int G__BesVisLib_rootcint_838_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08442 {
08443 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeSegment((int) G__int(libp->para[0])));
08444 return(1 || funcname || hash || result7 || libp) ;
08445 }
08446
08447 static int G__BesVisLib_rootcint_838_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08448 {
08449 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeLayer((int) G__int(libp->para[0])));
08450 return(1 || funcname || hash || result7 || libp) ;
08451 }
08452
08453 static int G__BesVisLib_rootcint_838_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08454 {
08455 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetVolumeReplica((int) G__int(libp->para[0])));
08456 return(1 || funcname || hash || result7 || libp) ;
08457 }
08458
08459 static int G__BesVisLib_rootcint_838_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08460 {
08461 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetSegment((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
08462 return(1 || funcname || hash || result7 || libp) ;
08463 }
08464
08465 static int G__BesVisLib_rootcint_838_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08466 {
08467 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetLayer((int) G__int(libp->para[0])));
08468 return(1 || funcname || hash || result7 || libp) ;
08469 }
08470
08471 static int G__BesVisLib_rootcint_838_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08472 {
08473 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
08474 return(1 || funcname || hash || result7 || libp) ;
08475 }
08476
08477 static int G__BesVisLib_rootcint_838_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08478 {
08479 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetPhysicalSegment((int) G__int(libp->para[0])));
08480 return(1 || funcname || hash || result7 || libp) ;
08481 }
08482
08483 static int G__BesVisLib_rootcint_838_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08484 {
08485 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->GetPhysicalReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
08486 return(1 || funcname || hash || result7 || libp) ;
08487 }
08488
08489 static int G__BesVisLib_rootcint_838_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08490 {
08491 G__letint(result7, 85, (long) ((MdcROOTGeo*) G__getstructoffset())->Get2DWire((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
08492 return(1 || funcname || hash || result7 || libp) ;
08493 }
08494
08495 static int G__BesVisLib_rootcint_838_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08496 {
08497 G__letint(result7, 105, (long) ((MdcROOTGeo*) G__getstructoffset())->GetSimuLayer((Int_t) G__int(libp->para[0])));
08498 return(1 || funcname || hash || result7 || libp) ;
08499 }
08500
08501 static int G__BesVisLib_rootcint_838_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08502 {
08503 G__letint(result7, 103, (long) ((MdcROOTGeo*) G__getstructoffset())->IsHit((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
08504 return(1 || funcname || hash || result7 || libp) ;
08505 }
08506
08507 static int G__BesVisLib_rootcint_838_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08508 {
08509 ((MdcROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
08510 G__setnull(result7);
08511 return(1 || funcname || hash || result7 || libp) ;
08512 }
08513
08514 static int G__BesVisLib_rootcint_838_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08515 {
08516 ((MdcROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
08517 G__setnull(result7);
08518 return(1 || funcname || hash || result7 || libp) ;
08519 }
08520
08521
08522 static int G__BesVisLib_rootcint_838_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08523
08524 {
08525 MdcROOTGeo* p;
08526 void* tmp = (void*) G__int(libp->para[0]);
08527 p = new MdcROOTGeo(*(MdcROOTGeo*) tmp);
08528 result7->obj.i = (long) p;
08529 result7->ref = (long) p;
08530 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
08531 return(1 || funcname || hash || result7 || libp) ;
08532 }
08533
08534
08535 typedef MdcROOTGeo G__TMdcROOTGeo;
08536 static int G__BesVisLib_rootcint_838_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08537 {
08538 char* gvp = (char*) G__getgvp();
08539 long soff = G__getstructoffset();
08540 int n = G__getaryconstruct();
08541
08542
08543
08544
08545
08546 if (!soff) {
08547 return(1);
08548 }
08549 if (n) {
08550 if (gvp == (char*)G__PVOID) {
08551 delete[] (MdcROOTGeo*) soff;
08552 } else {
08553 G__setgvp((long) G__PVOID);
08554 for (int i = n - 1; i >= 0; --i) {
08555 ((MdcROOTGeo*) (soff+(sizeof(MdcROOTGeo)*i)))->~G__TMdcROOTGeo();
08556 }
08557 G__setgvp((long)gvp);
08558 }
08559 } else {
08560 if (gvp == (char*)G__PVOID) {
08561 delete (MdcROOTGeo*) soff;
08562 } else {
08563 G__setgvp((long) G__PVOID);
08564 ((MdcROOTGeo*) (soff))->~G__TMdcROOTGeo();
08565 G__setgvp((long)gvp);
08566 }
08567 }
08568 G__setnull(result7);
08569 return(1 || funcname || hash || result7 || libp) ;
08570 }
08571
08572
08573
08574 static int G__BesVisLib_rootcint_839_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08575 {
08576 Tof2DScin* p = NULL;
08577 char* gvp = (char*) G__getgvp();
08578 int n = G__getaryconstruct();
08579 if (n) {
08580 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08581 p = new Tof2DScin[n];
08582 } else {
08583 p = new((void*) gvp) Tof2DScin[n];
08584 }
08585 } else {
08586 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08587 p = new Tof2DScin;
08588 } else {
08589 p = new((void*) gvp) Tof2DScin;
08590 }
08591 }
08592 result7->obj.i = (long) p;
08593 result7->ref = (long) p;
08594 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
08595 return(1 || funcname || hash || result7 || libp) ;
08596 }
08597
08598 static int G__BesVisLib_rootcint_839_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08599 {
08600 Tof2DScin* p = NULL;
08601 char* gvp = (char*) G__getgvp();
08602
08603 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08604 p = new Tof2DScin(
08605 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08606 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
08607 , (Int_t) G__int(libp->para[4]));
08608 } else {
08609 p = new((void*) gvp) Tof2DScin(
08610 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08611 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
08612 , (Int_t) G__int(libp->para[4]));
08613 }
08614 result7->obj.i = (long) p;
08615 result7->ref = (long) p;
08616 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
08617 return(1 || funcname || hash || result7 || libp) ;
08618 }
08619
08620 static int G__BesVisLib_rootcint_839_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08621 {
08622 ((Tof2DScin*) G__getstructoffset())->SetStyle();
08623 G__setnull(result7);
08624 return(1 || funcname || hash || result7 || libp) ;
08625 }
08626
08627 static int G__BesVisLib_rootcint_839_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08628 {
08629 switch (libp->paran) {
08630 case 1:
08631 ((Tof2DScin*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
08632 G__setnull(result7);
08633 break;
08634 case 0:
08635 ((Tof2DScin*) G__getstructoffset())->SetHighlighted();
08636 G__setnull(result7);
08637 break;
08638 }
08639 return(1 || funcname || hash || result7 || libp) ;
08640 }
08641
08642 static int G__BesVisLib_rootcint_839_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08643 {
08644 switch (libp->paran) {
08645 case 1:
08646 ((Tof2DScin*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
08647 G__setnull(result7);
08648 break;
08649 case 0:
08650 ((Tof2DScin*) G__getstructoffset())->SetFired();
08651 G__setnull(result7);
08652 break;
08653 }
08654 return(1 || funcname || hash || result7 || libp) ;
08655 }
08656
08657 static int G__BesVisLib_rootcint_839_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08658 {
08659 G__letint(result7, 103, (long) ((Tof2DScin*) G__getstructoffset())->IsHighlighted());
08660 return(1 || funcname || hash || result7 || libp) ;
08661 }
08662
08663 static int G__BesVisLib_rootcint_839_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08664 {
08665 G__letint(result7, 103, (long) ((Tof2DScin*) G__getstructoffset())->IsFired());
08666 return(1 || funcname || hash || result7 || libp) ;
08667 }
08668
08669 static int G__BesVisLib_rootcint_839_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08670 {
08671 ((Tof2DScin*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
08672 G__setnull(result7);
08673 return(1 || funcname || hash || result7 || libp) ;
08674 }
08675
08676 static int G__BesVisLib_rootcint_839_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08677 {
08678 ((Tof2DScin*) G__getstructoffset())->CloseInfo();
08679 G__setnull(result7);
08680 return(1 || funcname || hash || result7 || libp) ;
08681 }
08682
08683 static int G__BesVisLib_rootcint_839_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08684 {
08685 ((Tof2DScin*) G__getstructoffset())->ClearInfo();
08686 G__setnull(result7);
08687 return(1 || funcname || hash || result7 || libp) ;
08688 }
08689
08690 static int G__BesVisLib_rootcint_839_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08691 {
08692 ((Tof2DScin*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
08693 G__setnull(result7);
08694 return(1 || funcname || hash || result7 || libp) ;
08695 }
08696
08697 static int G__BesVisLib_rootcint_839_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08698 {
08699 ((Tof2DScin*) G__getstructoffset())->SetCharge((Double_t) G__double(libp->para[0]));
08700 G__setnull(result7);
08701 return(1 || funcname || hash || result7 || libp) ;
08702 }
08703
08704 static int G__BesVisLib_rootcint_839_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08705 {
08706 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->GetTime());
08707 return(1 || funcname || hash || result7 || libp) ;
08708 }
08709
08710 static int G__BesVisLib_rootcint_839_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08711 {
08712 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->GetCharge());
08713 return(1 || funcname || hash || result7 || libp) ;
08714 }
08715
08716 static int G__BesVisLib_rootcint_839_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08717 {
08718 ((Tof2DScin*) G__getstructoffset())->ResetTimeCharge();
08719 G__setnull(result7);
08720 return(1 || funcname || hash || result7 || libp) ;
08721 }
08722
08723 static int G__BesVisLib_rootcint_839_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08724 {
08725 G__letint(result7, 105, (long) ((Tof2DScin*) G__getstructoffset())->GetPart());
08726 return(1 || funcname || hash || result7 || libp) ;
08727 }
08728
08729 static int G__BesVisLib_rootcint_839_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08730 {
08731 G__letint(result7, 103, (long) ((Tof2DScin*) G__getstructoffset())->HasZRSection());
08732 return(1 || funcname || hash || result7 || libp) ;
08733 }
08734
08735 static int G__BesVisLib_rootcint_839_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08736 {
08737 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->GetAngle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
08738 return(1 || funcname || hash || result7 || libp) ;
08739 }
08740
08741 static int G__BesVisLib_rootcint_839_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08742 {
08743 G__letdouble(result7, 100, (double) ((Tof2DScin*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
08744 return(1 || funcname || hash || result7 || libp) ;
08745 }
08746
08747 static int G__BesVisLib_rootcint_839_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08748 {
08749 G__letint(result7, 85, (long) Tof2DScin::Class());
08750 return(1 || funcname || hash || result7 || libp) ;
08751 }
08752
08753 static int G__BesVisLib_rootcint_839_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08754 {
08755 G__letint(result7, 67, (long) Tof2DScin::Class_Name());
08756 return(1 || funcname || hash || result7 || libp) ;
08757 }
08758
08759 static int G__BesVisLib_rootcint_839_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08760 {
08761 G__letint(result7, 115, (long) Tof2DScin::Class_Version());
08762 return(1 || funcname || hash || result7 || libp) ;
08763 }
08764
08765 static int G__BesVisLib_rootcint_839_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08766 {
08767 Tof2DScin::Dictionary();
08768 G__setnull(result7);
08769 return(1 || funcname || hash || result7 || libp) ;
08770 }
08771
08772 static int G__BesVisLib_rootcint_839_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08773 {
08774 ((Tof2DScin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08775 G__setnull(result7);
08776 return(1 || funcname || hash || result7 || libp) ;
08777 }
08778
08779 static int G__BesVisLib_rootcint_839_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08780 {
08781 G__letint(result7, 67, (long) Tof2DScin::DeclFileName());
08782 return(1 || funcname || hash || result7 || libp) ;
08783 }
08784
08785 static int G__BesVisLib_rootcint_839_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08786 {
08787 G__letint(result7, 105, (long) Tof2DScin::ImplFileLine());
08788 return(1 || funcname || hash || result7 || libp) ;
08789 }
08790
08791 static int G__BesVisLib_rootcint_839_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08792 {
08793 G__letint(result7, 67, (long) Tof2DScin::ImplFileName());
08794 return(1 || funcname || hash || result7 || libp) ;
08795 }
08796
08797 static int G__BesVisLib_rootcint_839_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08798 {
08799 G__letint(result7, 105, (long) Tof2DScin::DeclFileLine());
08800 return(1 || funcname || hash || result7 || libp) ;
08801 }
08802
08803
08804 static int G__BesVisLib_rootcint_839_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08805
08806 {
08807 Tof2DScin* p;
08808 void* tmp = (void*) G__int(libp->para[0]);
08809 p = new Tof2DScin(*(Tof2DScin*) tmp);
08810 result7->obj.i = (long) p;
08811 result7->ref = (long) p;
08812 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
08813 return(1 || funcname || hash || result7 || libp) ;
08814 }
08815
08816
08817 typedef Tof2DScin G__TTof2DScin;
08818 static int G__BesVisLib_rootcint_839_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08819 {
08820 char* gvp = (char*) G__getgvp();
08821 long soff = G__getstructoffset();
08822 int n = G__getaryconstruct();
08823
08824
08825
08826
08827
08828 if (!soff) {
08829 return(1);
08830 }
08831 if (n) {
08832 if (gvp == (char*)G__PVOID) {
08833 delete[] (Tof2DScin*) soff;
08834 } else {
08835 G__setgvp((long) G__PVOID);
08836 for (int i = n - 1; i >= 0; --i) {
08837 ((Tof2DScin*) (soff+(sizeof(Tof2DScin)*i)))->~G__TTof2DScin();
08838 }
08839 G__setgvp((long)gvp);
08840 }
08841 } else {
08842 if (gvp == (char*)G__PVOID) {
08843 delete (Tof2DScin*) soff;
08844 } else {
08845 G__setgvp((long) G__PVOID);
08846 ((Tof2DScin*) (soff))->~G__TTof2DScin();
08847 G__setgvp((long)gvp);
08848 }
08849 }
08850 G__setnull(result7);
08851 return(1 || funcname || hash || result7 || libp) ;
08852 }
08853
08854
08855 static int G__BesVisLib_rootcint_839_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08856 {
08857 Tof2DScin* dest = (Tof2DScin*) G__getstructoffset();
08858 *dest = *(Tof2DScin*) libp->para[0].ref;
08859 const Tof2DScin& obj = *dest;
08860 result7->ref = (long) (&obj);
08861 result7->obj.i = (long) (&obj);
08862 return(1 || funcname || hash || result7 || libp) ;
08863 }
08864
08865
08866
08867 static int G__BesVisLib_rootcint_840_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08868 {
08869 TofROOTGeo* p = NULL;
08870 char* gvp = (char*) G__getgvp();
08871 int n = G__getaryconstruct();
08872 if (n) {
08873 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08874 p = new TofROOTGeo[n];
08875 } else {
08876 p = new((void*) gvp) TofROOTGeo[n];
08877 }
08878 } else {
08879 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08880 p = new TofROOTGeo;
08881 } else {
08882 p = new((void*) gvp) TofROOTGeo;
08883 }
08884 }
08885 result7->obj.i = (long) p;
08886 result7->ref = (long) p;
08887 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
08888 return(1 || funcname || hash || result7 || libp) ;
08889 }
08890
08891 static int G__BesVisLib_rootcint_840_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08892 {
08893 ((TofROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
08894 G__setnull(result7);
08895 return(1 || funcname || hash || result7 || libp) ;
08896 }
08897
08898 static int G__BesVisLib_rootcint_840_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08899 {
08900 ((TofROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
08901 G__setnull(result7);
08902 return(1 || funcname || hash || result7 || libp) ;
08903 }
08904
08905 static int G__BesVisLib_rootcint_840_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08906 {
08907 ((TofROOTGeo*) G__getstructoffset())->Init2DGeometry();
08908 G__setnull(result7);
08909 return(1 || funcname || hash || result7 || libp) ;
08910 }
08911
08912 static int G__BesVisLib_rootcint_840_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08913 {
08914 ((TofROOTGeo*) G__getstructoffset())->SetNode();
08915 G__setnull(result7);
08916 return(1 || funcname || hash || result7 || libp) ;
08917 }
08918
08919 static int G__BesVisLib_rootcint_840_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08920 {
08921 ((TofROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
08922 G__setnull(result7);
08923 return(1 || funcname || hash || result7 || libp) ;
08924 }
08925
08926 static int G__BesVisLib_rootcint_840_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08927 {
08928 ((TofROOTGeo*) G__getstructoffset())->SetAllVisible();
08929 G__setnull(result7);
08930 return(1 || funcname || hash || result7 || libp) ;
08931 }
08932
08933 static int G__BesVisLib_rootcint_840_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08934 {
08935 ((TofROOTGeo*) G__getstructoffset())->SetTMatch((Bool_t) G__int(libp->para[0]));
08936 G__setnull(result7);
08937 return(1 || funcname || hash || result7 || libp) ;
08938 }
08939
08940 static int G__BesVisLib_rootcint_840_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08941 {
08942 ((TofROOTGeo*) G__getstructoffset())->SetQMatch((Bool_t) G__int(libp->para[0]));
08943 G__setnull(result7);
08944 return(1 || funcname || hash || result7 || libp) ;
08945 }
08946
08947 static int G__BesVisLib_rootcint_840_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08948 {
08949 ((TofROOTGeo*) G__getstructoffset())->SetQuarterVisible();
08950 G__setnull(result7);
08951 return(1 || funcname || hash || result7 || libp) ;
08952 }
08953
08954 static int G__BesVisLib_rootcint_840_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08955 {
08956 ((TofROOTGeo*) G__getstructoffset())->SetHalfVisible();
08957 G__setnull(result7);
08958 return(1 || funcname || hash || result7 || libp) ;
08959 }
08960
08961 static int G__BesVisLib_rootcint_840_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08962 {
08963 ((TofROOTGeo*) G__getstructoffset())->SetNoEndVisible();
08964 G__setnull(result7);
08965 return(1 || funcname || hash || result7 || libp) ;
08966 }
08967
08968 static int G__BesVisLib_rootcint_840_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08969 {
08970 ((TofROOTGeo*) G__getstructoffset())->SetPhysicalNode();
08971 G__setnull(result7);
08972 return(1 || funcname || hash || result7 || libp) ;
08973 }
08974
08975 static int G__BesVisLib_rootcint_840_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08976 {
08977 ((TofROOTGeo*) G__getstructoffset())->SetDetector();
08978 G__setnull(result7);
08979 return(1 || funcname || hash || result7 || libp) ;
08980 }
08981
08982 static int G__BesVisLib_rootcint_840_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08983 {
08984 ((TofROOTGeo*) G__getstructoffset())->SetHits();
08985 G__setnull(result7);
08986 return(1 || funcname || hash || result7 || libp) ;
08987 }
08988
08989 static int G__BesVisLib_rootcint_840_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08990 {
08991 ((TofROOTGeo*) G__getstructoffset())->SetVisTofDetector();
08992 G__setnull(result7);
08993 return(1 || funcname || hash || result7 || libp) ;
08994 }
08995
08996 static int G__BesVisLib_rootcint_840_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08997 {
08998 ((TofROOTGeo*) G__getstructoffset())->SetVisTofHits();
08999 G__setnull(result7);
09000 return(1 || funcname || hash || result7 || libp) ;
09001 }
09002
09003 static int G__BesVisLib_rootcint_840_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09004 {
09005 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetPartNb());
09006 return(1 || funcname || hash || result7 || libp) ;
09007 }
09008
09009 static int G__BesVisLib_rootcint_840_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09010 {
09011 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetScinNb((int) G__int(libp->para[0])));
09012 return(1 || funcname || hash || result7 || libp) ;
09013 }
09014
09015 static int G__BesVisLib_rootcint_840_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09016 {
09017 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetLayerNb((int) G__int(libp->para[0])));
09018 return(1 || funcname || hash || result7 || libp) ;
09019 }
09020
09021 static int G__BesVisLib_rootcint_840_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09022 {
09023 ((TofROOTGeo*) G__getstructoffset())->SetVolumeTof((TGeoVolume*) G__int(libp->para[0]));
09024 G__setnull(result7);
09025 return(1 || funcname || hash || result7 || libp) ;
09026 }
09027
09028 static int G__BesVisLib_rootcint_840_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09029 {
09030 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeTof());
09031 return(1 || funcname || hash || result7 || libp) ;
09032 }
09033
09034 static int G__BesVisLib_rootcint_840_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09035 {
09036 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumePart((int) G__int(libp->para[0])));
09037 return(1 || funcname || hash || result7 || libp) ;
09038 }
09039
09040 static int G__BesVisLib_rootcint_840_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09041 {
09042 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumePVF((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09043 return(1 || funcname || hash || result7 || libp) ;
09044 }
09045
09046 static int G__BesVisLib_rootcint_840_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09047 {
09048 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeAl((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09049 return(1 || funcname || hash || result7 || libp) ;
09050 }
09051
09052 static int G__BesVisLib_rootcint_840_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09053 {
09054 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09055 return(1 || funcname || hash || result7 || libp) ;
09056 }
09057
09058 static int G__BesVisLib_rootcint_840_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09059 {
09060 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetVolumeBucket((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09061 return(1 || funcname || hash || result7 || libp) ;
09062 }
09063
09064 static int G__BesVisLib_rootcint_840_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09065 {
09066 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetPVF((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09067 , (int) G__int(libp->para[2])));
09068 return(1 || funcname || hash || result7 || libp) ;
09069 }
09070
09071 static int G__BesVisLib_rootcint_840_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09072 {
09073 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetAl((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09074 return(1 || funcname || hash || result7 || libp) ;
09075 }
09076
09077 static int G__BesVisLib_rootcint_840_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09078 {
09079 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09080 return(1 || funcname || hash || result7 || libp) ;
09081 }
09082
09083 static int G__BesVisLib_rootcint_840_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09084 {
09085 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->GetPhysicalScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09086 , (int) G__int(libp->para[2])));
09087 return(1 || funcname || hash || result7 || libp) ;
09088 }
09089
09090 static int G__BesVisLib_rootcint_840_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09091 {
09092 G__letint(result7, 85, (long) ((TofROOTGeo*) G__getstructoffset())->Get2DScin((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09093 , (Int_t) G__int(libp->para[2])));
09094 return(1 || funcname || hash || result7 || libp) ;
09095 }
09096
09097 static int G__BesVisLib_rootcint_840_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09098 {
09099 G__letint(result7, 105, (long) ((TofROOTGeo*) G__getstructoffset())->GetPart((TGeoPhysicalNode*) G__int(libp->para[0])));
09100 return(1 || funcname || hash || result7 || libp) ;
09101 }
09102
09103 static int G__BesVisLib_rootcint_840_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09104 {
09105 ((TofROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
09106 G__setnull(result7);
09107 return(1 || funcname || hash || result7 || libp) ;
09108 }
09109
09110 static int G__BesVisLib_rootcint_840_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09111 {
09112 ((TofROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
09113 G__setnull(result7);
09114 return(1 || funcname || hash || result7 || libp) ;
09115 }
09116
09117
09118 static int G__BesVisLib_rootcint_840_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09119
09120 {
09121 TofROOTGeo* p;
09122 void* tmp = (void*) G__int(libp->para[0]);
09123 p = new TofROOTGeo(*(TofROOTGeo*) tmp);
09124 result7->obj.i = (long) p;
09125 result7->ref = (long) p;
09126 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
09127 return(1 || funcname || hash || result7 || libp) ;
09128 }
09129
09130
09131 typedef TofROOTGeo G__TTofROOTGeo;
09132 static int G__BesVisLib_rootcint_840_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09133 {
09134 char* gvp = (char*) G__getgvp();
09135 long soff = G__getstructoffset();
09136 int n = G__getaryconstruct();
09137
09138
09139
09140
09141
09142 if (!soff) {
09143 return(1);
09144 }
09145 if (n) {
09146 if (gvp == (char*)G__PVOID) {
09147 delete[] (TofROOTGeo*) soff;
09148 } else {
09149 G__setgvp((long) G__PVOID);
09150 for (int i = n - 1; i >= 0; --i) {
09151 ((TofROOTGeo*) (soff+(sizeof(TofROOTGeo)*i)))->~G__TTofROOTGeo();
09152 }
09153 G__setgvp((long)gvp);
09154 }
09155 } else {
09156 if (gvp == (char*)G__PVOID) {
09157 delete (TofROOTGeo*) soff;
09158 } else {
09159 G__setgvp((long) G__PVOID);
09160 ((TofROOTGeo*) (soff))->~G__TTofROOTGeo();
09161 G__setgvp((long)gvp);
09162 }
09163 }
09164 G__setnull(result7);
09165 return(1 || funcname || hash || result7 || libp) ;
09166 }
09167
09168
09169
09170 static int G__BesVisLib_rootcint_841_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09171 {
09172 Emc2DCrystal* p = NULL;
09173 char* gvp = (char*) G__getgvp();
09174 int n = G__getaryconstruct();
09175 if (n) {
09176 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09177 p = new Emc2DCrystal[n];
09178 } else {
09179 p = new((void*) gvp) Emc2DCrystal[n];
09180 }
09181 } else {
09182 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09183 p = new Emc2DCrystal;
09184 } else {
09185 p = new((void*) gvp) Emc2DCrystal;
09186 }
09187 }
09188 result7->obj.i = (long) p;
09189 result7->ref = (long) p;
09190 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
09191 return(1 || funcname || hash || result7 || libp) ;
09192 }
09193
09194 static int G__BesVisLib_rootcint_841_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09195 {
09196 Emc2DCrystal* p = NULL;
09197 char* gvp = (char*) G__getgvp();
09198
09199 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09200 p = new Emc2DCrystal(
09201 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09202 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
09203 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
09204 } else {
09205 p = new((void*) gvp) Emc2DCrystal(
09206 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09207 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
09208 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
09209 }
09210 result7->obj.i = (long) p;
09211 result7->ref = (long) p;
09212 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
09213 return(1 || funcname || hash || result7 || libp) ;
09214 }
09215
09216 static int G__BesVisLib_rootcint_841_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09217 {
09218 ((Emc2DCrystal*) G__getstructoffset())->SetStyle();
09219 G__setnull(result7);
09220 return(1 || funcname || hash || result7 || libp) ;
09221 }
09222
09223 static int G__BesVisLib_rootcint_841_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09224 {
09225 switch (libp->paran) {
09226 case 1:
09227 ((Emc2DCrystal*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
09228 G__setnull(result7);
09229 break;
09230 case 0:
09231 ((Emc2DCrystal*) G__getstructoffset())->SetHighlighted();
09232 G__setnull(result7);
09233 break;
09234 }
09235 return(1 || funcname || hash || result7 || libp) ;
09236 }
09237
09238 static int G__BesVisLib_rootcint_841_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09239 {
09240 switch (libp->paran) {
09241 case 1:
09242 ((Emc2DCrystal*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
09243 G__setnull(result7);
09244 break;
09245 case 0:
09246 ((Emc2DCrystal*) G__getstructoffset())->SetFired();
09247 G__setnull(result7);
09248 break;
09249 }
09250 return(1 || funcname || hash || result7 || libp) ;
09251 }
09252
09253 static int G__BesVisLib_rootcint_841_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09254 {
09255 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsHighlighted());
09256 return(1 || funcname || hash || result7 || libp) ;
09257 }
09258
09259 static int G__BesVisLib_rootcint_841_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09260 {
09261 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsFired());
09262 return(1 || funcname || hash || result7 || libp) ;
09263 }
09264
09265 static int G__BesVisLib_rootcint_841_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09266 {
09267 ((Emc2DCrystal*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
09268 G__setnull(result7);
09269 return(1 || funcname || hash || result7 || libp) ;
09270 }
09271
09272 static int G__BesVisLib_rootcint_841_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09273 {
09274 ((Emc2DCrystal*) G__getstructoffset())->CloseInfo();
09275 G__setnull(result7);
09276 return(1 || funcname || hash || result7 || libp) ;
09277 }
09278
09279 static int G__BesVisLib_rootcint_841_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09280 {
09281 ((Emc2DCrystal*) G__getstructoffset())->ClearInfo();
09282 G__setnull(result7);
09283 return(1 || funcname || hash || result7 || libp) ;
09284 }
09285
09286 static int G__BesVisLib_rootcint_841_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09287 {
09288 ((Emc2DCrystal*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
09289 G__setnull(result7);
09290 return(1 || funcname || hash || result7 || libp) ;
09291 }
09292
09293 static int G__BesVisLib_rootcint_841_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09294 {
09295 ((Emc2DCrystal*) G__getstructoffset())->SetCharge((Double_t) G__double(libp->para[0]));
09296 G__setnull(result7);
09297 return(1 || funcname || hash || result7 || libp) ;
09298 }
09299
09300 static int G__BesVisLib_rootcint_841_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09301 {
09302 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->GetTime());
09303 return(1 || funcname || hash || result7 || libp) ;
09304 }
09305
09306 static int G__BesVisLib_rootcint_841_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09307 {
09308 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->GetCharge());
09309 return(1 || funcname || hash || result7 || libp) ;
09310 }
09311
09312 static int G__BesVisLib_rootcint_841_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09313 {
09314 ((Emc2DCrystal*) G__getstructoffset())->ResetTimeCharge();
09315 G__setnull(result7);
09316 return(1 || funcname || hash || result7 || libp) ;
09317 }
09318
09319 static int G__BesVisLib_rootcint_841_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09320 {
09321 G__letint(result7, 105, (long) ((Emc2DCrystal*) G__getstructoffset())->GetPart());
09322 return(1 || funcname || hash || result7 || libp) ;
09323 }
09324
09325 static int G__BesVisLib_rootcint_841_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09326 {
09327 G__letint(result7, 105, (long) ((Emc2DCrystal*) G__getstructoffset())->GetTheta());
09328 return(1 || funcname || hash || result7 || libp) ;
09329 }
09330
09331 static int G__BesVisLib_rootcint_841_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09332 {
09333 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->HasZRSection());
09334 return(1 || funcname || hash || result7 || libp) ;
09335 }
09336
09337 static int G__BesVisLib_rootcint_841_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09338 {
09339 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->GetAngle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
09340 return(1 || funcname || hash || result7 || libp) ;
09341 }
09342
09343 static int G__BesVisLib_rootcint_841_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09344 {
09345 G__letdouble(result7, 100, (double) ((Emc2DCrystal*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
09346 return(1 || funcname || hash || result7 || libp) ;
09347 }
09348
09349 static int G__BesVisLib_rootcint_841_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09350 {
09351 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsXYVisible());
09352 return(1 || funcname || hash || result7 || libp) ;
09353 }
09354
09355 static int G__BesVisLib_rootcint_841_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09356 {
09357 G__letint(result7, 103, (long) ((Emc2DCrystal*) G__getstructoffset())->IsSideVisible());
09358 return(1 || funcname || hash || result7 || libp) ;
09359 }
09360
09361 static int G__BesVisLib_rootcint_841_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09362 {
09363 ((Emc2DCrystal*) G__getstructoffset())->SetXYPoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
09364 , (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
09365 G__setnull(result7);
09366 return(1 || funcname || hash || result7 || libp) ;
09367 }
09368
09369 static int G__BesVisLib_rootcint_841_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09370 {
09371 ((Emc2DCrystal*) G__getstructoffset())->SetZRPoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
09372 , (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
09373 G__setnull(result7);
09374 return(1 || funcname || hash || result7 || libp) ;
09375 }
09376
09377 static int G__BesVisLib_rootcint_841_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09378 {
09379 ((Emc2DCrystal*) G__getstructoffset())->ProjectECToSide((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
09380 G__setnull(result7);
09381 return(1 || funcname || hash || result7 || libp) ;
09382 }
09383
09384 static int G__BesVisLib_rootcint_841_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09385 {
09386 G__letint(result7, 85, (long) Emc2DCrystal::Class());
09387 return(1 || funcname || hash || result7 || libp) ;
09388 }
09389
09390 static int G__BesVisLib_rootcint_841_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09391 {
09392 G__letint(result7, 67, (long) Emc2DCrystal::Class_Name());
09393 return(1 || funcname || hash || result7 || libp) ;
09394 }
09395
09396 static int G__BesVisLib_rootcint_841_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09397 {
09398 G__letint(result7, 115, (long) Emc2DCrystal::Class_Version());
09399 return(1 || funcname || hash || result7 || libp) ;
09400 }
09401
09402 static int G__BesVisLib_rootcint_841_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09403 {
09404 Emc2DCrystal::Dictionary();
09405 G__setnull(result7);
09406 return(1 || funcname || hash || result7 || libp) ;
09407 }
09408
09409 static int G__BesVisLib_rootcint_841_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09410 {
09411 ((Emc2DCrystal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09412 G__setnull(result7);
09413 return(1 || funcname || hash || result7 || libp) ;
09414 }
09415
09416 static int G__BesVisLib_rootcint_841_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09417 {
09418 G__letint(result7, 67, (long) Emc2DCrystal::DeclFileName());
09419 return(1 || funcname || hash || result7 || libp) ;
09420 }
09421
09422 static int G__BesVisLib_rootcint_841_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09423 {
09424 G__letint(result7, 105, (long) Emc2DCrystal::ImplFileLine());
09425 return(1 || funcname || hash || result7 || libp) ;
09426 }
09427
09428 static int G__BesVisLib_rootcint_841_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09429 {
09430 G__letint(result7, 67, (long) Emc2DCrystal::ImplFileName());
09431 return(1 || funcname || hash || result7 || libp) ;
09432 }
09433
09434 static int G__BesVisLib_rootcint_841_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09435 {
09436 G__letint(result7, 105, (long) Emc2DCrystal::DeclFileLine());
09437 return(1 || funcname || hash || result7 || libp) ;
09438 }
09439
09440
09441 static int G__BesVisLib_rootcint_841_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09442
09443 {
09444 Emc2DCrystal* p;
09445 void* tmp = (void*) G__int(libp->para[0]);
09446 p = new Emc2DCrystal(*(Emc2DCrystal*) tmp);
09447 result7->obj.i = (long) p;
09448 result7->ref = (long) p;
09449 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
09450 return(1 || funcname || hash || result7 || libp) ;
09451 }
09452
09453
09454 typedef Emc2DCrystal G__TEmc2DCrystal;
09455 static int G__BesVisLib_rootcint_841_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09456 {
09457 char* gvp = (char*) G__getgvp();
09458 long soff = G__getstructoffset();
09459 int n = G__getaryconstruct();
09460
09461
09462
09463
09464
09465 if (!soff) {
09466 return(1);
09467 }
09468 if (n) {
09469 if (gvp == (char*)G__PVOID) {
09470 delete[] (Emc2DCrystal*) soff;
09471 } else {
09472 G__setgvp((long) G__PVOID);
09473 for (int i = n - 1; i >= 0; --i) {
09474 ((Emc2DCrystal*) (soff+(sizeof(Emc2DCrystal)*i)))->~G__TEmc2DCrystal();
09475 }
09476 G__setgvp((long)gvp);
09477 }
09478 } else {
09479 if (gvp == (char*)G__PVOID) {
09480 delete (Emc2DCrystal*) soff;
09481 } else {
09482 G__setgvp((long) G__PVOID);
09483 ((Emc2DCrystal*) (soff))->~G__TEmc2DCrystal();
09484 G__setgvp((long)gvp);
09485 }
09486 }
09487 G__setnull(result7);
09488 return(1 || funcname || hash || result7 || libp) ;
09489 }
09490
09491
09492 static int G__BesVisLib_rootcint_841_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09493 {
09494 Emc2DCrystal* dest = (Emc2DCrystal*) G__getstructoffset();
09495 *dest = *(Emc2DCrystal*) libp->para[0].ref;
09496 const Emc2DCrystal& obj = *dest;
09497 result7->ref = (long) (&obj);
09498 result7->obj.i = (long) (&obj);
09499 return(1 || funcname || hash || result7 || libp) ;
09500 }
09501
09502
09503
09504 static int G__BesVisLib_rootcint_842_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09505 {
09506 EmcROOTGeo* p = NULL;
09507 char* gvp = (char*) G__getgvp();
09508 int n = G__getaryconstruct();
09509 if (n) {
09510 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09511 p = new EmcROOTGeo[n];
09512 } else {
09513 p = new((void*) gvp) EmcROOTGeo[n];
09514 }
09515 } else {
09516 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09517 p = new EmcROOTGeo;
09518 } else {
09519 p = new((void*) gvp) EmcROOTGeo;
09520 }
09521 }
09522 result7->obj.i = (long) p;
09523 result7->ref = (long) p;
09524 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
09525 return(1 || funcname || hash || result7 || libp) ;
09526 }
09527
09528 static int G__BesVisLib_rootcint_842_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09529 {
09530 ((EmcROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09531 G__setnull(result7);
09532 return(1 || funcname || hash || result7 || libp) ;
09533 }
09534
09535 static int G__BesVisLib_rootcint_842_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09536 {
09537 ((EmcROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
09538 G__setnull(result7);
09539 return(1 || funcname || hash || result7 || libp) ;
09540 }
09541
09542 static int G__BesVisLib_rootcint_842_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09543 {
09544 ((EmcROOTGeo*) G__getstructoffset())->Init2DGeometry();
09545 G__setnull(result7);
09546 return(1 || funcname || hash || result7 || libp) ;
09547 }
09548
09549 static int G__BesVisLib_rootcint_842_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09550 {
09551 ((EmcROOTGeo*) G__getstructoffset())->SetNode();
09552 G__setnull(result7);
09553 return(1 || funcname || hash || result7 || libp) ;
09554 }
09555
09556 static int G__BesVisLib_rootcint_842_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09557 {
09558 ((EmcROOTGeo*) G__getstructoffset())->SetVolumeAppendInVis();
09559 G__setnull(result7);
09560 return(1 || funcname || hash || result7 || libp) ;
09561 }
09562
09563 static int G__BesVisLib_rootcint_842_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09564 {
09565 ((EmcROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
09566 G__setnull(result7);
09567 return(1 || funcname || hash || result7 || libp) ;
09568 }
09569
09570 static int G__BesVisLib_rootcint_842_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09571 {
09572 ((EmcROOTGeo*) G__getstructoffset())->SetAllVisible();
09573 G__setnull(result7);
09574 return(1 || funcname || hash || result7 || libp) ;
09575 }
09576
09577 static int G__BesVisLib_rootcint_842_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09578 {
09579 ((EmcROOTGeo*) G__getstructoffset())->SetQuarterVisible();
09580 G__setnull(result7);
09581 return(1 || funcname || hash || result7 || libp) ;
09582 }
09583
09584 static int G__BesVisLib_rootcint_842_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09585 {
09586 ((EmcROOTGeo*) G__getstructoffset())->SetHalfVisible();
09587 G__setnull(result7);
09588 return(1 || funcname || hash || result7 || libp) ;
09589 }
09590
09591 static int G__BesVisLib_rootcint_842_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09592 {
09593 ((EmcROOTGeo*) G__getstructoffset())->SetNoEndVisible();
09594 G__setnull(result7);
09595 return(1 || funcname || hash || result7 || libp) ;
09596 }
09597
09598 static int G__BesVisLib_rootcint_842_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09599 {
09600 ((EmcROOTGeo*) G__getstructoffset())->SetPhysicalNode();
09601 G__setnull(result7);
09602 return(1 || funcname || hash || result7 || libp) ;
09603 }
09604
09605 static int G__BesVisLib_rootcint_842_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09606 {
09607 ((EmcROOTGeo*) G__getstructoffset())->SetDetector();
09608 G__setnull(result7);
09609 return(1 || funcname || hash || result7 || libp) ;
09610 }
09611
09612 static int G__BesVisLib_rootcint_842_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09613 {
09614 ((EmcROOTGeo*) G__getstructoffset())->SetHits();
09615 G__setnull(result7);
09616 return(1 || funcname || hash || result7 || libp) ;
09617 }
09618
09619 static int G__BesVisLib_rootcint_842_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09620 {
09621 ((EmcROOTGeo*) G__getstructoffset())->SetVisEmcDetector();
09622 G__setnull(result7);
09623 return(1 || funcname || hash || result7 || libp) ;
09624 }
09625
09626 static int G__BesVisLib_rootcint_842_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09627 {
09628 ((EmcROOTGeo*) G__getstructoffset())->SetVisEmcHits();
09629 G__setnull(result7);
09630 return(1 || funcname || hash || result7 || libp) ;
09631 }
09632
09633 static int G__BesVisLib_rootcint_842_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09634 {
09635 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPartNb());
09636 return(1 || funcname || hash || result7 || libp) ;
09637 }
09638
09639 static int G__BesVisLib_rootcint_842_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09640 {
09641 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetThetaNb((int) G__int(libp->para[0])));
09642 return(1 || funcname || hash || result7 || libp) ;
09643 }
09644
09645 static int G__BesVisLib_rootcint_842_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09646 {
09647 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhiNb((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09648 return(1 || funcname || hash || result7 || libp) ;
09649 }
09650
09651 static int G__BesVisLib_rootcint_842_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09652 {
09653 ((EmcROOTGeo*) G__getstructoffset())->SetVolumeEmc((TGeoVolume*) G__int(libp->para[0]));
09654 G__setnull(result7);
09655 return(1 || funcname || hash || result7 || libp) ;
09656 }
09657
09658 static int G__BesVisLib_rootcint_842_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09659 {
09660 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumeEmc());
09661 return(1 || funcname || hash || result7 || libp) ;
09662 }
09663
09664 static int G__BesVisLib_rootcint_842_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09665 {
09666 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumePart((int) G__int(libp->para[0])));
09667 return(1 || funcname || hash || result7 || libp) ;
09668 }
09669
09670 static int G__BesVisLib_rootcint_842_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09671 {
09672 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumePhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09673 return(1 || funcname || hash || result7 || libp) ;
09674 }
09675
09676 static int G__BesVisLib_rootcint_842_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09677 {
09678 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumeTheta((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09679 , (int) G__int(libp->para[2])));
09680 return(1 || funcname || hash || result7 || libp) ;
09681 }
09682
09683 static int G__BesVisLib_rootcint_842_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09684 {
09685 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetVolumeCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09686 , (int) G__int(libp->para[2])));
09687 return(1 || funcname || hash || result7 || libp) ;
09688 }
09689
09690 static int G__BesVisLib_rootcint_842_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09691 {
09692 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPart((int) G__int(libp->para[0])));
09693 return(1 || funcname || hash || result7 || libp) ;
09694 }
09695
09696 static int G__BesVisLib_rootcint_842_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09697 {
09698 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
09699 return(1 || funcname || hash || result7 || libp) ;
09700 }
09701
09702 static int G__BesVisLib_rootcint_842_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09703 {
09704 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetTheta((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09705 , (int) G__int(libp->para[2])));
09706 return(1 || funcname || hash || result7 || libp) ;
09707 }
09708
09709 static int G__BesVisLib_rootcint_842_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09710 {
09711 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetTheta2((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09712 , (int) G__int(libp->para[2])));
09713 return(1 || funcname || hash || result7 || libp) ;
09714 }
09715
09716 static int G__BesVisLib_rootcint_842_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09717 {
09718 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09719 , (int) G__int(libp->para[2])));
09720 return(1 || funcname || hash || result7 || libp) ;
09721 }
09722
09723 static int G__BesVisLib_rootcint_842_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09724 {
09725 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetCrystal2((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09726 , (int) G__int(libp->para[2])));
09727 return(1 || funcname || hash || result7 || libp) ;
09728 }
09729
09730 static int G__BesVisLib_rootcint_842_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09731 {
09732 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhysicalCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09733 , (int) G__int(libp->para[2])));
09734 return(1 || funcname || hash || result7 || libp) ;
09735 }
09736
09737 static int G__BesVisLib_rootcint_842_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09738 {
09739 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPhysicalCrystal2((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09740 , (int) G__int(libp->para[2])));
09741 return(1 || funcname || hash || result7 || libp) ;
09742 }
09743
09744 static int G__BesVisLib_rootcint_842_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09745 {
09746 G__letint(result7, 103, (long) ((EmcROOTGeo*) G__getstructoffset())->HasTwoNodes((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09747 , (int) G__int(libp->para[2])));
09748 return(1 || funcname || hash || result7 || libp) ;
09749 }
09750
09751 static int G__BesVisLib_rootcint_842_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09752 {
09753 ((EmcROOTGeo*) G__getstructoffset())->ComputeThetaPhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
09754 , (int) G__int(libp->para[2]), *(int*) G__Intref(&libp->para[3])
09755 , *(int*) G__Intref(&libp->para[4]));
09756 G__setnull(result7);
09757 return(1 || funcname || hash || result7 || libp) ;
09758 }
09759
09760 static int G__BesVisLib_rootcint_842_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09761 {
09762 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->ComputeEndCopyNb((int) G__int(libp->para[0])));
09763 return(1 || funcname || hash || result7 || libp) ;
09764 }
09765
09766 static int G__BesVisLib_rootcint_842_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09767 {
09768 G__letint(result7, 85, (long) ((EmcROOTGeo*) G__getstructoffset())->Get2DCrystal((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09769 , (Int_t) G__int(libp->para[2])));
09770 return(1 || funcname || hash || result7 || libp) ;
09771 }
09772
09773 static int G__BesVisLib_rootcint_842_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09774 {
09775 G__letint(result7, 105, (long) ((EmcROOTGeo*) G__getstructoffset())->GetPart((TGeoPhysicalNode*) G__int(libp->para[0])));
09776 return(1 || funcname || hash || result7 || libp) ;
09777 }
09778
09779 static int G__BesVisLib_rootcint_842_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09780 {
09781 ((EmcROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
09782 G__setnull(result7);
09783 return(1 || funcname || hash || result7 || libp) ;
09784 }
09785
09786 static int G__BesVisLib_rootcint_842_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09787 {
09788 ((EmcROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
09789 G__setnull(result7);
09790 return(1 || funcname || hash || result7 || libp) ;
09791 }
09792
09793 static int G__BesVisLib_rootcint_842_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09794 {
09795 switch (libp->paran) {
09796 case 4:
09797 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])
09798 , (TGeoShape*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
09799 G__setnull(result7);
09800 break;
09801 case 3:
09802 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])
09803 , (TGeoShape*) G__int(libp->para[2]));
09804 G__setnull(result7);
09805 break;
09806 case 2:
09807 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1]));
09808 G__setnull(result7);
09809 break;
09810 case 1:
09811 ((EmcROOTGeo*) G__getstructoffset())->Align((TGeoPhysicalNode*) G__int(libp->para[0]));
09812 G__setnull(result7);
09813 break;
09814 }
09815 return(1 || funcname || hash || result7 || libp) ;
09816 }
09817
09818 static int G__BesVisLib_rootcint_842_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09819 {
09820 ((EmcROOTGeo*) G__getstructoffset())->RestorePhyNode((TGeoPhysicalNode*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1]));
09821 G__setnull(result7);
09822 return(1 || funcname || hash || result7 || libp) ;
09823 }
09824
09825
09826 static int G__BesVisLib_rootcint_842_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09827
09828 {
09829 EmcROOTGeo* p;
09830 void* tmp = (void*) G__int(libp->para[0]);
09831 p = new EmcROOTGeo(*(EmcROOTGeo*) tmp);
09832 result7->obj.i = (long) p;
09833 result7->ref = (long) p;
09834 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
09835 return(1 || funcname || hash || result7 || libp) ;
09836 }
09837
09838
09839 typedef EmcROOTGeo G__TEmcROOTGeo;
09840 static int G__BesVisLib_rootcint_842_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09841 {
09842 char* gvp = (char*) G__getgvp();
09843 long soff = G__getstructoffset();
09844 int n = G__getaryconstruct();
09845
09846
09847
09848
09849
09850 if (!soff) {
09851 return(1);
09852 }
09853 if (n) {
09854 if (gvp == (char*)G__PVOID) {
09855 delete[] (EmcROOTGeo*) soff;
09856 } else {
09857 G__setgvp((long) G__PVOID);
09858 for (int i = n - 1; i >= 0; --i) {
09859 ((EmcROOTGeo*) (soff+(sizeof(EmcROOTGeo)*i)))->~G__TEmcROOTGeo();
09860 }
09861 G__setgvp((long)gvp);
09862 }
09863 } else {
09864 if (gvp == (char*)G__PVOID) {
09865 delete (EmcROOTGeo*) soff;
09866 } else {
09867 G__setgvp((long) G__PVOID);
09868 ((EmcROOTGeo*) (soff))->~G__TEmcROOTGeo();
09869 G__setgvp((long)gvp);
09870 }
09871 }
09872 G__setnull(result7);
09873 return(1 || funcname || hash || result7 || libp) ;
09874 }
09875
09876
09877
09878 static int G__BesVisLib_rootcint_843_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09879 {
09880 Muc2DStrip* p = NULL;
09881 char* gvp = (char*) G__getgvp();
09882 int n = G__getaryconstruct();
09883 if (n) {
09884 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09885 p = new Muc2DStrip[n];
09886 } else {
09887 p = new((void*) gvp) Muc2DStrip[n];
09888 }
09889 } else {
09890 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09891 p = new Muc2DStrip;
09892 } else {
09893 p = new((void*) gvp) Muc2DStrip;
09894 }
09895 }
09896 result7->obj.i = (long) p;
09897 result7->ref = (long) p;
09898 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
09899 return(1 || funcname || hash || result7 || libp) ;
09900 }
09901
09902 static int G__BesVisLib_rootcint_843_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09903 {
09904 Muc2DStrip* p = NULL;
09905 char* gvp = (char*) G__getgvp();
09906
09907 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09908 p = new Muc2DStrip(
09909 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09910 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
09911 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09912 , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
09913 } else {
09914 p = new((void*) gvp) Muc2DStrip(
09915 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09916 , (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
09917 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09918 , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
09919 }
09920 result7->obj.i = (long) p;
09921 result7->ref = (long) p;
09922 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
09923 return(1 || funcname || hash || result7 || libp) ;
09924 }
09925
09926 static int G__BesVisLib_rootcint_843_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09927 {
09928 ((Muc2DStrip*) G__getstructoffset())->SetStyle();
09929 G__setnull(result7);
09930 return(1 || funcname || hash || result7 || libp) ;
09931 }
09932
09933 static int G__BesVisLib_rootcint_843_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09934 {
09935 switch (libp->paran) {
09936 case 1:
09937 ((Muc2DStrip*) G__getstructoffset())->SetHighlighted((bool) G__int(libp->para[0]));
09938 G__setnull(result7);
09939 break;
09940 case 0:
09941 ((Muc2DStrip*) G__getstructoffset())->SetHighlighted();
09942 G__setnull(result7);
09943 break;
09944 }
09945 return(1 || funcname || hash || result7 || libp) ;
09946 }
09947
09948 static int G__BesVisLib_rootcint_843_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09949 {
09950 switch (libp->paran) {
09951 case 1:
09952 ((Muc2DStrip*) G__getstructoffset())->SetFired((bool) G__int(libp->para[0]));
09953 G__setnull(result7);
09954 break;
09955 case 0:
09956 ((Muc2DStrip*) G__getstructoffset())->SetFired();
09957 G__setnull(result7);
09958 break;
09959 }
09960 return(1 || funcname || hash || result7 || libp) ;
09961 }
09962
09963 static int G__BesVisLib_rootcint_843_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09964 {
09965 G__letint(result7, 103, (long) ((Muc2DStrip*) G__getstructoffset())->IsHighlighted());
09966 return(1 || funcname || hash || result7 || libp) ;
09967 }
09968
09969 static int G__BesVisLib_rootcint_843_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09970 {
09971 G__letint(result7, 103, (long) ((Muc2DStrip*) G__getstructoffset())->IsFired());
09972 return(1 || funcname || hash || result7 || libp) ;
09973 }
09974
09975 static int G__BesVisLib_rootcint_843_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09976 {
09977 ((Muc2DStrip*) G__getstructoffset())->AddInfo(*((TString*) G__int(libp->para[0])));
09978 G__setnull(result7);
09979 return(1 || funcname || hash || result7 || libp) ;
09980 }
09981
09982 static int G__BesVisLib_rootcint_843_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09983 {
09984 ((Muc2DStrip*) G__getstructoffset())->CloseInfo();
09985 G__setnull(result7);
09986 return(1 || funcname || hash || result7 || libp) ;
09987 }
09988
09989 static int G__BesVisLib_rootcint_843_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09990 {
09991 ((Muc2DStrip*) G__getstructoffset())->ClearInfo();
09992 G__setnull(result7);
09993 return(1 || funcname || hash || result7 || libp) ;
09994 }
09995
09996 static int G__BesVisLib_rootcint_843_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09997 {
09998 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetPart());
09999 return(1 || funcname || hash || result7 || libp) ;
10000 }
10001
10002 static int G__BesVisLib_rootcint_843_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10003 {
10004 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetSeg());
10005 return(1 || funcname || hash || result7 || libp) ;
10006 }
10007
10008 static int G__BesVisLib_rootcint_843_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10009 {
10010 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetGap());
10011 return(1 || funcname || hash || result7 || libp) ;
10012 }
10013
10014 static int G__BesVisLib_rootcint_843_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10015 {
10016 G__letint(result7, 105, (long) ((Muc2DStrip*) G__getstructoffset())->GetStrip());
10017 return(1 || funcname || hash || result7 || libp) ;
10018 }
10019
10020 static int G__BesVisLib_rootcint_843_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10021 {
10022 G__letint(result7, 103, (long) ((Muc2DStrip*) G__getstructoffset())->IsZRVisible());
10023 return(1 || funcname || hash || result7 || libp) ;
10024 }
10025
10026 static int G__BesVisLib_rootcint_843_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10027 {
10028 G__letdouble(result7, 100, (double) ((Muc2DStrip*) G__getstructoffset())->GetAngle((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
10029 return(1 || funcname || hash || result7 || libp) ;
10030 }
10031
10032 static int G__BesVisLib_rootcint_843_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10033 {
10034 G__letdouble(result7, 100, (double) ((Muc2DStrip*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
10035 return(1 || funcname || hash || result7 || libp) ;
10036 }
10037
10038 static int G__BesVisLib_rootcint_843_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10039 {
10040 G__letint(result7, 85, (long) Muc2DStrip::Class());
10041 return(1 || funcname || hash || result7 || libp) ;
10042 }
10043
10044 static int G__BesVisLib_rootcint_843_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10045 {
10046 G__letint(result7, 67, (long) Muc2DStrip::Class_Name());
10047 return(1 || funcname || hash || result7 || libp) ;
10048 }
10049
10050 static int G__BesVisLib_rootcint_843_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10051 {
10052 G__letint(result7, 115, (long) Muc2DStrip::Class_Version());
10053 return(1 || funcname || hash || result7 || libp) ;
10054 }
10055
10056 static int G__BesVisLib_rootcint_843_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10057 {
10058 Muc2DStrip::Dictionary();
10059 G__setnull(result7);
10060 return(1 || funcname || hash || result7 || libp) ;
10061 }
10062
10063 static int G__BesVisLib_rootcint_843_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10064 {
10065 ((Muc2DStrip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10066 G__setnull(result7);
10067 return(1 || funcname || hash || result7 || libp) ;
10068 }
10069
10070 static int G__BesVisLib_rootcint_843_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10071 {
10072 G__letint(result7, 67, (long) Muc2DStrip::DeclFileName());
10073 return(1 || funcname || hash || result7 || libp) ;
10074 }
10075
10076 static int G__BesVisLib_rootcint_843_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10077 {
10078 G__letint(result7, 105, (long) Muc2DStrip::ImplFileLine());
10079 return(1 || funcname || hash || result7 || libp) ;
10080 }
10081
10082 static int G__BesVisLib_rootcint_843_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10083 {
10084 G__letint(result7, 67, (long) Muc2DStrip::ImplFileName());
10085 return(1 || funcname || hash || result7 || libp) ;
10086 }
10087
10088 static int G__BesVisLib_rootcint_843_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10089 {
10090 G__letint(result7, 105, (long) Muc2DStrip::DeclFileLine());
10091 return(1 || funcname || hash || result7 || libp) ;
10092 }
10093
10094
10095 static int G__BesVisLib_rootcint_843_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10096
10097 {
10098 Muc2DStrip* p;
10099 void* tmp = (void*) G__int(libp->para[0]);
10100 p = new Muc2DStrip(*(Muc2DStrip*) tmp);
10101 result7->obj.i = (long) p;
10102 result7->ref = (long) p;
10103 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
10104 return(1 || funcname || hash || result7 || libp) ;
10105 }
10106
10107
10108 typedef Muc2DStrip G__TMuc2DStrip;
10109 static int G__BesVisLib_rootcint_843_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10110 {
10111 char* gvp = (char*) G__getgvp();
10112 long soff = G__getstructoffset();
10113 int n = G__getaryconstruct();
10114
10115
10116
10117
10118
10119 if (!soff) {
10120 return(1);
10121 }
10122 if (n) {
10123 if (gvp == (char*)G__PVOID) {
10124 delete[] (Muc2DStrip*) soff;
10125 } else {
10126 G__setgvp((long) G__PVOID);
10127 for (int i = n - 1; i >= 0; --i) {
10128 ((Muc2DStrip*) (soff+(sizeof(Muc2DStrip)*i)))->~G__TMuc2DStrip();
10129 }
10130 G__setgvp((long)gvp);
10131 }
10132 } else {
10133 if (gvp == (char*)G__PVOID) {
10134 delete (Muc2DStrip*) soff;
10135 } else {
10136 G__setgvp((long) G__PVOID);
10137 ((Muc2DStrip*) (soff))->~G__TMuc2DStrip();
10138 G__setgvp((long)gvp);
10139 }
10140 }
10141 G__setnull(result7);
10142 return(1 || funcname || hash || result7 || libp) ;
10143 }
10144
10145
10146 static int G__BesVisLib_rootcint_843_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10147 {
10148 Muc2DStrip* dest = (Muc2DStrip*) G__getstructoffset();
10149 *dest = *(Muc2DStrip*) libp->para[0].ref;
10150 const Muc2DStrip& obj = *dest;
10151 result7->ref = (long) (&obj);
10152 result7->obj.i = (long) (&obj);
10153 return(1 || funcname || hash || result7 || libp) ;
10154 }
10155
10156
10157
10158 static int G__BesVisLib_rootcint_844_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10159 {
10160 MucROOTGeo* p = NULL;
10161 char* gvp = (char*) G__getgvp();
10162 int n = G__getaryconstruct();
10163 if (n) {
10164 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10165 p = new MucROOTGeo[n];
10166 } else {
10167 p = new((void*) gvp) MucROOTGeo[n];
10168 }
10169 } else {
10170 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10171 p = new MucROOTGeo;
10172 } else {
10173 p = new((void*) gvp) MucROOTGeo;
10174 }
10175 }
10176 result7->obj.i = (long) p;
10177 result7->ref = (long) p;
10178 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
10179 return(1 || funcname || hash || result7 || libp) ;
10180 }
10181
10182 static int G__BesVisLib_rootcint_844_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10183 {
10184 ((MucROOTGeo*) G__getstructoffset())->InitFromGDML((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10185 G__setnull(result7);
10186 return(1 || funcname || hash || result7 || libp) ;
10187 }
10188
10189 static int G__BesVisLib_rootcint_844_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10190 {
10191 ((MucROOTGeo*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
10192 G__setnull(result7);
10193 return(1 || funcname || hash || result7 || libp) ;
10194 }
10195
10196 static int G__BesVisLib_rootcint_844_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10197 {
10198 ((MucROOTGeo*) G__getstructoffset())->Init2DGeometry();
10199 G__setnull(result7);
10200 return(1 || funcname || hash || result7 || libp) ;
10201 }
10202
10203 static int G__BesVisLib_rootcint_844_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10204 {
10205 ((MucROOTGeo*) G__getstructoffset())->SetNode();
10206 G__setnull(result7);
10207 return(1 || funcname || hash || result7 || libp) ;
10208 }
10209
10210 static int G__BesVisLib_rootcint_844_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10211 {
10212 ((MucROOTGeo*) G__getstructoffset())->SetVolumeDefaultVis();
10213 G__setnull(result7);
10214 return(1 || funcname || hash || result7 || libp) ;
10215 }
10216
10217 static int G__BesVisLib_rootcint_844_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10218 {
10219 ((MucROOTGeo*) G__getstructoffset())->SetAllVisible();
10220 G__setnull(result7);
10221 return(1 || funcname || hash || result7 || libp) ;
10222 }
10223
10224 static int G__BesVisLib_rootcint_844_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10225 {
10226 ((MucROOTGeo*) G__getstructoffset())->SetQuarterVisible();
10227 G__setnull(result7);
10228 return(1 || funcname || hash || result7 || libp) ;
10229 }
10230
10231 static int G__BesVisLib_rootcint_844_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10232 {
10233 ((MucROOTGeo*) G__getstructoffset())->SetHalfVisible();
10234 G__setnull(result7);
10235 return(1 || funcname || hash || result7 || libp) ;
10236 }
10237
10238 static int G__BesVisLib_rootcint_844_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10239 {
10240 ((MucROOTGeo*) G__getstructoffset())->SetNoEndVisible();
10241 G__setnull(result7);
10242 return(1 || funcname || hash || result7 || libp) ;
10243 }
10244
10245 static int G__BesVisLib_rootcint_844_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10246 {
10247 ((MucROOTGeo*) G__getstructoffset())->SetPhysicalNode();
10248 G__setnull(result7);
10249 return(1 || funcname || hash || result7 || libp) ;
10250 }
10251
10252 static int G__BesVisLib_rootcint_844_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10253 {
10254 ((MucROOTGeo*) G__getstructoffset())->SetDetector();
10255 G__setnull(result7);
10256 return(1 || funcname || hash || result7 || libp) ;
10257 }
10258
10259 static int G__BesVisLib_rootcint_844_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10260 {
10261 ((MucROOTGeo*) G__getstructoffset())->SetHits();
10262 G__setnull(result7);
10263 return(1 || funcname || hash || result7 || libp) ;
10264 }
10265
10266 static int G__BesVisLib_rootcint_844_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10267 {
10268 ((MucROOTGeo*) G__getstructoffset())->SetVisMucDetector();
10269 G__setnull(result7);
10270 return(1 || funcname || hash || result7 || libp) ;
10271 }
10272
10273 static int G__BesVisLib_rootcint_844_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10274 {
10275 ((MucROOTGeo*) G__getstructoffset())->SetVisMucHits();
10276 G__setnull(result7);
10277 return(1 || funcname || hash || result7 || libp) ;
10278 }
10279
10280 static int G__BesVisLib_rootcint_844_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10281 {
10282 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetPartNb());
10283 return(1 || funcname || hash || result7 || libp) ;
10284 }
10285
10286 static int G__BesVisLib_rootcint_844_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10287 {
10288 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetSegNb((int) G__int(libp->para[0])));
10289 return(1 || funcname || hash || result7 || libp) ;
10290 }
10291
10292 static int G__BesVisLib_rootcint_844_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10293 {
10294 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetGapNb((int) G__int(libp->para[0])));
10295 return(1 || funcname || hash || result7 || libp) ;
10296 }
10297
10298 static int G__BesVisLib_rootcint_844_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10299 {
10300 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetStripNb((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10301 , (int) G__int(libp->para[2])));
10302 return(1 || funcname || hash || result7 || libp) ;
10303 }
10304
10305 static int G__BesVisLib_rootcint_844_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10306 {
10307 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetAbsorberNb((int) G__int(libp->para[0])));
10308 return(1 || funcname || hash || result7 || libp) ;
10309 }
10310
10311 static int G__BesVisLib_rootcint_844_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10312 {
10313 ((MucROOTGeo*) G__getstructoffset())->SetVolumeMuc((TGeoVolume*) G__int(libp->para[0]));
10314 G__setnull(result7);
10315 return(1 || funcname || hash || result7 || libp) ;
10316 }
10317
10318 static int G__BesVisLib_rootcint_844_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10319 {
10320 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeMuc());
10321 return(1 || funcname || hash || result7 || libp) ;
10322 }
10323
10324 static int G__BesVisLib_rootcint_844_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10325 {
10326 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10327 , (int) G__int(libp->para[2])));
10328 return(1 || funcname || hash || result7 || libp) ;
10329 }
10330
10331 static int G__BesVisLib_rootcint_844_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10332 {
10333 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeAbsorberSmallBlock((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10334 return(1 || funcname || hash || result7 || libp) ;
10335 }
10336
10337 static int G__BesVisLib_rootcint_844_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10338 {
10339 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeAbsorberPanel((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10340 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10341 return(1 || funcname || hash || result7 || libp) ;
10342 }
10343
10344 static int G__BesVisLib_rootcint_844_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10345 {
10346 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10347 , (int) G__int(libp->para[2])));
10348 return(1 || funcname || hash || result7 || libp) ;
10349 }
10350
10351 static int G__BesVisLib_rootcint_844_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10352 {
10353 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeBox((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10354 , (int) G__int(libp->para[2])));
10355 return(1 || funcname || hash || result7 || libp) ;
10356 }
10357
10358 static int G__BesVisLib_rootcint_844_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10359 {
10360 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeBoxSurface((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10361 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10362 return(1 || funcname || hash || result7 || libp) ;
10363 }
10364
10365 static int G__BesVisLib_rootcint_844_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10366 {
10367 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeStripPlane((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10368 , (int) G__int(libp->para[2])));
10369 return(1 || funcname || hash || result7 || libp) ;
10370 }
10371
10372 static int G__BesVisLib_rootcint_844_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10373 {
10374 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10375 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10376 return(1 || funcname || hash || result7 || libp) ;
10377 }
10378
10379 static int G__BesVisLib_rootcint_844_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10380 {
10381 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeGasChamber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10382 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10383 , (int) G__int(libp->para[4])));
10384 return(1 || funcname || hash || result7 || libp) ;
10385 }
10386
10387 static int G__BesVisLib_rootcint_844_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10388 {
10389 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeGasBorder((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10390 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10391 , (int) G__int(libp->para[4])));
10392 return(1 || funcname || hash || result7 || libp) ;
10393 }
10394
10395 static int G__BesVisLib_rootcint_844_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10396 {
10397 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetVolumeBakelite((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10398 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10399 , (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
10400 return(1 || funcname || hash || result7 || libp) ;
10401 }
10402
10403 static int G__BesVisLib_rootcint_844_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10404 {
10405 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10406 , (int) G__int(libp->para[2])));
10407 return(1 || funcname || hash || result7 || libp) ;
10408 }
10409
10410 static int G__BesVisLib_rootcint_844_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10411 {
10412 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetAbsorberPanel((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10413 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10414 return(1 || funcname || hash || result7 || libp) ;
10415 }
10416
10417 static int G__BesVisLib_rootcint_844_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10418 {
10419 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10420 , (int) G__int(libp->para[2])));
10421 return(1 || funcname || hash || result7 || libp) ;
10422 }
10423
10424 static int G__BesVisLib_rootcint_844_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10425 {
10426 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetStripPlane((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10427 , (int) G__int(libp->para[2])));
10428 return(1 || funcname || hash || result7 || libp) ;
10429 }
10430
10431 static int G__BesVisLib_rootcint_844_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10432 {
10433 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10434 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10435 return(1 || funcname || hash || result7 || libp) ;
10436 }
10437
10438 static int G__BesVisLib_rootcint_844_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10439 {
10440 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetPhysicalAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10441 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10442 return(1 || funcname || hash || result7 || libp) ;
10443 }
10444
10445 static int G__BesVisLib_rootcint_844_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10446 {
10447 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetPhysicalGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10448 , (int) G__int(libp->para[2])));
10449 return(1 || funcname || hash || result7 || libp) ;
10450 }
10451
10452 static int G__BesVisLib_rootcint_844_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10453 {
10454 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->GetPhysicalStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10455 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10456 return(1 || funcname || hash || result7 || libp) ;
10457 }
10458
10459 static int G__BesVisLib_rootcint_844_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10460 {
10461 G__letint(result7, 85, (long) ((MucROOTGeo*) G__getstructoffset())->Get2DStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10462 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10463 return(1 || funcname || hash || result7 || libp) ;
10464 }
10465
10466 static int G__BesVisLib_rootcint_844_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10467 {
10468 G__letint(result7, 105, (long) ((MucROOTGeo*) G__getstructoffset())->GetPart((TGeoPhysicalNode*) G__int(libp->para[0])));
10469 return(1 || funcname || hash || result7 || libp) ;
10470 }
10471
10472 static int G__BesVisLib_rootcint_844_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10473 {
10474 G__letint(result7, 103, (long) ((MucROOTGeo*) G__getstructoffset())->IsZRVisible((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10475 return(1 || funcname || hash || result7 || libp) ;
10476 }
10477
10478 static int G__BesVisLib_rootcint_844_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10479 {
10480 G__letdouble(result7, 100, (double) ((MucROOTGeo*) G__getstructoffset())->Range360((Double_t) G__double(libp->para[0])));
10481 return(1 || funcname || hash || result7 || libp) ;
10482 }
10483
10484 static int G__BesVisLib_rootcint_844_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10485 {
10486 ((MucROOTGeo*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
10487 G__setnull(result7);
10488 return(1 || funcname || hash || result7 || libp) ;
10489 }
10490
10491 static int G__BesVisLib_rootcint_844_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10492 {
10493 ((MucROOTGeo*) G__getstructoffset())->DrawHits((Option_t*) G__int(libp->para[0]));
10494 G__setnull(result7);
10495 return(1 || funcname || hash || result7 || libp) ;
10496 }
10497
10498
10499 static int G__BesVisLib_rootcint_844_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10500
10501 {
10502 MucROOTGeo* p;
10503 void* tmp = (void*) G__int(libp->para[0]);
10504 p = new MucROOTGeo(*(MucROOTGeo*) tmp);
10505 result7->obj.i = (long) p;
10506 result7->ref = (long) p;
10507 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
10508 return(1 || funcname || hash || result7 || libp) ;
10509 }
10510
10511
10512 typedef MucROOTGeo G__TMucROOTGeo;
10513 static int G__BesVisLib_rootcint_844_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10514 {
10515 char* gvp = (char*) G__getgvp();
10516 long soff = G__getstructoffset();
10517 int n = G__getaryconstruct();
10518
10519
10520
10521
10522
10523 if (!soff) {
10524 return(1);
10525 }
10526 if (n) {
10527 if (gvp == (char*)G__PVOID) {
10528 delete[] (MucROOTGeo*) soff;
10529 } else {
10530 G__setgvp((long) G__PVOID);
10531 for (int i = n - 1; i >= 0; --i) {
10532 ((MucROOTGeo*) (soff+(sizeof(MucROOTGeo)*i)))->~G__TMucROOTGeo();
10533 }
10534 G__setgvp((long)gvp);
10535 }
10536 } else {
10537 if (gvp == (char*)G__PVOID) {
10538 delete (MucROOTGeo*) soff;
10539 } else {
10540 G__setgvp((long) G__PVOID);
10541 ((MucROOTGeo*) (soff))->~G__TMucROOTGeo();
10542 G__setgvp((long)gvp);
10543 }
10544 }
10545 G__setnull(result7);
10546 return(1 || funcname || hash || result7 || libp) ;
10547 }
10548
10549
10550
10551 static int G__BesVisLib_rootcint_845_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10552 {
10553 BesGeometry* p = NULL;
10554 char* gvp = (char*) G__getgvp();
10555 int n = G__getaryconstruct();
10556 if (n) {
10557 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10558 p = new BesGeometry[n];
10559 } else {
10560 p = new((void*) gvp) BesGeometry[n];
10561 }
10562 } else {
10563 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10564 p = new BesGeometry;
10565 } else {
10566 p = new((void*) gvp) BesGeometry;
10567 }
10568 }
10569 result7->obj.i = (long) p;
10570 result7->ref = (long) p;
10571 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
10572 return(1 || funcname || hash || result7 || libp) ;
10573 }
10574
10575 static int G__BesVisLib_rootcint_845_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10576 {
10577 ((BesGeometry*) G__getstructoffset())->InitFromGDML(*((const TString*) G__int(libp->para[0])));
10578 G__setnull(result7);
10579 return(1 || funcname || hash || result7 || libp) ;
10580 }
10581
10582 static int G__BesVisLib_rootcint_845_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10583 {
10584 ((BesGeometry*) G__getstructoffset())->InitFromROOT((TGeoVolume*) G__int(libp->para[0]));
10585 G__setnull(result7);
10586 return(1 || funcname || hash || result7 || libp) ;
10587 }
10588
10589 static int G__BesVisLib_rootcint_845_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10590 {
10591 ((BesGeometry*) G__getstructoffset())->InitGeometry();
10592 G__setnull(result7);
10593 return(1 || funcname || hash || result7 || libp) ;
10594 }
10595
10596 static int G__BesVisLib_rootcint_845_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10597 {
10598 G__letint(result7, 67, (long) ((BesGeometry*) G__getstructoffset())->GetFilename((const char*) G__int(libp->para[0])));
10599 return(1 || funcname || hash || result7 || libp) ;
10600 }
10601
10602 static int G__BesVisLib_rootcint_845_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10603 {
10604 ((BesGeometry*) G__getstructoffset())->SetDefaultVis();
10605 G__setnull(result7);
10606 return(1 || funcname || hash || result7 || libp) ;
10607 }
10608
10609 static int G__BesVisLib_rootcint_845_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10610 {
10611 ((BesGeometry*) G__getstructoffset())->Draw3D();
10612 G__setnull(result7);
10613 return(1 || funcname || hash || result7 || libp) ;
10614 }
10615
10616 static int G__BesVisLib_rootcint_845_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10617 {
10618 ((BesGeometry*) G__getstructoffset())->Draw2DXY();
10619 G__setnull(result7);
10620 return(1 || funcname || hash || result7 || libp) ;
10621 }
10622
10623 static int G__BesVisLib_rootcint_845_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10624 {
10625 ((BesGeometry*) G__getstructoffset())->Draw2DZR();
10626 G__setnull(result7);
10627 return(1 || funcname || hash || result7 || libp) ;
10628 }
10629
10630 static int G__BesVisLib_rootcint_845_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10631 {
10632 G__letdouble(result7, 102, (double) ((BesGeometry*) G__getstructoffset())->GetBesR());
10633 return(1 || funcname || hash || result7 || libp) ;
10634 }
10635
10636 static int G__BesVisLib_rootcint_845_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10637 {
10638 G__letdouble(result7, 102, (double) ((BesGeometry*) G__getstructoffset())->GetBesZ());
10639 return(1 || funcname || hash || result7 || libp) ;
10640 }
10641
10642 static int G__BesVisLib_rootcint_845_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10643 {
10644 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolBes());
10645 return(1 || funcname || hash || result7 || libp) ;
10646 }
10647
10648 static int G__BesVisLib_rootcint_845_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10649 {
10650 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeBeamPipe());
10651 return(1 || funcname || hash || result7 || libp) ;
10652 }
10653
10654 static int G__BesVisLib_rootcint_845_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10655 {
10656 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetMdcROOTGeo());
10657 return(1 || funcname || hash || result7 || libp) ;
10658 }
10659
10660 static int G__BesVisLib_rootcint_845_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10661 {
10662 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetTofROOTGeo());
10663 return(1 || funcname || hash || result7 || libp) ;
10664 }
10665
10666 static int G__BesVisLib_rootcint_845_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10667 {
10668 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetEmcROOTGeo());
10669 return(1 || funcname || hash || result7 || libp) ;
10670 }
10671
10672 static int G__BesVisLib_rootcint_845_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10673 {
10674 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetMucROOTGeo());
10675 return(1 || funcname || hash || result7 || libp) ;
10676 }
10677
10678 static int G__BesVisLib_rootcint_845_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10679 {
10680 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdc());
10681 return(1 || funcname || hash || result7 || libp) ;
10682 }
10683
10684 static int G__BesVisLib_rootcint_845_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10685 {
10686 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdcSegment((int) G__int(libp->para[0])));
10687 return(1 || funcname || hash || result7 || libp) ;
10688 }
10689
10690 static int G__BesVisLib_rootcint_845_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10691 {
10692 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdcLayer((int) G__int(libp->para[0])));
10693 return(1 || funcname || hash || result7 || libp) ;
10694 }
10695
10696 static int G__BesVisLib_rootcint_845_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10697 {
10698 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMdcReplica((int) G__int(libp->para[0])));
10699 return(1 || funcname || hash || result7 || libp) ;
10700 }
10701
10702 static int G__BesVisLib_rootcint_845_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10703 {
10704 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalMdcReplica((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10705 return(1 || funcname || hash || result7 || libp) ;
10706 }
10707
10708 static int G__BesVisLib_rootcint_845_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10709 {
10710 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeTof());
10711 return(1 || funcname || hash || result7 || libp) ;
10712 }
10713
10714 static int G__BesVisLib_rootcint_845_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10715 {
10716 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalTofScin((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10717 , (int) G__int(libp->para[2])));
10718 return(1 || funcname || hash || result7 || libp) ;
10719 }
10720
10721 static int G__BesVisLib_rootcint_845_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10722 {
10723 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmc());
10724 return(1 || funcname || hash || result7 || libp) ;
10725 }
10726
10727 static int G__BesVisLib_rootcint_845_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10728 {
10729 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcPart((int) G__int(libp->para[0])));
10730 return(1 || funcname || hash || result7 || libp) ;
10731 }
10732
10733 static int G__BesVisLib_rootcint_845_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10734 {
10735 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcPhi((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
10736 return(1 || funcname || hash || result7 || libp) ;
10737 }
10738
10739 static int G__BesVisLib_rootcint_845_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10740 {
10741 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcTheta((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10742 , (int) G__int(libp->para[2])));
10743 return(1 || funcname || hash || result7 || libp) ;
10744 }
10745
10746 static int G__BesVisLib_rootcint_845_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10747 {
10748 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeEmcCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10749 , (int) G__int(libp->para[2])));
10750 return(1 || funcname || hash || result7 || libp) ;
10751 }
10752
10753 static int G__BesVisLib_rootcint_845_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10754 {
10755 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalEmcCrystal((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10756 , (int) G__int(libp->para[2])));
10757 return(1 || funcname || hash || result7 || libp) ;
10758 }
10759
10760 static int G__BesVisLib_rootcint_845_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10761 {
10762 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMuc());
10763 return(1 || funcname || hash || result7 || libp) ;
10764 }
10765
10766 static int G__BesVisLib_rootcint_845_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10767 {
10768 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucAbsorber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10769 , (int) G__int(libp->para[2])));
10770 return(1 || funcname || hash || result7 || libp) ;
10771 }
10772
10773 static int G__BesVisLib_rootcint_845_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10774 {
10775 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucAbsorberPanel((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10776 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10777 return(1 || funcname || hash || result7 || libp) ;
10778 }
10779
10780 static int G__BesVisLib_rootcint_845_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10781 {
10782 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10783 , (int) G__int(libp->para[2])));
10784 return(1 || funcname || hash || result7 || libp) ;
10785 }
10786
10787 static int G__BesVisLib_rootcint_845_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10788 {
10789 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucStripPlane((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10790 , (int) G__int(libp->para[2])));
10791 return(1 || funcname || hash || result7 || libp) ;
10792 }
10793
10794 static int G__BesVisLib_rootcint_845_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10795 {
10796 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10797 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10798 return(1 || funcname || hash || result7 || libp) ;
10799 }
10800
10801 static int G__BesVisLib_rootcint_845_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10802 {
10803 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucGasChamber((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10804 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10805 , (int) G__int(libp->para[4])));
10806 return(1 || funcname || hash || result7 || libp) ;
10807 }
10808
10809 static int G__BesVisLib_rootcint_845_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10810 {
10811 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetVolumeMucBakelite((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10812 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
10813 , (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
10814 return(1 || funcname || hash || result7 || libp) ;
10815 }
10816
10817 static int G__BesVisLib_rootcint_845_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10818 {
10819 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalMucGap((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10820 , (int) G__int(libp->para[2])));
10821 return(1 || funcname || hash || result7 || libp) ;
10822 }
10823
10824 static int G__BesVisLib_rootcint_845_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10825 {
10826 G__letint(result7, 85, (long) ((BesGeometry*) G__getstructoffset())->GetPhysicalMucStrip((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
10827 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
10828 return(1 || funcname || hash || result7 || libp) ;
10829 }
10830
10831 static int G__BesVisLib_rootcint_845_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10832 {
10833 G__letint(result7, 85, (long) BesGeometry::Class());
10834 return(1 || funcname || hash || result7 || libp) ;
10835 }
10836
10837 static int G__BesVisLib_rootcint_845_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10838 {
10839 G__letint(result7, 67, (long) BesGeometry::Class_Name());
10840 return(1 || funcname || hash || result7 || libp) ;
10841 }
10842
10843 static int G__BesVisLib_rootcint_845_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10844 {
10845 G__letint(result7, 115, (long) BesGeometry::Class_Version());
10846 return(1 || funcname || hash || result7 || libp) ;
10847 }
10848
10849 static int G__BesVisLib_rootcint_845_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10850 {
10851 BesGeometry::Dictionary();
10852 G__setnull(result7);
10853 return(1 || funcname || hash || result7 || libp) ;
10854 }
10855
10856 static int G__BesVisLib_rootcint_845_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10857 {
10858 ((BesGeometry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10859 G__setnull(result7);
10860 return(1 || funcname || hash || result7 || libp) ;
10861 }
10862
10863 static int G__BesVisLib_rootcint_845_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10864 {
10865 G__letint(result7, 67, (long) BesGeometry::DeclFileName());
10866 return(1 || funcname || hash || result7 || libp) ;
10867 }
10868
10869 static int G__BesVisLib_rootcint_845_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10870 {
10871 G__letint(result7, 105, (long) BesGeometry::ImplFileLine());
10872 return(1 || funcname || hash || result7 || libp) ;
10873 }
10874
10875 static int G__BesVisLib_rootcint_845_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10876 {
10877 G__letint(result7, 67, (long) BesGeometry::ImplFileName());
10878 return(1 || funcname || hash || result7 || libp) ;
10879 }
10880
10881 static int G__BesVisLib_rootcint_845_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10882 {
10883 G__letint(result7, 105, (long) BesGeometry::DeclFileLine());
10884 return(1 || funcname || hash || result7 || libp) ;
10885 }
10886
10887
10888 static int G__BesVisLib_rootcint_845_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10889
10890 {
10891 BesGeometry* p;
10892 void* tmp = (void*) G__int(libp->para[0]);
10893 p = new BesGeometry(*(BesGeometry*) tmp);
10894 result7->obj.i = (long) p;
10895 result7->ref = (long) p;
10896 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
10897 return(1 || funcname || hash || result7 || libp) ;
10898 }
10899
10900
10901 typedef BesGeometry G__TBesGeometry;
10902 static int G__BesVisLib_rootcint_845_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10903 {
10904 char* gvp = (char*) G__getgvp();
10905 long soff = G__getstructoffset();
10906 int n = G__getaryconstruct();
10907
10908
10909
10910
10911
10912 if (!soff) {
10913 return(1);
10914 }
10915 if (n) {
10916 if (gvp == (char*)G__PVOID) {
10917 delete[] (BesGeometry*) soff;
10918 } else {
10919 G__setgvp((long) G__PVOID);
10920 for (int i = n - 1; i >= 0; --i) {
10921 ((BesGeometry*) (soff+(sizeof(BesGeometry)*i)))->~G__TBesGeometry();
10922 }
10923 G__setgvp((long)gvp);
10924 }
10925 } else {
10926 if (gvp == (char*)G__PVOID) {
10927 delete (BesGeometry*) soff;
10928 } else {
10929 G__setgvp((long) G__PVOID);
10930 ((BesGeometry*) (soff))->~G__TBesGeometry();
10931 G__setgvp((long)gvp);
10932 }
10933 }
10934 G__setnull(result7);
10935 return(1 || funcname || hash || result7 || libp) ;
10936 }
10937
10938
10939 static int G__BesVisLib_rootcint_845_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10940 {
10941 BesGeometry* dest = (BesGeometry*) G__getstructoffset();
10942 *dest = *(BesGeometry*) libp->para[0].ref;
10943 const BesGeometry& obj = *dest;
10944 result7->ref = (long) (&obj);
10945 result7->obj.i = (long) (&obj);
10946 return(1 || funcname || hash || result7 || libp) ;
10947 }
10948
10949
10950
10951 static int G__BesVisLib_rootcint_925_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10952 {
10953 BesGMenuTitle* p = NULL;
10954 char* gvp = (char*) G__getgvp();
10955 switch (libp->paran) {
10956 case 6:
10957
10958 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10959 p = new BesGMenuTitle(
10960 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
10961 , (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
10962 , (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
10963 } else {
10964 p = new((void*) gvp) BesGMenuTitle(
10965 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
10966 , (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
10967 , (FontStruct_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
10968 }
10969 break;
10970 case 5:
10971
10972 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10973 p = new BesGMenuTitle(
10974 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
10975 , (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
10976 , (FontStruct_t) G__int(libp->para[4]));
10977 } else {
10978 p = new((void*) gvp) BesGMenuTitle(
10979 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
10980 , (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
10981 , (FontStruct_t) G__int(libp->para[4]));
10982 }
10983 break;
10984 case 4:
10985
10986 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10987 p = new BesGMenuTitle(
10988 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
10989 , (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
10990 } else {
10991 p = new((void*) gvp) BesGMenuTitle(
10992 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
10993 , (TGPopupMenu*) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
10994 }
10995 break;
10996 case 3:
10997
10998 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10999 p = new BesGMenuTitle(
11000 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11001 , (TGPopupMenu*) G__int(libp->para[2]));
11002 } else {
11003 p = new((void*) gvp) BesGMenuTitle(
11004 (TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1])
11005 , (TGPopupMenu*) G__int(libp->para[2]));
11006 }
11007 break;
11008 case 2:
11009
11010 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11011 p = new BesGMenuTitle((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
11012 } else {
11013 p = new((void*) gvp) BesGMenuTitle((TGWindow*) G__int(libp->para[0]), (TGHotString*) G__int(libp->para[1]));
11014 }
11015 break;
11016 case 1:
11017
11018 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11019 p = new BesGMenuTitle((TGWindow*) G__int(libp->para[0]));
11020 } else {
11021 p = new((void*) gvp) BesGMenuTitle((TGWindow*) G__int(libp->para[0]));
11022 }
11023 break;
11024 case 0:
11025 int n = G__getaryconstruct();
11026 if (n) {
11027 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11028 p = new BesGMenuTitle[n];
11029 } else {
11030 p = new((void*) gvp) BesGMenuTitle[n];
11031 }
11032 } else {
11033 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11034 p = new BesGMenuTitle;
11035 } else {
11036 p = new((void*) gvp) BesGMenuTitle;
11037 }
11038 }
11039 break;
11040 }
11041 result7->obj.i = (long) p;
11042 result7->ref = (long) p;
11043 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle));
11044 return(1 || funcname || hash || result7 || libp) ;
11045 }
11046
11047 static int G__BesVisLib_rootcint_925_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11048 {
11049 ((BesGMenuTitle*) G__getstructoffset())->SetPicture((Pixmap_t) G__int(libp->para[0]));
11050 G__setnull(result7);
11051 return(1 || funcname || hash || result7 || libp) ;
11052 }
11053
11054 static int G__BesVisLib_rootcint_925_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11055 {
11056 ((BesGMenuTitle*) G__getstructoffset())->SetPictureHL((Pixmap_t) G__int(libp->para[0]));
11057 G__setnull(result7);
11058 return(1 || funcname || hash || result7 || libp) ;
11059 }
11060
11061 static int G__BesVisLib_rootcint_925_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11062 {
11063 G__letint(result7, 85, (long) BesGMenuTitle::Class());
11064 return(1 || funcname || hash || result7 || libp) ;
11065 }
11066
11067 static int G__BesVisLib_rootcint_925_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11068 {
11069 G__letint(result7, 67, (long) BesGMenuTitle::Class_Name());
11070 return(1 || funcname || hash || result7 || libp) ;
11071 }
11072
11073 static int G__BesVisLib_rootcint_925_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11074 {
11075 G__letint(result7, 115, (long) BesGMenuTitle::Class_Version());
11076 return(1 || funcname || hash || result7 || libp) ;
11077 }
11078
11079 static int G__BesVisLib_rootcint_925_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11080 {
11081 BesGMenuTitle::Dictionary();
11082 G__setnull(result7);
11083 return(1 || funcname || hash || result7 || libp) ;
11084 }
11085
11086 static int G__BesVisLib_rootcint_925_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11087 {
11088 ((BesGMenuTitle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11089 G__setnull(result7);
11090 return(1 || funcname || hash || result7 || libp) ;
11091 }
11092
11093 static int G__BesVisLib_rootcint_925_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11094 {
11095 G__letint(result7, 67, (long) BesGMenuTitle::DeclFileName());
11096 return(1 || funcname || hash || result7 || libp) ;
11097 }
11098
11099 static int G__BesVisLib_rootcint_925_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11100 {
11101 G__letint(result7, 105, (long) BesGMenuTitle::ImplFileLine());
11102 return(1 || funcname || hash || result7 || libp) ;
11103 }
11104
11105 static int G__BesVisLib_rootcint_925_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11106 {
11107 G__letint(result7, 67, (long) BesGMenuTitle::ImplFileName());
11108 return(1 || funcname || hash || result7 || libp) ;
11109 }
11110
11111 static int G__BesVisLib_rootcint_925_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11112 {
11113 G__letint(result7, 105, (long) BesGMenuTitle::DeclFileLine());
11114 return(1 || funcname || hash || result7 || libp) ;
11115 }
11116
11117
11118 typedef BesGMenuTitle G__TBesGMenuTitle;
11119 static int G__BesVisLib_rootcint_925_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11120 {
11121 char* gvp = (char*) G__getgvp();
11122 long soff = G__getstructoffset();
11123 int n = G__getaryconstruct();
11124
11125
11126
11127
11128
11129 if (!soff) {
11130 return(1);
11131 }
11132 if (n) {
11133 if (gvp == (char*)G__PVOID) {
11134 delete[] (BesGMenuTitle*) soff;
11135 } else {
11136 G__setgvp((long) G__PVOID);
11137 for (int i = n - 1; i >= 0; --i) {
11138 ((BesGMenuTitle*) (soff+(sizeof(BesGMenuTitle)*i)))->~G__TBesGMenuTitle();
11139 }
11140 G__setgvp((long)gvp);
11141 }
11142 } else {
11143 if (gvp == (char*)G__PVOID) {
11144 delete (BesGMenuTitle*) soff;
11145 } else {
11146 G__setgvp((long) G__PVOID);
11147 ((BesGMenuTitle*) (soff))->~G__TBesGMenuTitle();
11148 G__setgvp((long)gvp);
11149 }
11150 }
11151 G__setnull(result7);
11152 return(1 || funcname || hash || result7 || libp) ;
11153 }
11154
11155
11156
11157 static int G__BesVisLib_rootcint_926_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11158 {
11159 BesGMenuBar* p = NULL;
11160 char* gvp = (char*) G__getgvp();
11161 switch (libp->paran) {
11162 case 4:
11163
11164 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11165 p = new BesGMenuBar(
11166 (TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11167 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11168 } else {
11169 p = new((void*) gvp) BesGMenuBar(
11170 (TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11171 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11172 }
11173 break;
11174 case 3:
11175
11176 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11177 p = new BesGMenuBar(
11178 (TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11179 , (UInt_t) G__int(libp->para[2]));
11180 } else {
11181 p = new((void*) gvp) BesGMenuBar(
11182 (TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
11183 , (UInt_t) G__int(libp->para[2]));
11184 }
11185 break;
11186 case 2:
11187
11188 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11189 p = new BesGMenuBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
11190 } else {
11191 p = new((void*) gvp) BesGMenuBar((TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
11192 }
11193 break;
11194 case 1:
11195
11196 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11197 p = new BesGMenuBar((TGWindow*) G__int(libp->para[0]));
11198 } else {
11199 p = new((void*) gvp) BesGMenuBar((TGWindow*) G__int(libp->para[0]));
11200 }
11201 break;
11202 case 0:
11203 int n = G__getaryconstruct();
11204 if (n) {
11205 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11206 p = new BesGMenuBar[n];
11207 } else {
11208 p = new((void*) gvp) BesGMenuBar[n];
11209 }
11210 } else {
11211 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11212 p = new BesGMenuBar;
11213 } else {
11214 p = new((void*) gvp) BesGMenuBar;
11215 }
11216 }
11217 break;
11218 }
11219 result7->obj.i = (long) p;
11220 result7->ref = (long) p;
11221 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar));
11222 return(1 || funcname || hash || result7 || libp) ;
11223 }
11224
11225 static int G__BesVisLib_rootcint_926_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11226 {
11227 G__letint(result7, 85, (long) ((BesGMenuBar*) G__getstructoffset())->GetMenuTitle((Int_t) G__int(libp->para[0])));
11228 return(1 || funcname || hash || result7 || libp) ;
11229 }
11230
11231 static int G__BesVisLib_rootcint_926_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11232 {
11233 G__letint(result7, 85, (long) BesGMenuBar::Class());
11234 return(1 || funcname || hash || result7 || libp) ;
11235 }
11236
11237 static int G__BesVisLib_rootcint_926_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11238 {
11239 G__letint(result7, 67, (long) BesGMenuBar::Class_Name());
11240 return(1 || funcname || hash || result7 || libp) ;
11241 }
11242
11243 static int G__BesVisLib_rootcint_926_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11244 {
11245 G__letint(result7, 115, (long) BesGMenuBar::Class_Version());
11246 return(1 || funcname || hash || result7 || libp) ;
11247 }
11248
11249 static int G__BesVisLib_rootcint_926_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11250 {
11251 BesGMenuBar::Dictionary();
11252 G__setnull(result7);
11253 return(1 || funcname || hash || result7 || libp) ;
11254 }
11255
11256 static int G__BesVisLib_rootcint_926_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11257 {
11258 ((BesGMenuBar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11259 G__setnull(result7);
11260 return(1 || funcname || hash || result7 || libp) ;
11261 }
11262
11263 static int G__BesVisLib_rootcint_926_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11264 {
11265 G__letint(result7, 67, (long) BesGMenuBar::DeclFileName());
11266 return(1 || funcname || hash || result7 || libp) ;
11267 }
11268
11269 static int G__BesVisLib_rootcint_926_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11270 {
11271 G__letint(result7, 105, (long) BesGMenuBar::ImplFileLine());
11272 return(1 || funcname || hash || result7 || libp) ;
11273 }
11274
11275 static int G__BesVisLib_rootcint_926_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11276 {
11277 G__letint(result7, 67, (long) BesGMenuBar::ImplFileName());
11278 return(1 || funcname || hash || result7 || libp) ;
11279 }
11280
11281 static int G__BesVisLib_rootcint_926_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11282 {
11283 G__letint(result7, 105, (long) BesGMenuBar::DeclFileLine());
11284 return(1 || funcname || hash || result7 || libp) ;
11285 }
11286
11287
11288 typedef BesGMenuBar G__TBesGMenuBar;
11289 static int G__BesVisLib_rootcint_926_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11290 {
11291 char* gvp = (char*) G__getgvp();
11292 long soff = G__getstructoffset();
11293 int n = G__getaryconstruct();
11294
11295
11296
11297
11298
11299 if (!soff) {
11300 return(1);
11301 }
11302 if (n) {
11303 if (gvp == (char*)G__PVOID) {
11304 delete[] (BesGMenuBar*) soff;
11305 } else {
11306 G__setgvp((long) G__PVOID);
11307 for (int i = n - 1; i >= 0; --i) {
11308 ((BesGMenuBar*) (soff+(sizeof(BesGMenuBar)*i)))->~G__TBesGMenuBar();
11309 }
11310 G__setgvp((long)gvp);
11311 }
11312 } else {
11313 if (gvp == (char*)G__PVOID) {
11314 delete (BesGMenuBar*) soff;
11315 } else {
11316 G__setgvp((long) G__PVOID);
11317 ((BesGMenuBar*) (soff))->~G__TBesGMenuBar();
11318 G__setgvp((long)gvp);
11319 }
11320 }
11321 G__setnull(result7);
11322 return(1 || funcname || hash || result7 || libp) ;
11323 }
11324
11325
11326
11327 static int G__BesVisLib_rootcint_934_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11328 {
11329 BesGPictureButton* p = NULL;
11330 char* gvp = (char*) G__getgvp();
11331 switch (libp->paran) {
11332 case 5:
11333
11334 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11335 p = new BesGPictureButton(
11336 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11337 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11338 , (UInt_t) G__int(libp->para[4]));
11339 } else {
11340 p = new((void*) gvp) BesGPictureButton(
11341 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11342 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11343 , (UInt_t) G__int(libp->para[4]));
11344 }
11345 break;
11346 case 4:
11347
11348 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11349 p = new BesGPictureButton(
11350 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11351 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11352 } else {
11353 p = new((void*) gvp) BesGPictureButton(
11354 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11355 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11356 }
11357 break;
11358 case 3:
11359
11360 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11361 p = new BesGPictureButton(
11362 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11363 , (Int_t) G__int(libp->para[2]));
11364 } else {
11365 p = new((void*) gvp) BesGPictureButton(
11366 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11367 , (Int_t) G__int(libp->para[2]));
11368 }
11369 break;
11370 case 2:
11371
11372 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11373 p = new BesGPictureButton((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
11374 } else {
11375 p = new((void*) gvp) BesGPictureButton((TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1]));
11376 }
11377 break;
11378 }
11379 result7->obj.i = (long) p;
11380 result7->ref = (long) p;
11381 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
11382 return(1 || funcname || hash || result7 || libp) ;
11383 }
11384
11385 static int G__BesVisLib_rootcint_934_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11386 {
11387 BesGPictureButton* p = NULL;
11388 char* gvp = (char*) G__getgvp();
11389 switch (libp->paran) {
11390 case 6:
11391
11392 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11393 p = new BesGPictureButton(
11394 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11395 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11396 , (GContext_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
11397 } else {
11398 p = new((void*) gvp) BesGPictureButton(
11399 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11400 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11401 , (GContext_t) G__int(libp->para[4]), (UInt_t) G__int(libp->para[5]));
11402 }
11403 break;
11404 case 5:
11405
11406 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11407 p = new BesGPictureButton(
11408 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11409 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11410 , (GContext_t) G__int(libp->para[4]));
11411 } else {
11412 p = new((void*) gvp) BesGPictureButton(
11413 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11414 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11415 , (GContext_t) G__int(libp->para[4]));
11416 }
11417 break;
11418 case 4:
11419
11420 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11421 p = new BesGPictureButton(
11422 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11423 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
11424 } else {
11425 p = new((void*) gvp) BesGPictureButton(
11426 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11427 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
11428 }
11429 break;
11430 case 3:
11431
11432 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11433 p = new BesGPictureButton(
11434 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11435 , (const char*) G__int(libp->para[2]));
11436 } else {
11437 p = new((void*) gvp) BesGPictureButton(
11438 (TGWindow*) G__int(libp->para[0]), (TGPicture*) G__int(libp->para[1])
11439 , (const char*) G__int(libp->para[2]));
11440 }
11441 break;
11442 }
11443 result7->obj.i = (long) p;
11444 result7->ref = (long) p;
11445 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
11446 return(1 || funcname || hash || result7 || libp) ;
11447 }
11448
11449 static int G__BesVisLib_rootcint_934_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11450 {
11451 BesGPictureButton* p = NULL;
11452 char* gvp = (char*) G__getgvp();
11453 switch (libp->paran) {
11454 case 5:
11455
11456 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11457 p = new BesGPictureButton(
11458 (TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11459 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11460 , (UInt_t) G__int(libp->para[4]));
11461 } else {
11462 p = new((void*) gvp) BesGPictureButton(
11463 (TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11464 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3])
11465 , (UInt_t) G__int(libp->para[4]));
11466 }
11467 break;
11468 case 4:
11469
11470 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11471 p = new BesGPictureButton(
11472 (TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11473 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11474 } else {
11475 p = new((void*) gvp) BesGPictureButton(
11476 (TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11477 , (Int_t) G__int(libp->para[2]), (GContext_t) G__int(libp->para[3]));
11478 }
11479 break;
11480 case 3:
11481
11482 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11483 p = new BesGPictureButton(
11484 (TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11485 , (Int_t) G__int(libp->para[2]));
11486 } else {
11487 p = new((void*) gvp) BesGPictureButton(
11488 (TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11489 , (Int_t) G__int(libp->para[2]));
11490 }
11491 break;
11492 case 2:
11493
11494 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11495 p = new BesGPictureButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
11496 } else {
11497 p = new((void*) gvp) BesGPictureButton((TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
11498 }
11499 break;
11500 case 1:
11501
11502 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11503 p = new BesGPictureButton((TGWindow*) G__int(libp->para[0]));
11504 } else {
11505 p = new((void*) gvp) BesGPictureButton((TGWindow*) G__int(libp->para[0]));
11506 }
11507 break;
11508 case 0:
11509 int n = G__getaryconstruct();
11510 if (n) {
11511 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11512 p = new BesGPictureButton[n];
11513 } else {
11514 p = new((void*) gvp) BesGPictureButton[n];
11515 }
11516 } else {
11517 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11518 p = new BesGPictureButton;
11519 } else {
11520 p = new((void*) gvp) BesGPictureButton;
11521 }
11522 }
11523 break;
11524 }
11525 result7->obj.i = (long) p;
11526 result7->ref = (long) p;
11527 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
11528 return(1 || funcname || hash || result7 || libp) ;
11529 }
11530
11531 static int G__BesVisLib_rootcint_934_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11532 {
11533 G__letint(result7, 103, (long) ((BesGPictureButton*) G__getstructoffset())->IsStateOn());
11534 return(1 || funcname || hash || result7 || libp) ;
11535 }
11536
11537 static int G__BesVisLib_rootcint_934_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11538 {
11539 ((BesGPictureButton*) G__getstructoffset())->SetState((Bool_t) G__int(libp->para[0]));
11540 G__setnull(result7);
11541 return(1 || funcname || hash || result7 || libp) ;
11542 }
11543
11544 static int G__BesVisLib_rootcint_934_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11545 {
11546 ((BesGPictureButton*) G__getstructoffset())->SetPictureHL((TGPicture*) G__int(libp->para[0]));
11547 G__setnull(result7);
11548 return(1 || funcname || hash || result7 || libp) ;
11549 }
11550
11551 static int G__BesVisLib_rootcint_934_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11552 {
11553 G__letint(result7, 85, (long) BesGPictureButton::Class());
11554 return(1 || funcname || hash || result7 || libp) ;
11555 }
11556
11557 static int G__BesVisLib_rootcint_934_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11558 {
11559 G__letint(result7, 67, (long) BesGPictureButton::Class_Name());
11560 return(1 || funcname || hash || result7 || libp) ;
11561 }
11562
11563 static int G__BesVisLib_rootcint_934_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11564 {
11565 G__letint(result7, 115, (long) BesGPictureButton::Class_Version());
11566 return(1 || funcname || hash || result7 || libp) ;
11567 }
11568
11569 static int G__BesVisLib_rootcint_934_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11570 {
11571 BesGPictureButton::Dictionary();
11572 G__setnull(result7);
11573 return(1 || funcname || hash || result7 || libp) ;
11574 }
11575
11576 static int G__BesVisLib_rootcint_934_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11577 {
11578 ((BesGPictureButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11579 G__setnull(result7);
11580 return(1 || funcname || hash || result7 || libp) ;
11581 }
11582
11583 static int G__BesVisLib_rootcint_934_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11584 {
11585 G__letint(result7, 67, (long) BesGPictureButton::DeclFileName());
11586 return(1 || funcname || hash || result7 || libp) ;
11587 }
11588
11589 static int G__BesVisLib_rootcint_934_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11590 {
11591 G__letint(result7, 105, (long) BesGPictureButton::ImplFileLine());
11592 return(1 || funcname || hash || result7 || libp) ;
11593 }
11594
11595 static int G__BesVisLib_rootcint_934_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11596 {
11597 G__letint(result7, 67, (long) BesGPictureButton::ImplFileName());
11598 return(1 || funcname || hash || result7 || libp) ;
11599 }
11600
11601 static int G__BesVisLib_rootcint_934_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11602 {
11603 G__letint(result7, 105, (long) BesGPictureButton::DeclFileLine());
11604 return(1 || funcname || hash || result7 || libp) ;
11605 }
11606
11607
11608 typedef BesGPictureButton G__TBesGPictureButton;
11609 static int G__BesVisLib_rootcint_934_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11610 {
11611 char* gvp = (char*) G__getgvp();
11612 long soff = G__getstructoffset();
11613 int n = G__getaryconstruct();
11614
11615
11616
11617
11618
11619 if (!soff) {
11620 return(1);
11621 }
11622 if (n) {
11623 if (gvp == (char*)G__PVOID) {
11624 delete[] (BesGPictureButton*) soff;
11625 } else {
11626 G__setgvp((long) G__PVOID);
11627 for (int i = n - 1; i >= 0; --i) {
11628 ((BesGPictureButton*) (soff+(sizeof(BesGPictureButton)*i)))->~G__TBesGPictureButton();
11629 }
11630 G__setgvp((long)gvp);
11631 }
11632 } else {
11633 if (gvp == (char*)G__PVOID) {
11634 delete (BesGPictureButton*) soff;
11635 } else {
11636 G__setgvp((long) G__PVOID);
11637 ((BesGPictureButton*) (soff))->~G__TBesGPictureButton();
11638 G__setgvp((long)gvp);
11639 }
11640 }
11641 G__setnull(result7);
11642 return(1 || funcname || hash || result7 || libp) ;
11643 }
11644
11645
11646
11647 static int G__BesVisLib_rootcint_935_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11648 {
11649 BesHeader* p = NULL;
11650 char* gvp = (char*) G__getgvp();
11651 int n = G__getaryconstruct();
11652 if (n) {
11653 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11654 p = new BesHeader[n];
11655 } else {
11656 p = new((void*) gvp) BesHeader[n];
11657 }
11658 } else {
11659 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11660 p = new BesHeader;
11661 } else {
11662 p = new((void*) gvp) BesHeader;
11663 }
11664 }
11665 result7->obj.i = (long) p;
11666 result7->ref = (long) p;
11667 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
11668 return(1 || funcname || hash || result7 || libp) ;
11669 }
11670
11671 static int G__BesVisLib_rootcint_935_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11672 {
11673 BesHeader* p = NULL;
11674 char* gvp = (char*) G__getgvp();
11675
11676 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11677 p = new BesHeader(
11678 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
11679 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
11680 , (Option_t*) G__int(libp->para[4]));
11681 } else {
11682 p = new((void*) gvp) BesHeader(
11683 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
11684 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
11685 , (Option_t*) G__int(libp->para[4]));
11686 }
11687 result7->obj.i = (long) p;
11688 result7->ref = (long) p;
11689 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
11690 return(1 || funcname || hash || result7 || libp) ;
11691 }
11692
11693 static int G__BesVisLib_rootcint_935_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11694 {
11695 ((BesHeader*) G__getstructoffset())->SetMdcOn((Bool_t) G__int(libp->para[0]));
11696 G__setnull(result7);
11697 return(1 || funcname || hash || result7 || libp) ;
11698 }
11699
11700 static int G__BesVisLib_rootcint_935_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11701 {
11702 G__letint(result7, 103, (long) ((BesHeader*) G__getstructoffset())->GetMdcOn());
11703 return(1 || funcname || hash || result7 || libp) ;
11704 }
11705
11706 static int G__BesVisLib_rootcint_935_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11707 {
11708 ((BesHeader*) G__getstructoffset())->TransferMdcOn((Bool_t) G__int(libp->para[0]));
11709 G__setnull(result7);
11710 return(1 || funcname || hash || result7 || libp) ;
11711 }
11712
11713 static int G__BesVisLib_rootcint_935_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11714 {
11715 ((BesHeader*) G__getstructoffset())->SetTofOn((Bool_t) G__int(libp->para[0]));
11716 G__setnull(result7);
11717 return(1 || funcname || hash || result7 || libp) ;
11718 }
11719
11720 static int G__BesVisLib_rootcint_935_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11721 {
11722 G__letint(result7, 103, (long) ((BesHeader*) G__getstructoffset())->GetTofOn());
11723 return(1 || funcname || hash || result7 || libp) ;
11724 }
11725
11726 static int G__BesVisLib_rootcint_935_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11727 {
11728 ((BesHeader*) G__getstructoffset())->TransferTofOn((Bool_t) G__int(libp->para[0]));
11729 G__setnull(result7);
11730 return(1 || funcname || hash || result7 || libp) ;
11731 }
11732
11733 static int G__BesVisLib_rootcint_935_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11734 {
11735 ((BesHeader*) G__getstructoffset())->SetEmcOn((Bool_t) G__int(libp->para[0]));
11736 G__setnull(result7);
11737 return(1 || funcname || hash || result7 || libp) ;
11738 }
11739
11740 static int G__BesVisLib_rootcint_935_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11741 {
11742 G__letint(result7, 103, (long) ((BesHeader*) G__getstructoffset())->GetEmcOn());
11743 return(1 || funcname || hash || result7 || libp) ;
11744 }
11745
11746 static int G__BesVisLib_rootcint_935_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11747 {
11748 ((BesHeader*) G__getstructoffset())->TransferEmcOn((Bool_t) G__int(libp->para[0]));
11749 G__setnull(result7);
11750 return(1 || funcname || hash || result7 || libp) ;
11751 }
11752
11753 static int G__BesVisLib_rootcint_935_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11754 {
11755 ((BesHeader*) G__getstructoffset())->DrawClass();
11756 G__setnull(result7);
11757 return(1 || funcname || hash || result7 || libp) ;
11758 }
11759
11760 static int G__BesVisLib_rootcint_935_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11761 {
11762 switch (libp->paran) {
11763 case 1:
11764 G__letint(result7, 85, (long) ((BesHeader*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0])));
11765 break;
11766 case 0:
11767 G__letint(result7, 85, (long) ((BesHeader*) G__getstructoffset())->DrawClone());
11768 break;
11769 }
11770 return(1 || funcname || hash || result7 || libp) ;
11771 }
11772
11773 static int G__BesVisLib_rootcint_935_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11774 {
11775 ((BesHeader*) G__getstructoffset())->Dump();
11776 G__setnull(result7);
11777 return(1 || funcname || hash || result7 || libp) ;
11778 }
11779
11780 static int G__BesVisLib_rootcint_935_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11781 {
11782 ((BesHeader*) G__getstructoffset())->Inspect();
11783 G__setnull(result7);
11784 return(1 || funcname || hash || result7 || libp) ;
11785 }
11786
11787 static int G__BesVisLib_rootcint_935_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11788 {
11789 G__letint(result7, 85, (long) BesHeader::Class());
11790 return(1 || funcname || hash || result7 || libp) ;
11791 }
11792
11793 static int G__BesVisLib_rootcint_935_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11794 {
11795 G__letint(result7, 67, (long) BesHeader::Class_Name());
11796 return(1 || funcname || hash || result7 || libp) ;
11797 }
11798
11799 static int G__BesVisLib_rootcint_935_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11800 {
11801 G__letint(result7, 115, (long) BesHeader::Class_Version());
11802 return(1 || funcname || hash || result7 || libp) ;
11803 }
11804
11805 static int G__BesVisLib_rootcint_935_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11806 {
11807 BesHeader::Dictionary();
11808 G__setnull(result7);
11809 return(1 || funcname || hash || result7 || libp) ;
11810 }
11811
11812 static int G__BesVisLib_rootcint_935_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11813 {
11814 ((BesHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11815 G__setnull(result7);
11816 return(1 || funcname || hash || result7 || libp) ;
11817 }
11818
11819 static int G__BesVisLib_rootcint_935_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11820 {
11821 G__letint(result7, 67, (long) BesHeader::DeclFileName());
11822 return(1 || funcname || hash || result7 || libp) ;
11823 }
11824
11825 static int G__BesVisLib_rootcint_935_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11826 {
11827 G__letint(result7, 105, (long) BesHeader::ImplFileLine());
11828 return(1 || funcname || hash || result7 || libp) ;
11829 }
11830
11831 static int G__BesVisLib_rootcint_935_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11832 {
11833 G__letint(result7, 67, (long) BesHeader::ImplFileName());
11834 return(1 || funcname || hash || result7 || libp) ;
11835 }
11836
11837 static int G__BesVisLib_rootcint_935_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11838 {
11839 G__letint(result7, 105, (long) BesHeader::DeclFileLine());
11840 return(1 || funcname || hash || result7 || libp) ;
11841 }
11842
11843
11844 typedef BesHeader G__TBesHeader;
11845 static int G__BesVisLib_rootcint_935_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11846 {
11847 char* gvp = (char*) G__getgvp();
11848 long soff = G__getstructoffset();
11849 int n = G__getaryconstruct();
11850
11851
11852
11853
11854
11855 if (!soff) {
11856 return(1);
11857 }
11858 if (n) {
11859 if (gvp == (char*)G__PVOID) {
11860 delete[] (BesHeader*) soff;
11861 } else {
11862 G__setgvp((long) G__PVOID);
11863 for (int i = n - 1; i >= 0; --i) {
11864 ((BesHeader*) (soff+(sizeof(BesHeader)*i)))->~G__TBesHeader();
11865 }
11866 G__setgvp((long)gvp);
11867 }
11868 } else {
11869 if (gvp == (char*)G__PVOID) {
11870 delete (BesHeader*) soff;
11871 } else {
11872 G__setgvp((long) G__PVOID);
11873 ((BesHeader*) (soff))->~G__TBesHeader();
11874 G__setgvp((long)gvp);
11875 }
11876 }
11877 G__setnull(result7);
11878 return(1 || funcname || hash || result7 || libp) ;
11879 }
11880
11881
11882
11883 static int G__BesVisLib_rootcint_957_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11884 {
11885 BesVisDisplay* p = NULL;
11886 char* gvp = (char*) G__getgvp();
11887 int n = G__getaryconstruct();
11888 if (n) {
11889 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11890 p = new BesVisDisplay[n];
11891 } else {
11892 p = new((void*) gvp) BesVisDisplay[n];
11893 }
11894 } else {
11895 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11896 p = new BesVisDisplay;
11897 } else {
11898 p = new((void*) gvp) BesVisDisplay;
11899 }
11900 }
11901 result7->obj.i = (long) p;
11902 result7->ref = (long) p;
11903 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
11904 return(1 || funcname || hash || result7 || libp) ;
11905 }
11906
11907 static int G__BesVisLib_rootcint_957_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11908 {
11909 BesVisDisplay* p = NULL;
11910 char* gvp = (char*) G__getgvp();
11911
11912 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11913 p = new BesVisDisplay((const char*) G__int(libp->para[0]));
11914 } else {
11915 p = new((void*) gvp) BesVisDisplay((const char*) G__int(libp->para[0]));
11916 }
11917 result7->obj.i = (long) p;
11918 result7->ref = (long) p;
11919 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
11920 return(1 || funcname || hash || result7 || libp) ;
11921 }
11922
11923 static int G__BesVisLib_rootcint_957_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11924 {
11925 switch (libp->paran) {
11926 case 1:
11927 ((BesVisDisplay*) G__getstructoffset())->SetCanvas((TCanvas*) G__int(libp->para[0]));
11928 G__setnull(result7);
11929 break;
11930 case 0:
11931 ((BesVisDisplay*) G__getstructoffset())->SetCanvas();
11932 G__setnull(result7);
11933 break;
11934 }
11935 return(1 || funcname || hash || result7 || libp) ;
11936 }
11937
11938 static int G__BesVisLib_rootcint_957_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11939 {
11940 ((BesVisDisplay*) G__getstructoffset())->SetDisplayMode((Int_t) G__int(libp->para[0]));
11941 G__setnull(result7);
11942 return(1 || funcname || hash || result7 || libp) ;
11943 }
11944
11945 static int G__BesVisLib_rootcint_957_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11946 {
11947 G__letint(result7, 105, (long) ((BesVisDisplay*) G__getstructoffset())->GetDisplayMode());
11948 return(1 || funcname || hash || result7 || libp) ;
11949 }
11950
11951 static int G__BesVisLib_rootcint_957_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11952 {
11953 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->IsVHeader());
11954 return(1 || funcname || hash || result7 || libp) ;
11955 }
11956
11957 static int G__BesVisLib_rootcint_957_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11958 {
11959 ((BesVisDisplay*) G__getstructoffset())->SwitchDisplayMode((Int_t) G__int(libp->para[0]));
11960 G__setnull(result7);
11961 return(1 || funcname || hash || result7 || libp) ;
11962 }
11963
11964 static int G__BesVisLib_rootcint_957_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11965 {
11966 ((BesVisDisplay*) G__getstructoffset())->ResizePad();
11967 G__setnull(result7);
11968 return(1 || funcname || hash || result7 || libp) ;
11969 }
11970
11971 static int G__BesVisLib_rootcint_957_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11972 {
11973 ((BesVisDisplay*) G__getstructoffset())->SwitchPad();
11974 G__setnull(result7);
11975 return(1 || funcname || hash || result7 || libp) ;
11976 }
11977
11978 static int G__BesVisLib_rootcint_957_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11979 {
11980 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetPadXY());
11981 return(1 || funcname || hash || result7 || libp) ;
11982 }
11983
11984 static int G__BesVisLib_rootcint_957_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11985 {
11986 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetPadZR());
11987 return(1 || funcname || hash || result7 || libp) ;
11988 }
11989
11990 static int G__BesVisLib_rootcint_957_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11991 {
11992 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetPad3D());
11993 return(1 || funcname || hash || result7 || libp) ;
11994 }
11995
11996 static int G__BesVisLib_rootcint_957_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11997 {
11998 ((BesVisDisplay*) G__getstructoffset())->DrawHeader();
11999 G__setnull(result7);
12000 return(1 || funcname || hash || result7 || libp) ;
12001 }
12002
12003 static int G__BesVisLib_rootcint_957_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12004 {
12005 ((BesVisDisplay*) G__getstructoffset())->Reset();
12006 G__setnull(result7);
12007 return(1 || funcname || hash || result7 || libp) ;
12008 }
12009
12010 static int G__BesVisLib_rootcint_957_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12011 {
12012 ((BesVisDisplay*) G__getstructoffset())->InitGeometryFromGDML(*((const TString*) G__int(libp->para[0])));
12013 G__setnull(result7);
12014 return(1 || funcname || hash || result7 || libp) ;
12015 }
12016
12017 static int G__BesVisLib_rootcint_957_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12018 {
12019 ((BesVisDisplay*) G__getstructoffset())->InitGeometryFromROOT((TGeoVolume*) G__int(libp->para[0]));
12020 G__setnull(result7);
12021 return(1 || funcname || hash || result7 || libp) ;
12022 }
12023
12024 static int G__BesVisLib_rootcint_957_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12025 {
12026 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetBesGeometry());
12027 return(1 || funcname || hash || result7 || libp) ;
12028 }
12029
12030 static int G__BesVisLib_rootcint_957_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12031 {
12032 ((BesVisDisplay*) G__getstructoffset())->SetMdcOn((Bool_t) G__int(libp->para[0]));
12033 G__setnull(result7);
12034 return(1 || funcname || hash || result7 || libp) ;
12035 }
12036
12037 static int G__BesVisLib_rootcint_957_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12038 {
12039 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->GetMdcOn());
12040 return(1 || funcname || hash || result7 || libp) ;
12041 }
12042
12043 static int G__BesVisLib_rootcint_957_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12044 {
12045 ((BesVisDisplay*) G__getstructoffset())->SetTofOn((Bool_t) G__int(libp->para[0]));
12046 G__setnull(result7);
12047 return(1 || funcname || hash || result7 || libp) ;
12048 }
12049
12050 static int G__BesVisLib_rootcint_957_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12051 {
12052 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->GetTofOn());
12053 return(1 || funcname || hash || result7 || libp) ;
12054 }
12055
12056 static int G__BesVisLib_rootcint_957_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12057 {
12058 ((BesVisDisplay*) G__getstructoffset())->SetEmcOn((Bool_t) G__int(libp->para[0]));
12059 G__setnull(result7);
12060 return(1 || funcname || hash || result7 || libp) ;
12061 }
12062
12063 static int G__BesVisLib_rootcint_957_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12064 {
12065 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->GetEmcOn());
12066 return(1 || funcname || hash || result7 || libp) ;
12067 }
12068
12069 static int G__BesVisLib_rootcint_957_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12070 {
12071 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->AllViews());
12072 return(1 || funcname || hash || result7 || libp) ;
12073 }
12074
12075 static int G__BesVisLib_rootcint_957_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12076 {
12077 switch (libp->paran) {
12078 case 1:
12079 ((BesVisDisplay*) G__getstructoffset())->Clear((Option_t*) G__int(libp->para[0]));
12080 G__setnull(result7);
12081 break;
12082 case 0:
12083 ((BesVisDisplay*) G__getstructoffset())->Clear();
12084 G__setnull(result7);
12085 break;
12086 }
12087 return(1 || funcname || hash || result7 || libp) ;
12088 }
12089
12090 static int G__BesVisLib_rootcint_957_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12091 {
12092 ((BesVisDisplay*) G__getstructoffset())->DisplayTrigger((Int_t) G__int(libp->para[0]));
12093 G__setnull(result7);
12094 return(1 || funcname || hash || result7 || libp) ;
12095 }
12096
12097 static int G__BesVisLib_rootcint_957_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12098 {
12099 G__letint(result7, 105, (long) ((BesVisDisplay*) G__getstructoffset())->DistancetoPrimitive((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
12100 return(1 || funcname || hash || result7 || libp) ;
12101 }
12102
12103 static int G__BesVisLib_rootcint_957_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12104 {
12105 switch (libp->paran) {
12106 case 1:
12107 ((BesVisDisplay*) G__getstructoffset())->Draw((Option_t*) G__int(libp->para[0]));
12108 G__setnull(result7);
12109 break;
12110 case 0:
12111 ((BesVisDisplay*) G__getstructoffset())->Draw();
12112 G__setnull(result7);
12113 break;
12114 }
12115 return(1 || funcname || hash || result7 || libp) ;
12116 }
12117
12118 static int G__BesVisLib_rootcint_957_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12119 {
12120 switch (libp->paran) {
12121 case 1:
12122 ((BesVisDisplay*) G__getstructoffset())->Draw2D((Option_t*) G__int(libp->para[0]));
12123 G__setnull(result7);
12124 break;
12125 case 0:
12126 ((BesVisDisplay*) G__getstructoffset())->Draw2D();
12127 G__setnull(result7);
12128 break;
12129 }
12130 return(1 || funcname || hash || result7 || libp) ;
12131 }
12132
12133 static int G__BesVisLib_rootcint_957_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12134 {
12135 switch (libp->paran) {
12136 case 1:
12137 ((BesVisDisplay*) G__getstructoffset())->Draw3D((Option_t*) G__int(libp->para[0]));
12138 G__setnull(result7);
12139 break;
12140 case 0:
12141 ((BesVisDisplay*) G__getstructoffset())->Draw3D();
12142 G__setnull(result7);
12143 break;
12144 }
12145 return(1 || funcname || hash || result7 || libp) ;
12146 }
12147
12148 static int G__BesVisLib_rootcint_957_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12149 {
12150 switch (libp->paran) {
12151 case 1:
12152 ((BesVisDisplay*) G__getstructoffset())->Draw2DXY((Option_t*) G__int(libp->para[0]));
12153 G__setnull(result7);
12154 break;
12155 case 0:
12156 ((BesVisDisplay*) G__getstructoffset())->Draw2DXY();
12157 G__setnull(result7);
12158 break;
12159 }
12160 return(1 || funcname || hash || result7 || libp) ;
12161 }
12162
12163 static int G__BesVisLib_rootcint_957_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12164 {
12165 switch (libp->paran) {
12166 case 1:
12167 ((BesVisDisplay*) G__getstructoffset())->Draw2DZR((Option_t*) G__int(libp->para[0]));
12168 G__setnull(result7);
12169 break;
12170 case 0:
12171 ((BesVisDisplay*) G__getstructoffset())->Draw2DZR();
12172 G__setnull(result7);
12173 break;
12174 }
12175 return(1 || funcname || hash || result7 || libp) ;
12176 }
12177
12178 static int G__BesVisLib_rootcint_957_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12179 {
12180 ((BesVisDisplay*) G__getstructoffset())->DrawAllViews();
12181 G__setnull(result7);
12182 return(1 || funcname || hash || result7 || libp) ;
12183 }
12184
12185 static int G__BesVisLib_rootcint_957_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12186 {
12187 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->DrawClusters());
12188 return(1 || funcname || hash || result7 || libp) ;
12189 }
12190
12191 static int G__BesVisLib_rootcint_957_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12192 {
12193 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->DrawParticles());
12194 return(1 || funcname || hash || result7 || libp) ;
12195 }
12196
12197 static int G__BesVisLib_rootcint_957_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12198 {
12199 G__letint(result7, 103, (long) ((BesVisDisplay*) G__getstructoffset())->DrawParticles2());
12200 return(1 || funcname || hash || result7 || libp) ;
12201 }
12202
12203 static int G__BesVisLib_rootcint_957_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12204 {
12205 switch (libp->paran) {
12206 case 1:
12207 ((BesVisDisplay*) G__getstructoffset())->DrawTitle((Option_t*) G__int(libp->para[0]));
12208 G__setnull(result7);
12209 break;
12210 case 0:
12211 ((BesVisDisplay*) G__getstructoffset())->DrawTitle();
12212 G__setnull(result7);
12213 break;
12214 }
12215 return(1 || funcname || hash || result7 || libp) ;
12216 }
12217
12218 static int G__BesVisLib_rootcint_957_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12219 {
12220 ((BesVisDisplay*) G__getstructoffset())->DrawView((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
12221 G__setnull(result7);
12222 return(1 || funcname || hash || result7 || libp) ;
12223 }
12224
12225 static int G__BesVisLib_rootcint_957_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12226 {
12227 ((BesVisDisplay*) G__getstructoffset())->DrawViewRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12228 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
12229 G__setnull(result7);
12230 return(1 || funcname || hash || result7 || libp) ;
12231 }
12232
12233 static int G__BesVisLib_rootcint_957_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12234 {
12235 ((BesVisDisplay*) G__getstructoffset())->DrawViewGL();
12236 G__setnull(result7);
12237 return(1 || funcname || hash || result7 || libp) ;
12238 }
12239
12240 static int G__BesVisLib_rootcint_957_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12241 {
12242 ((BesVisDisplay*) G__getstructoffset())->DrawViewX3D();
12243 G__setnull(result7);
12244 return(1 || funcname || hash || result7 || libp) ;
12245 }
12246
12247 static int G__BesVisLib_rootcint_957_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12248 {
12249 ((BesVisDisplay*) G__getstructoffset())->DrawViewRaytracer((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
12250 , (Float_t) G__double(libp->para[2]));
12251 G__setnull(result7);
12252 return(1 || funcname || hash || result7 || libp) ;
12253 }
12254
12255 static int G__BesVisLib_rootcint_957_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12256 {
12257 ((BesVisDisplay*) G__getstructoffset())->DrawViewX3D((char) G__int(libp->para[0]));
12258 G__setnull(result7);
12259 return(1 || funcname || hash || result7 || libp) ;
12260 }
12261
12262 static int G__BesVisLib_rootcint_957_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12263 {
12264 ((BesVisDisplay*) G__getstructoffset())->DrawImageSequence((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
12265 G__setnull(result7);
12266 return(1 || funcname || hash || result7 || libp) ;
12267 }
12268
12269 static int G__BesVisLib_rootcint_957_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12270 {
12271 ((BesVisDisplay*) G__getstructoffset())->ExecuteEvent((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12272 , (Int_t) G__int(libp->para[2]));
12273 G__setnull(result7);
12274 return(1 || funcname || hash || result7 || libp) ;
12275 }
12276
12277 static int G__BesVisLib_rootcint_957_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12278 {
12279 ((BesVisDisplay*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0]));
12280 G__setnull(result7);
12281 return(1 || funcname || hash || result7 || libp) ;
12282 }
12283
12284 static int G__BesVisLib_rootcint_957_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12285 {
12286 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetVolBes());
12287 return(1 || funcname || hash || result7 || libp) ;
12288 }
12289
12290 static int G__BesVisLib_rootcint_957_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12291 {
12292 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetMdcROOTGeo());
12293 return(1 || funcname || hash || result7 || libp) ;
12294 }
12295
12296 static int G__BesVisLib_rootcint_957_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12297 {
12298 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetTofROOTGeo());
12299 return(1 || funcname || hash || result7 || libp) ;
12300 }
12301
12302 static int G__BesVisLib_rootcint_957_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12303 {
12304 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetEmcROOTGeo());
12305 return(1 || funcname || hash || result7 || libp) ;
12306 }
12307
12308 static int G__BesVisLib_rootcint_957_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12309 {
12310 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->GetMucROOTGeo());
12311 return(1 || funcname || hash || result7 || libp) ;
12312 }
12313
12314 static int G__BesVisLib_rootcint_957_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12315 {
12316 ((BesVisDisplay*) G__getstructoffset())->Init();
12317 G__setnull(result7);
12318 return(1 || funcname || hash || result7 || libp) ;
12319 }
12320
12321 static int G__BesVisLib_rootcint_957_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12322 {
12323 G__letint(result7, 85, (long) ((BesVisDisplay*) G__getstructoffset())->Pad());
12324 return(1 || funcname || hash || result7 || libp) ;
12325 }
12326
12327 static int G__BesVisLib_rootcint_957_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12328 {
12329 switch (libp->paran) {
12330 case 1:
12331 ((BesVisDisplay*) G__getstructoffset())->Paint((Option_t*) G__int(libp->para[0]));
12332 G__setnull(result7);
12333 break;
12334 case 0:
12335 ((BesVisDisplay*) G__getstructoffset())->Paint();
12336 G__setnull(result7);
12337 break;
12338 }
12339 return(1 || funcname || hash || result7 || libp) ;
12340 }
12341
12342 static int G__BesVisLib_rootcint_957_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12343 {
12344 switch (libp->paran) {
12345 case 6:
12346 ((BesVisDisplay*) G__getstructoffset())->PaintFruit((TObject*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
12347 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
12348 , (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
12349 G__setnull(result7);
12350 break;
12351 case 5:
12352 ((BesVisDisplay*) G__getstructoffset())->PaintFruit((TObject*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
12353 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
12354 , (Int_t) G__int(libp->para[4]));
12355 G__setnull(result7);
12356 break;
12357 }
12358 return(1 || funcname || hash || result7 || libp) ;
12359 }
12360
12361 static int G__BesVisLib_rootcint_957_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12362 {
12363 switch (libp->paran) {
12364 case 1:
12365 ((BesVisDisplay*) G__getstructoffset())->PaintParticles((Option_t*) G__int(libp->para[0]));
12366 G__setnull(result7);
12367 break;
12368 case 0:
12369 ((BesVisDisplay*) G__getstructoffset())->PaintParticles();
12370 G__setnull(result7);
12371 break;
12372 }
12373 return(1 || funcname || hash || result7 || libp) ;
12374 }
12375
12376 static int G__BesVisLib_rootcint_957_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12377 {
12378 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->PTcut());
12379 return(1 || funcname || hash || result7 || libp) ;
12380 }
12381
12382 static int G__BesVisLib_rootcint_957_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12383 {
12384 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->PTcutEGMUNU());
12385 return(1 || funcname || hash || result7 || libp) ;
12386 }
12387
12388 static int G__BesVisLib_rootcint_957_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12389 {
12390 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Rin());
12391 return(1 || funcname || hash || result7 || libp) ;
12392 }
12393
12394 static int G__BesVisLib_rootcint_957_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12395 {
12396 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Rout());
12397 return(1 || funcname || hash || result7 || libp) ;
12398 }
12399
12400 static int G__BesVisLib_rootcint_957_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12401 {
12402 switch (libp->paran) {
12403 case 1:
12404 ((BesVisDisplay*) G__getstructoffset())->SetDrawClusters((Bool_t) G__int(libp->para[0]));
12405 G__setnull(result7);
12406 break;
12407 case 0:
12408 ((BesVisDisplay*) G__getstructoffset())->SetDrawClusters();
12409 G__setnull(result7);
12410 break;
12411 }
12412 return(1 || funcname || hash || result7 || libp) ;
12413 }
12414
12415 static int G__BesVisLib_rootcint_957_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12416 {
12417 switch (libp->paran) {
12418 case 1:
12419 ((BesVisDisplay*) G__getstructoffset())->SetDrawParticles((Bool_t) G__int(libp->para[0]));
12420 G__setnull(result7);
12421 break;
12422 case 0:
12423 ((BesVisDisplay*) G__getstructoffset())->SetDrawParticles();
12424 G__setnull(result7);
12425 break;
12426 }
12427 return(1 || funcname || hash || result7 || libp) ;
12428 }
12429
12430 static int G__BesVisLib_rootcint_957_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12431 {
12432 switch (libp->paran) {
12433 case 1:
12434 ((BesVisDisplay*) G__getstructoffset())->SetPTcut((Float_t) G__double(libp->para[0]));
12435 G__setnull(result7);
12436 break;
12437 case 0:
12438 ((BesVisDisplay*) G__getstructoffset())->SetPTcut();
12439 G__setnull(result7);
12440 break;
12441 }
12442 return(1 || funcname || hash || result7 || libp) ;
12443 }
12444
12445 static int G__BesVisLib_rootcint_957_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12446 {
12447 switch (libp->paran) {
12448 case 1:
12449 ((BesVisDisplay*) G__getstructoffset())->SetPTcutEGMUNU((Float_t) G__double(libp->para[0]));
12450 G__setnull(result7);
12451 break;
12452 case 0:
12453 ((BesVisDisplay*) G__getstructoffset())->SetPTcutEGMUNU();
12454 G__setnull(result7);
12455 break;
12456 }
12457 return(1 || funcname || hash || result7 || libp) ;
12458 }
12459
12460 static int G__BesVisLib_rootcint_957_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12461 {
12462 ((BesVisDisplay*) G__getstructoffset())->SetView((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
12463 G__setnull(result7);
12464 return(1 || funcname || hash || result7 || libp) ;
12465 }
12466
12467 static int G__BesVisLib_rootcint_957_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12468 {
12469 switch (libp->paran) {
12470 case 1:
12471 ((BesVisDisplay*) G__getstructoffset())->ShowNextEvent((Int_t) G__int(libp->para[0]));
12472 G__setnull(result7);
12473 break;
12474 case 0:
12475 ((BesVisDisplay*) G__getstructoffset())->ShowNextEvent();
12476 G__setnull(result7);
12477 break;
12478 }
12479 return(1 || funcname || hash || result7 || libp) ;
12480 }
12481
12482 static int G__BesVisLib_rootcint_957_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12483 {
12484 ((BesVisDisplay*) G__getstructoffset())->SetMdcCon((Int_t) G__int(libp->para[0]));
12485 G__setnull(result7);
12486 return(1 || funcname || hash || result7 || libp) ;
12487 }
12488
12489 static int G__BesVisLib_rootcint_957_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12490 {
12491 ((BesVisDisplay*) G__getstructoffset())->SetTofCon((Int_t) G__int(libp->para[0]));
12492 G__setnull(result7);
12493 return(1 || funcname || hash || result7 || libp) ;
12494 }
12495
12496 static int G__BesVisLib_rootcint_957_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12497 {
12498 ((BesVisDisplay*) G__getstructoffset())->SetEmcCon((Int_t) G__int(libp->para[0]));
12499 G__setnull(result7);
12500 return(1 || funcname || hash || result7 || libp) ;
12501 }
12502
12503 static int G__BesVisLib_rootcint_957_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12504 {
12505 ((BesVisDisplay*) G__getstructoffset())->SetMucCon((Int_t) G__int(libp->para[0]));
12506 G__setnull(result7);
12507 return(1 || funcname || hash || result7 || libp) ;
12508 }
12509
12510 static int G__BesVisLib_rootcint_957_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12511 {
12512 ((BesVisDisplay*) G__getstructoffset())->SetAllVisible((Int_t) G__int(libp->para[0]));
12513 G__setnull(result7);
12514 return(1 || funcname || hash || result7 || libp) ;
12515 }
12516
12517 static int G__BesVisLib_rootcint_957_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12518 {
12519 ((BesVisDisplay*) G__getstructoffset())->SetQuarterVisible((Int_t) G__int(libp->para[0]));
12520 G__setnull(result7);
12521 return(1 || funcname || hash || result7 || libp) ;
12522 }
12523
12524 static int G__BesVisLib_rootcint_957_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12525 {
12526 ((BesVisDisplay*) G__getstructoffset())->SetHalfVisible((Int_t) G__int(libp->para[0]));
12527 G__setnull(result7);
12528 return(1 || funcname || hash || result7 || libp) ;
12529 }
12530
12531 static int G__BesVisLib_rootcint_957_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12532 {
12533 ((BesVisDisplay*) G__getstructoffset())->SetNoEndVisible((Int_t) G__int(libp->para[0]));
12534 G__setnull(result7);
12535 return(1 || funcname || hash || result7 || libp) ;
12536 }
12537
12538 static int G__BesVisLib_rootcint_957_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12539 {
12540 ((BesVisDisplay*) G__getstructoffset())->SetMdcFiredCell();
12541 G__setnull(result7);
12542 return(1 || funcname || hash || result7 || libp) ;
12543 }
12544
12545 static int G__BesVisLib_rootcint_957_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12546 {
12547 ((BesVisDisplay*) G__getstructoffset())->SetTofFiredCell();
12548 G__setnull(result7);
12549 return(1 || funcname || hash || result7 || libp) ;
12550 }
12551
12552 static int G__BesVisLib_rootcint_957_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12553 {
12554 ((BesVisDisplay*) G__getstructoffset())->SetEmcFiredCell();
12555 G__setnull(result7);
12556 return(1 || funcname || hash || result7 || libp) ;
12557 }
12558
12559 static int G__BesVisLib_rootcint_957_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12560 {
12561 ((BesVisDisplay*) G__getstructoffset())->SetMucFiredCell();
12562 G__setnull(result7);
12563 return(1 || funcname || hash || result7 || libp) ;
12564 }
12565
12566 static int G__BesVisLib_rootcint_957_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12567 {
12568 ((const BesVisDisplay*) G__getstructoffset())->SizeFruit();
12569 G__setnull(result7);
12570 return(1 || funcname || hash || result7 || libp) ;
12571 }
12572
12573 static int G__BesVisLib_rootcint_957_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12574 {
12575 ((const BesVisDisplay*) G__getstructoffset())->SizeParticles();
12576 G__setnull(result7);
12577 return(1 || funcname || hash || result7 || libp) ;
12578 }
12579
12580 static int G__BesVisLib_rootcint_957_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12581 {
12582 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Zin());
12583 return(1 || funcname || hash || result7 || libp) ;
12584 }
12585
12586 static int G__BesVisLib_rootcint_957_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12587 {
12588 G__letdouble(result7, 102, (double) ((BesVisDisplay*) G__getstructoffset())->Zout());
12589 return(1 || funcname || hash || result7 || libp) ;
12590 }
12591
12592 static int G__BesVisLib_rootcint_957_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12593 {
12594 G__letint(result7, 85, (long) BesVisDisplay::Class());
12595 return(1 || funcname || hash || result7 || libp) ;
12596 }
12597
12598 static int G__BesVisLib_rootcint_957_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12599 {
12600 G__letint(result7, 67, (long) BesVisDisplay::Class_Name());
12601 return(1 || funcname || hash || result7 || libp) ;
12602 }
12603
12604 static int G__BesVisLib_rootcint_957_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12605 {
12606 G__letint(result7, 115, (long) BesVisDisplay::Class_Version());
12607 return(1 || funcname || hash || result7 || libp) ;
12608 }
12609
12610 static int G__BesVisLib_rootcint_957_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12611 {
12612 BesVisDisplay::Dictionary();
12613 G__setnull(result7);
12614 return(1 || funcname || hash || result7 || libp) ;
12615 }
12616
12617 static int G__BesVisLib_rootcint_957_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12618 {
12619 ((BesVisDisplay*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12620 G__setnull(result7);
12621 return(1 || funcname || hash || result7 || libp) ;
12622 }
12623
12624 static int G__BesVisLib_rootcint_957_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12625 {
12626 G__letint(result7, 67, (long) BesVisDisplay::DeclFileName());
12627 return(1 || funcname || hash || result7 || libp) ;
12628 }
12629
12630 static int G__BesVisLib_rootcint_957_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12631 {
12632 G__letint(result7, 105, (long) BesVisDisplay::ImplFileLine());
12633 return(1 || funcname || hash || result7 || libp) ;
12634 }
12635
12636 static int G__BesVisLib_rootcint_957_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12637 {
12638 G__letint(result7, 67, (long) BesVisDisplay::ImplFileName());
12639 return(1 || funcname || hash || result7 || libp) ;
12640 }
12641
12642 static int G__BesVisLib_rootcint_957_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12643 {
12644 G__letint(result7, 105, (long) BesVisDisplay::DeclFileLine());
12645 return(1 || funcname || hash || result7 || libp) ;
12646 }
12647
12648
12649 typedef BesVisDisplay G__TBesVisDisplay;
12650 static int G__BesVisLib_rootcint_957_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12651 {
12652 char* gvp = (char*) G__getgvp();
12653 long soff = G__getstructoffset();
12654 int n = G__getaryconstruct();
12655
12656
12657
12658
12659
12660 if (!soff) {
12661 return(1);
12662 }
12663 if (n) {
12664 if (gvp == (char*)G__PVOID) {
12665 delete[] (BesVisDisplay*) soff;
12666 } else {
12667 G__setgvp((long) G__PVOID);
12668 for (int i = n - 1; i >= 0; --i) {
12669 ((BesVisDisplay*) (soff+(sizeof(BesVisDisplay)*i)))->~G__TBesVisDisplay();
12670 }
12671 G__setgvp((long)gvp);
12672 }
12673 } else {
12674 if (gvp == (char*)G__PVOID) {
12675 delete (BesVisDisplay*) soff;
12676 } else {
12677 G__setgvp((long) G__PVOID);
12678 ((BesVisDisplay*) (soff))->~G__TBesVisDisplay();
12679 G__setgvp((long)gvp);
12680 }
12681 }
12682 G__setnull(result7);
12683 return(1 || funcname || hash || result7 || libp) ;
12684 }
12685
12686
12687
12688 static int G__BesVisLib_rootcint_960_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12689 {
12690 ZHelix* p = NULL;
12691 char* gvp = (char*) G__getgvp();
12692 int n = G__getaryconstruct();
12693 if (n) {
12694 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12695 p = new ZHelix[n];
12696 } else {
12697 p = new((void*) gvp) ZHelix[n];
12698 }
12699 } else {
12700 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12701 p = new ZHelix;
12702 } else {
12703 p = new((void*) gvp) ZHelix;
12704 }
12705 }
12706 result7->obj.i = (long) p;
12707 result7->ref = (long) p;
12708 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
12709 return(1 || funcname || hash || result7 || libp) ;
12710 }
12711
12712 static int G__BesVisLib_rootcint_960_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12713 {
12714 ZHelix* p = NULL;
12715 char* gvp = (char*) G__getgvp();
12716 switch (libp->paran) {
12717 case 14:
12718
12719 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12720 p = new ZHelix(
12721 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12722 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12723 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12724 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12725 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12726 , (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
12727 , (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13]));
12728 } else {
12729 p = new((void*) gvp) ZHelix(
12730 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12731 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12732 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12733 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12734 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12735 , (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
12736 , (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13]));
12737 }
12738 break;
12739 case 13:
12740
12741 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12742 p = new ZHelix(
12743 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12744 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12745 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12746 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12747 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12748 , (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
12749 , (Double_t) G__double(libp->para[12]));
12750 } else {
12751 p = new((void*) gvp) ZHelix(
12752 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12753 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12754 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12755 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12756 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12757 , (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11])
12758 , (Double_t) G__double(libp->para[12]));
12759 }
12760 break;
12761 case 12:
12762
12763 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12764 p = new ZHelix(
12765 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12766 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12767 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12768 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12769 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12770 , (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11]));
12771 } else {
12772 p = new((void*) gvp) ZHelix(
12773 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12774 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12775 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12776 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12777 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12778 , (Int_t) G__int(libp->para[10]), (EZHelixRangeType) G__int(libp->para[11]));
12779 }
12780 break;
12781 case 11:
12782
12783 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12784 p = new ZHelix(
12785 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12786 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12787 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12788 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12789 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12790 , (Int_t) G__int(libp->para[10]));
12791 } else {
12792 p = new((void*) gvp) ZHelix(
12793 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
12794 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
12795 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
12796 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
12797 , (Double_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
12798 , (Int_t) G__int(libp->para[10]));
12799 }
12800 break;
12801 }
12802 result7->obj.i = (long) p;
12803 result7->ref = (long) p;
12804 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
12805 return(1 || funcname || hash || result7 || libp) ;
12806 }
12807
12808 static int G__BesVisLib_rootcint_960_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12809 {
12810 ((ZHelix*) G__getstructoffset())->Phi2XYZ((Double_t) G__double(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
12811 , *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
12812 G__setnull(result7);
12813 return(1 || funcname || hash || result7 || libp) ;
12814 }
12815
12816 static int G__BesVisLib_rootcint_960_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12817 {
12818 ((ZHelix*) G__getstructoffset())->Phi2ZR((Double_t) G__double(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
12819 , *(Double_t*) G__Doubleref(&libp->para[2]));
12820 G__setnull(result7);
12821 return(1 || funcname || hash || result7 || libp) ;
12822 }
12823
12824 static int G__BesVisLib_rootcint_960_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12825 {
12826 ((ZHelix*) G__getstructoffset())->SetRange((EZHelixRangeType) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
12827 , (Double_t) G__double(libp->para[2]));
12828 G__setnull(result7);
12829 return(1 || funcname || hash || result7 || libp) ;
12830 }
12831
12832 static int G__BesVisLib_rootcint_960_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12833 {
12834 ((ZHelix*) G__getstructoffset())->SetTrackType((TrackType) G__int(libp->para[0]));
12835 G__setnull(result7);
12836 return(1 || funcname || hash || result7 || libp) ;
12837 }
12838
12839 static int G__BesVisLib_rootcint_960_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12840 {
12841 switch (libp->paran) {
12842 case 1:
12843 ((ZHelix*) G__getstructoffset())->SetPoints((Option_t*) G__int(libp->para[0]));
12844 G__setnull(result7);
12845 break;
12846 case 0:
12847 ((ZHelix*) G__getstructoffset())->SetPoints();
12848 G__setnull(result7);
12849 break;
12850 }
12851 return(1 || funcname || hash || result7 || libp) ;
12852 }
12853
12854 static int G__BesVisLib_rootcint_960_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12855 {
12856 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->X2Phi((Double_t) G__double(libp->para[0])));
12857 return(1 || funcname || hash || result7 || libp) ;
12858 }
12859
12860 static int G__BesVisLib_rootcint_960_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12861 {
12862 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->Y2Phi((Double_t) G__double(libp->para[0])));
12863 return(1 || funcname || hash || result7 || libp) ;
12864 }
12865
12866 static int G__BesVisLib_rootcint_960_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12867 {
12868 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->Z2Phi((Double_t) G__double(libp->para[0])));
12869 return(1 || funcname || hash || result7 || libp) ;
12870 }
12871
12872 static int G__BesVisLib_rootcint_960_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12873 {
12874 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->R2Phi((Double_t) G__double(libp->para[0])));
12875 return(1 || funcname || hash || result7 || libp) ;
12876 }
12877
12878 static int G__BesVisLib_rootcint_960_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12879 {
12880 G__letdouble(result7, 100, (double) ((ZHelix*) G__getstructoffset())->Phi2S((Double_t) G__double(libp->para[0])));
12881 return(1 || funcname || hash || result7 || libp) ;
12882 }
12883
12884 static int G__BesVisLib_rootcint_960_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12885 {
12886 ((ZHelix*) G__getstructoffset())->DrawClass();
12887 G__setnull(result7);
12888 return(1 || funcname || hash || result7 || libp) ;
12889 }
12890
12891 static int G__BesVisLib_rootcint_960_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12892 {
12893 ((ZHelix*) G__getstructoffset())->DrawClone((Option_t*) G__int(libp->para[0]));
12894 G__setnull(result7);
12895 return(1 || funcname || hash || result7 || libp) ;
12896 }
12897
12898 static int G__BesVisLib_rootcint_960_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12899 {
12900 G__letint(result7, 85, (long) ZHelix::Class());
12901 return(1 || funcname || hash || result7 || libp) ;
12902 }
12903
12904 static int G__BesVisLib_rootcint_960_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12905 {
12906 G__letint(result7, 67, (long) ZHelix::Class_Name());
12907 return(1 || funcname || hash || result7 || libp) ;
12908 }
12909
12910 static int G__BesVisLib_rootcint_960_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12911 {
12912 G__letint(result7, 115, (long) ZHelix::Class_Version());
12913 return(1 || funcname || hash || result7 || libp) ;
12914 }
12915
12916 static int G__BesVisLib_rootcint_960_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12917 {
12918 ZHelix::Dictionary();
12919 G__setnull(result7);
12920 return(1 || funcname || hash || result7 || libp) ;
12921 }
12922
12923 static int G__BesVisLib_rootcint_960_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12924 {
12925 ((ZHelix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12926 G__setnull(result7);
12927 return(1 || funcname || hash || result7 || libp) ;
12928 }
12929
12930 static int G__BesVisLib_rootcint_960_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12931 {
12932 G__letint(result7, 67, (long) ZHelix::DeclFileName());
12933 return(1 || funcname || hash || result7 || libp) ;
12934 }
12935
12936 static int G__BesVisLib_rootcint_960_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12937 {
12938 G__letint(result7, 105, (long) ZHelix::ImplFileLine());
12939 return(1 || funcname || hash || result7 || libp) ;
12940 }
12941
12942 static int G__BesVisLib_rootcint_960_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12943 {
12944 G__letint(result7, 67, (long) ZHelix::ImplFileName());
12945 return(1 || funcname || hash || result7 || libp) ;
12946 }
12947
12948 static int G__BesVisLib_rootcint_960_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12949 {
12950 G__letint(result7, 105, (long) ZHelix::DeclFileLine());
12951 return(1 || funcname || hash || result7 || libp) ;
12952 }
12953
12954
12955 static int G__BesVisLib_rootcint_960_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12956
12957 {
12958 ZHelix* p;
12959 void* tmp = (void*) G__int(libp->para[0]);
12960 p = new ZHelix(*(ZHelix*) tmp);
12961 result7->obj.i = (long) p;
12962 result7->ref = (long) p;
12963 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
12964 return(1 || funcname || hash || result7 || libp) ;
12965 }
12966
12967
12968 typedef ZHelix G__TZHelix;
12969 static int G__BesVisLib_rootcint_960_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12970 {
12971 char* gvp = (char*) G__getgvp();
12972 long soff = G__getstructoffset();
12973 int n = G__getaryconstruct();
12974
12975
12976
12977
12978
12979 if (!soff) {
12980 return(1);
12981 }
12982 if (n) {
12983 if (gvp == (char*)G__PVOID) {
12984 delete[] (ZHelix*) soff;
12985 } else {
12986 G__setgvp((long) G__PVOID);
12987 for (int i = n - 1; i >= 0; --i) {
12988 ((ZHelix*) (soff+(sizeof(ZHelix)*i)))->~G__TZHelix();
12989 }
12990 G__setgvp((long)gvp);
12991 }
12992 } else {
12993 if (gvp == (char*)G__PVOID) {
12994 delete (ZHelix*) soff;
12995 } else {
12996 G__setgvp((long) G__PVOID);
12997 ((ZHelix*) (soff))->~G__TZHelix();
12998 G__setgvp((long)gvp);
12999 }
13000 }
13001 G__setnull(result7);
13002 return(1 || funcname || hash || result7 || libp) ;
13003 }
13004
13005
13006 static int G__BesVisLib_rootcint_960_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13007 {
13008 ZHelix* dest = (ZHelix*) G__getstructoffset();
13009 *dest = *(ZHelix*) libp->para[0].ref;
13010 const ZHelix& obj = *dest;
13011 result7->ref = (long) (&obj);
13012 result7->obj.i = (long) (&obj);
13013 return(1 || funcname || hash || result7 || libp) ;
13014 }
13015
13016
13017
13018
13019 static int G__BesVisLib_rootcint_961_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13020 {
13021 vector3 *p;
13022 char* gvp = (char*) G__getgvp();
13023 int n = G__getaryconstruct();
13024 if (n) {
13025 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13026 p = new vector3[n];
13027 } else {
13028 p = new((void*) gvp) vector3[n];
13029 }
13030 } else {
13031 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13032 p = new vector3;
13033 } else {
13034 p = new((void*) gvp) vector3;
13035 }
13036 }
13037 result7->obj.i = (long) p;
13038 result7->ref = (long) p;
13039 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
13040 return(1 || funcname || hash || result7 || libp) ;
13041 }
13042
13043
13044 static int G__BesVisLib_rootcint_961_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13045
13046 {
13047 vector3* p;
13048 void* tmp = (void*) G__int(libp->para[0]);
13049 p = new vector3(*(vector3*) tmp);
13050 result7->obj.i = (long) p;
13051 result7->ref = (long) p;
13052 G__set_tagnum(result7,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
13053 return(1 || funcname || hash || result7 || libp) ;
13054 }
13055
13056
13057 typedef vector3 G__Tvector3;
13058 static int G__BesVisLib_rootcint_961_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13059 {
13060 char* gvp = (char*) G__getgvp();
13061 long soff = G__getstructoffset();
13062 int n = G__getaryconstruct();
13063
13064
13065
13066
13067
13068 if (!soff) {
13069 return(1);
13070 }
13071 if (n) {
13072 if (gvp == (char*)G__PVOID) {
13073 delete[] (vector3*) soff;
13074 } else {
13075 G__setgvp((long) G__PVOID);
13076 for (int i = n - 1; i >= 0; --i) {
13077 ((vector3*) (soff+(sizeof(vector3)*i)))->~G__Tvector3();
13078 }
13079 G__setgvp((long)gvp);
13080 }
13081 } else {
13082 if (gvp == (char*)G__PVOID) {
13083 delete (vector3*) soff;
13084 } else {
13085 G__setgvp((long) G__PVOID);
13086 ((vector3*) (soff))->~G__Tvector3();
13087 G__setgvp((long)gvp);
13088 }
13089 }
13090 G__setnull(result7);
13091 return(1 || funcname || hash || result7 || libp) ;
13092 }
13093
13094
13095 static int G__BesVisLib_rootcint_961_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13096 {
13097 vector3* dest = (vector3*) G__getstructoffset();
13098 *dest = *(vector3*) libp->para[0].ref;
13099 const vector3& obj = *dest;
13100 result7->ref = (long) (&obj);
13101 result7->obj.i = (long) (&obj);
13102 return(1 || funcname || hash || result7 || libp) ;
13103 }
13104
13105
13106
13107
13108
13109
13110
13111
13112
13113
13114
13115
13116
13117
13118
13119
13120
13121
13122
13123
13124
13125
13126
13127
13128
13129
13130
13131
13132
13133
13134
13135
13136
13137
13138
13139
13140
13141
13142
13143
13144
13145
13146
13147
13148
13149
13150
13151
13152
13153
13154
13155
13156
13157
13158
13159
13160
13161
13162
13163
13164
13165
13166
13167
13168
13169
13170
13171
13172
13173
13174
13175
13176
13177 class G__Sizep2memfuncBesVisLib_rootcint {
13178 public:
13179 G__Sizep2memfuncBesVisLib_rootcint(): p(&G__Sizep2memfuncBesVisLib_rootcint::sizep2memfunc) {}
13180 size_t sizep2memfunc() { return(sizeof(p)); }
13181 private:
13182 size_t (G__Sizep2memfuncBesVisLib_rootcint::*p)();
13183 };
13184
13185 size_t G__get_sizep2memfuncBesVisLib_rootcint()
13186 {
13187 G__Sizep2memfuncBesVisLib_rootcint a;
13188 G__setsizep2memfunc((int)a.sizep2memfunc());
13189 return((size_t)a.sizep2memfunc());
13190 }
13191
13192
13193
13194
13195
13196
13197
13198
13199
13200
13201
13202 extern "C" void G__cpp_setup_inheritanceBesVisLib_rootcint() {
13203
13204
13205 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus))) {
13206 BesStatus *G__Lderived;
13207 G__Lderived=(BesStatus*)0x1000;
13208 {
13209 TObject *G__Lpbase=(TObject*)G__Lderived;
13210 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13211 }
13212 }
13213 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView))) {
13214 BesTView *G__Lderived;
13215 G__Lderived=(BesTView*)0x1000;
13216 {
13217 TView *G__Lpbase=(TView*)G__Lderived;
13218 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TView),(long)G__Lpbase-(long)G__Lderived,1,1);
13219 }
13220 {
13221 TObject *G__Lpbase=(TObject*)G__Lderived;
13222 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13223 }
13224 {
13225 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13226 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13227 }
13228 }
13229 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView))) {
13230 Bes2DView *G__Lderived;
13231 G__Lderived=(Bes2DView*)0x1000;
13232 {
13233 BesTView *G__Lpbase=(BesTView*)G__Lderived;
13234 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),(long)G__Lpbase-(long)G__Lderived,1,1);
13235 }
13236 {
13237 TView *G__Lpbase=(TView*)G__Lderived;
13238 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TView),(long)G__Lpbase-(long)G__Lderived,1,0);
13239 }
13240 {
13241 TObject *G__Lpbase=(TObject*)G__Lderived;
13242 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13243 }
13244 {
13245 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13246 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13247 }
13248 }
13249 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D))) {
13250 BesCircle2D *G__Lderived;
13251 G__Lderived=(BesCircle2D*)0x1000;
13252 {
13253 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13254 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13255 }
13256 {
13257 TObject *G__Lpbase=(TObject*)G__Lderived;
13258 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13259 }
13260 {
13261 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13262 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13263 }
13264 {
13265 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13266 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13267 }
13268 }
13269 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor))) {
13270 BesCursor *G__Lderived;
13271 G__Lderived=(BesCursor*)0x1000;
13272 {
13273 TObject *G__Lpbase=(TObject*)G__Lderived;
13274 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13275 }
13276 }
13277 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader))) {
13278 BesEventHeader *G__Lderived;
13279 G__Lderived=(BesEventHeader*)0x1000;
13280 {
13281 TObject *G__Lpbase=(TObject*)G__Lderived;
13282 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13283 }
13284 }
13285 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView))) {
13286 BesView *G__Lderived;
13287 G__Lderived=(BesView*)0x1000;
13288 {
13289 BesTView *G__Lpbase=(BesTView*)G__Lderived;
13290 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView),(long)G__Lpbase-(long)G__Lderived,1,1);
13291 }
13292 {
13293 TView *G__Lpbase=(TView*)G__Lderived;
13294 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TView),(long)G__Lpbase-(long)G__Lderived,1,0);
13295 }
13296 {
13297 TObject *G__Lpbase=(TObject*)G__Lderived;
13298 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13299 }
13300 {
13301 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13302 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13303 }
13304 }
13305 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D))) {
13306 BesMarker2D *G__Lderived;
13307 G__Lderived=(BesMarker2D*)0x1000;
13308 {
13309 TMarker *G__Lpbase=(TMarker*)G__Lderived;
13310 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
13311 }
13312 {
13313 TObject *G__Lpbase=(TObject*)G__Lderived;
13314 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13315 }
13316 {
13317 TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
13318 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
13319 }
13320 }
13321 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText))) {
13322 BesPaveText *G__Lderived;
13323 G__Lderived=(BesPaveText*)0x1000;
13324 {
13325 TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
13326 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
13327 }
13328 {
13329 TPave *G__Lpbase=(TPave*)G__Lderived;
13330 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
13331 }
13332 {
13333 TBox *G__Lpbase=(TBox*)G__Lderived;
13334 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
13335 }
13336 {
13337 TObject *G__Lpbase=(TObject*)G__Lderived;
13338 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13339 }
13340 {
13341 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13342 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13343 }
13344 {
13345 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13346 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
13347 }
13348 {
13349 TAttText *G__Lpbase=(TAttText*)G__Lderived;
13350 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
13351 }
13352 }
13353 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack))) {
13354 BesGeoTrack *G__Lderived;
13355 G__Lderived=(BesGeoTrack*)0x1000;
13356 {
13357 TGeoTrack *G__Lpbase=(TGeoTrack*)G__Lderived;
13358 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoTrack),(long)G__Lpbase-(long)G__Lderived,1,1);
13359 }
13360 {
13361 TVirtualGeoTrack *G__Lpbase=(TVirtualGeoTrack*)G__Lderived;
13362 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TVirtualGeoTrack),(long)G__Lpbase-(long)G__Lderived,1,0);
13363 }
13364 {
13365 TObject *G__Lpbase=(TObject*)G__Lderived;
13366 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13367 }
13368 {
13369 TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
13370 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,0);
13371 }
13372 {
13373 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13374 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13375 }
13376 {
13377 TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
13378 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
13379 }
13380 }
13381 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent))) {
13382 BesEvent *G__Lderived;
13383 G__Lderived=(BesEvent*)0x1000;
13384 {
13385 TObject *G__Lpbase=(TObject*)G__Lderived;
13386 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13387 }
13388 }
13389 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D))) {
13390 BesPolygon2D *G__Lderived;
13391 G__Lderived=(BesPolygon2D*)0x1000;
13392 {
13393 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13394 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13395 }
13396 {
13397 TObject *G__Lpbase=(TObject*)G__Lderived;
13398 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13399 }
13400 {
13401 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13402 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13403 }
13404 {
13405 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13406 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13407 }
13408 }
13409 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire))) {
13410 Mdc2DWire *G__Lderived;
13411 G__Lderived=(Mdc2DWire*)0x1000;
13412 {
13413 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13414 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13415 }
13416 {
13417 TObject *G__Lpbase=(TObject*)G__Lderived;
13418 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13419 }
13420 {
13421 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13422 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13423 }
13424 {
13425 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13426 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13427 }
13428 }
13429 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo))) {
13430 MdcROOTGeo *G__Lderived;
13431 G__Lderived=(MdcROOTGeo*)0x1000;
13432 {
13433 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13434 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13435 }
13436 }
13437 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin))) {
13438 Tof2DScin *G__Lderived;
13439 G__Lderived=(Tof2DScin*)0x1000;
13440 {
13441 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13442 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13443 }
13444 {
13445 TObject *G__Lpbase=(TObject*)G__Lderived;
13446 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13447 }
13448 {
13449 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13450 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13451 }
13452 {
13453 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13454 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13455 }
13456 }
13457 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo))) {
13458 TofROOTGeo *G__Lderived;
13459 G__Lderived=(TofROOTGeo*)0x1000;
13460 {
13461 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13462 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13463 }
13464 }
13465 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal))) {
13466 Emc2DCrystal *G__Lderived;
13467 G__Lderived=(Emc2DCrystal*)0x1000;
13468 {
13469 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13470 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13471 }
13472 {
13473 TObject *G__Lpbase=(TObject*)G__Lderived;
13474 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13475 }
13476 {
13477 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13478 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13479 }
13480 {
13481 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13482 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13483 }
13484 }
13485 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo))) {
13486 EmcROOTGeo *G__Lderived;
13487 G__Lderived=(EmcROOTGeo*)0x1000;
13488 {
13489 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13490 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13491 }
13492 }
13493 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip))) {
13494 Muc2DStrip *G__Lderived;
13495 G__Lderived=(Muc2DStrip*)0x1000;
13496 {
13497 TNamed *G__Lpbase=(TNamed*)G__Lderived;
13498 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
13499 }
13500 {
13501 TObject *G__Lpbase=(TObject*)G__Lderived;
13502 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13503 }
13504 {
13505 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13506 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
13507 }
13508 {
13509 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13510 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
13511 }
13512 }
13513 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo))) {
13514 MucROOTGeo *G__Lderived;
13515 G__Lderived=(MucROOTGeo*)0x1000;
13516 {
13517 SubDetectorROOTGeo *G__Lpbase=(SubDetectorROOTGeo*)G__Lderived;
13518 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),(long)G__Lpbase-(long)G__Lderived,1,1);
13519 }
13520 }
13521 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry))) {
13522 BesGeometry *G__Lderived;
13523 G__Lderived=(BesGeometry*)0x1000;
13524 {
13525 TObject *G__Lpbase=(TObject*)G__Lderived;
13526 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13527 }
13528 }
13529 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle))) {
13530 BesGMenuTitle *G__Lderived;
13531 G__Lderived=(BesGMenuTitle*)0x1000;
13532 {
13533 TGMenuTitle *G__Lpbase=(TGMenuTitle*)G__Lderived;
13534 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGMenuTitle),(long)G__Lpbase-(long)G__Lderived,1,1);
13535 }
13536 {
13537 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13538 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13539 }
13540 {
13541 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13542 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13543 }
13544 {
13545 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13546 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13547 }
13548 {
13549 TObject *G__Lpbase=(TObject*)G__Lderived;
13550 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13551 }
13552 {
13553 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13554 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13555 }
13556 }
13557 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar))) {
13558 BesGMenuBar *G__Lderived;
13559 G__Lderived=(BesGMenuBar*)0x1000;
13560 {
13561 TGMenuBar *G__Lpbase=(TGMenuBar*)G__Lderived;
13562 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGMenuBar),(long)G__Lpbase-(long)G__Lderived,1,1);
13563 }
13564 {
13565 TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived;
13566 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13567 }
13568 {
13569 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13570 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13571 }
13572 {
13573 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13574 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13575 }
13576 {
13577 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13578 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13579 }
13580 {
13581 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13582 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13583 }
13584 {
13585 TObject *G__Lpbase=(TObject*)G__Lderived;
13586 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13587 }
13588 {
13589 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13590 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13591 }
13592 }
13593 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton))) {
13594 BesGPictureButton *G__Lderived;
13595 G__Lderived=(BesGPictureButton*)0x1000;
13596 {
13597 TGPictureButton *G__Lpbase=(TGPictureButton*)G__Lderived;
13598 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGPictureButton),(long)G__Lpbase-(long)G__Lderived,1,1);
13599 }
13600 {
13601 TGButton *G__Lpbase=(TGButton*)G__Lderived;
13602 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
13603 }
13604 {
13605 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13606 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13607 }
13608 {
13609 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13610 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13611 }
13612 {
13613 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13614 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13615 }
13616 {
13617 TObject *G__Lpbase=(TObject*)G__Lderived;
13618 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13619 }
13620 {
13621 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13622 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13623 }
13624 {
13625 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
13626 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
13627 }
13628 }
13629 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader))) {
13630 BesHeader *G__Lderived;
13631 G__Lderived=(BesHeader*)0x1000;
13632 {
13633 TPaveText *G__Lpbase=(TPaveText*)G__Lderived;
13634 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveText),(long)G__Lpbase-(long)G__Lderived,1,1);
13635 }
13636 {
13637 TPave *G__Lpbase=(TPave*)G__Lderived;
13638 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPave),(long)G__Lpbase-(long)G__Lderived,1,0);
13639 }
13640 {
13641 TBox *G__Lpbase=(TBox*)G__Lderived;
13642 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TBox),(long)G__Lpbase-(long)G__Lderived,1,0);
13643 }
13644 {
13645 TObject *G__Lpbase=(TObject*)G__Lderived;
13646 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13647 }
13648 {
13649 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13650 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13651 }
13652 {
13653 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
13654 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
13655 }
13656 {
13657 TAttText *G__Lpbase=(TAttText*)G__Lderived;
13658 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttText),(long)G__Lpbase-(long)G__Lderived,1,0);
13659 }
13660 {
13661 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13662 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13663 }
13664 }
13665 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay))) {
13666 BesVisDisplay *G__Lderived;
13667 G__Lderived=(BesVisDisplay*)0x1000;
13668 {
13669 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13670 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
13671 }
13672 }
13673 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix))) {
13674 ZHelix *G__Lderived;
13675 G__Lderived=(ZHelix*)0x1000;
13676 {
13677 TPolyLine3D *G__Lpbase=(TPolyLine3D*)G__Lderived;
13678 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPolyLine3D),(long)G__Lpbase-(long)G__Lderived,1,1);
13679 }
13680 {
13681 TObject *G__Lpbase=(TObject*)G__Lderived;
13682 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13683 }
13684 {
13685 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
13686 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
13687 }
13688 {
13689 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
13690 G__inheritance_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix),G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
13691 }
13692 }
13693 }
13694
13695
13696
13697
13698 extern "C" void G__cpp_setup_typetableBesVisLib_rootcint() {
13699
13700
13701 G__search_typename2("Int_t",105,-1,0,-1);
13702 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
13703 G__search_typename2("UInt_t",104,-1,0,-1);
13704 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
13705 G__search_typename2("Float_t",102,-1,0,-1);
13706 G__setnewtype(-1,"Float 4 bytes (float)",0);
13707 G__search_typename2("Double_t",100,-1,0,-1);
13708 G__setnewtype(-1,"Double 8 bytes",0);
13709 G__search_typename2("Bool_t",103,-1,0,-1);
13710 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
13711 G__search_typename2("Version_t",115,-1,0,-1);
13712 G__setnewtype(-1,"Class version identifier (short)",0);
13713 G__search_typename2("Option_t",99,-1,256,-1);
13714 G__setnewtype(-1,"Option string (const char)",0);
13715 G__search_typename2("Long64_t",110,-1,0,-1);
13716 G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
13717 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
13718 G__setnewtype(-1,NULL,0);
13719 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
13720 G__setnewtype(-1,NULL,0);
13721 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
13722 G__setnewtype(-1,NULL,0);
13723 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
13724 G__setnewtype(-1,NULL,0);
13725 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
13726 G__setnewtype(-1,NULL,0);
13727 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
13728 G__setnewtype(-1,NULL,0);
13729 G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
13730 G__setnewtype(-1,NULL,0);
13731 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
13732 G__setnewtype(-1,NULL,0);
13733 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
13734 G__setnewtype(-1,NULL,0);
13735 G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
13736 G__setnewtype(-1,NULL,0);
13737 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13738 G__setnewtype(-1,NULL,0);
13739 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13740 G__setnewtype(-1,NULL,0);
13741 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13742 G__setnewtype(-1,NULL,0);
13743 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13744 G__setnewtype(-1,NULL,0);
13745 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13746 G__setnewtype(-1,NULL,0);
13747 G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
13748 G__setnewtype(-1,NULL,0);
13749 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
13750 G__setnewtype(-1,NULL,0);
13751 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
13752 G__setnewtype(-1,NULL,0);
13753 G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
13754 G__setnewtype(-1,NULL,0);
13755 G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
13756 G__setnewtype(-1,NULL,0);
13757 G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
13758 G__setnewtype(-1,NULL,0);
13759 G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
13760 G__setnewtype(-1,NULL,0);
13761 G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
13762 G__setnewtype(-1,NULL,0);
13763 G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
13764 G__setnewtype(-1,NULL,0);
13765 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
13766 G__setnewtype(-1,NULL,0);
13767 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
13768 G__setnewtype(-1,NULL,0);
13769 G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
13770 G__setnewtype(-1,NULL,0);
13771 G__search_typename2("pair<Int_t,Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_pairlEintcOfloatgR),0,-1);
13772 G__setnewtype(-1,NULL,0);
13773 G__search_typename2("vector<std::pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
13774 G__setnewtype(-1,NULL,0);
13775 G__search_typename2("vector<pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
13776 G__setnewtype(-1,NULL,0);
13777 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
13778 G__setnewtype(-1,NULL,0);
13779 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
13780 G__setnewtype(-1,NULL,0);
13781 G__search_typename2("vector<pair<int,float> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
13782 G__setnewtype(-1,NULL,0);
13783 G__search_typename2("Pixmap_t",107,-1,0,-1);
13784 G__setnewtype(-1,"Pixmap handle",0);
13785 G__search_typename2("GContext_t",107,-1,0,-1);
13786 G__setnewtype(-1,"Graphics context handle",0);
13787 G__search_typename2("FontStruct_t",107,-1,0,-1);
13788 G__setnewtype(-1,"Pointer to font structure",0);
13789 G__search_typename2("pair<UInt_t,Int_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR),0,-1);
13790 G__setnewtype(-1,NULL,0);
13791 G__search_typename2("vector<std::pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
13792 G__setnewtype(-1,NULL,0);
13793 G__search_typename2("vector<pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
13794 G__setnewtype(-1,NULL,0);
13795 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
13796 G__setnewtype(-1,NULL,0);
13797 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
13798 G__setnewtype(-1,NULL,0);
13799 G__search_typename2("vector<pair<unsigned int,int> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
13800 G__setnewtype(-1,NULL,0);
13801 G__search_typename2("map<Int_t,TGeoElementRN*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
13802 G__setnewtype(-1,NULL,0);
13803 G__search_typename2("map<int,TGeoElementRN*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
13804 G__setnewtype(-1,NULL,0);
13805 G__search_typename2("map<int,TGeoElementRN*,less<int> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
13806 G__setnewtype(-1,NULL,0);
13807 G__search_typename2("vector<ThreadData_t*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR),0,-1);
13808 G__setnewtype(-1,NULL,0);
13809 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR));
13810 G__setnewtype(-1,NULL,0);
13811 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR));
13812 G__setnewtype(-1,NULL,0);
13813 G__search_typename2("vector<TGeoVolumeAssembly::ThreadData_t*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR),0,-1);
13814 G__setnewtype(-1,NULL,0);
13815 G__search_typename2("vector<ContentItem>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR),0,-1);
13816 G__setnewtype(-1,NULL,0);
13817 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR));
13818 G__setnewtype(-1,NULL,0);
13819 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR));
13820 G__setnewtype(-1,NULL,0);
13821 G__search_typename2("vector<ContentGroup::ContentItem>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR),0,-1);
13822 G__setnewtype(-1,NULL,0);
13823 G__search_typename2("vector<ContentChoice*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR),0,-1);
13824 G__setnewtype(-1,NULL,0);
13825 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR));
13826 G__setnewtype(-1,NULL,0);
13827 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR));
13828 G__setnewtype(-1,NULL,0);
13829 G__search_typename2("map<std::string,define::constant>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
13830 G__setnewtype(-1,NULL,0);
13831 G__search_typename2("map<string,define::constant>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
13832 G__setnewtype(-1,NULL,0);
13833 G__search_typename2("map<string,define::constant>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
13834 G__setnewtype(-1,NULL,0);
13835 G__search_typename2("map<string,define::constant,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR),0,-1);
13836 G__setnewtype(-1,NULL,0);
13837 G__search_typename2("map<std::string,define::quantity>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
13838 G__setnewtype(-1,NULL,0);
13839 G__search_typename2("map<string,define::quantity>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
13840 G__setnewtype(-1,NULL,0);
13841 G__search_typename2("map<string,define::quantity>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
13842 G__setnewtype(-1,NULL,0);
13843 G__search_typename2("map<string,define::quantity,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR),0,-1);
13844 G__setnewtype(-1,NULL,0);
13845 G__search_typename2("map<std::string,define::expression>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
13846 G__setnewtype(-1,NULL,0);
13847 G__search_typename2("map<string,define::expression>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
13848 G__setnewtype(-1,NULL,0);
13849 G__search_typename2("map<string,define::expression>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
13850 G__setnewtype(-1,NULL,0);
13851 G__search_typename2("map<string,define::expression,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR),0,-1);
13852 G__setnewtype(-1,NULL,0);
13853 G__search_typename2("map<std::string,define::position>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
13854 G__setnewtype(-1,NULL,0);
13855 G__search_typename2("map<string,define::position>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
13856 G__setnewtype(-1,NULL,0);
13857 G__search_typename2("map<string,define::position>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
13858 G__setnewtype(-1,NULL,0);
13859 G__search_typename2("map<string,define::position,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR),0,-1);
13860 G__setnewtype(-1,NULL,0);
13861 G__search_typename2("map<std::string,define::rotation>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
13862 G__setnewtype(-1,NULL,0);
13863 G__search_typename2("map<string,define::rotation>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
13864 G__setnewtype(-1,NULL,0);
13865 G__search_typename2("map<string,define::rotation>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
13866 G__setnewtype(-1,NULL,0);
13867 G__search_typename2("map<string,define::rotation,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR),0,-1);
13868 G__setnewtype(-1,NULL,0);
13869 G__search_typename2("map<std::string,TGeoTranslation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
13870 G__setnewtype(-1,NULL,0);
13871 G__search_typename2("map<string,TGeoTranslation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
13872 G__setnewtype(-1,NULL,0);
13873 G__search_typename2("map<string,TGeoTranslation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
13874 G__setnewtype(-1,NULL,0);
13875 G__search_typename2("map<string,TGeoTranslation*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR),0,-1);
13876 G__setnewtype(-1,NULL,0);
13877 G__search_typename2("map<std::string,TGeoRotation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
13878 G__setnewtype(-1,NULL,0);
13879 G__search_typename2("map<string,TGeoRotation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
13880 G__setnewtype(-1,NULL,0);
13881 G__search_typename2("map<string,TGeoRotation*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
13882 G__setnewtype(-1,NULL,0);
13883 G__search_typename2("map<string,TGeoRotation*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR),0,-1);
13884 G__setnewtype(-1,NULL,0);
13885 G__search_typename2("map<std::string,TGeoShape*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
13886 G__setnewtype(-1,NULL,0);
13887 G__search_typename2("map<string,TGeoShape*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
13888 G__setnewtype(-1,NULL,0);
13889 G__search_typename2("map<string,TGeoShape*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
13890 G__setnewtype(-1,NULL,0);
13891 G__search_typename2("map<string,TGeoShape*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR),0,-1);
13892 G__setnewtype(-1,NULL,0);
13893 G__search_typename2("map<std::string,TGeoVolume*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
13894 G__setnewtype(-1,NULL,0);
13895 G__search_typename2("map<string,TGeoVolume*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
13896 G__setnewtype(-1,NULL,0);
13897 G__search_typename2("map<string,TGeoVolume*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
13898 G__setnewtype(-1,NULL,0);
13899 G__search_typename2("map<string,TGeoVolume*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR),0,-1);
13900 G__setnewtype(-1,NULL,0);
13901 G__search_typename2("map<std::string,TGeoVolumeAssembly*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
13902 G__setnewtype(-1,NULL,0);
13903 G__search_typename2("map<string,TGeoVolumeAssembly*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
13904 G__setnewtype(-1,NULL,0);
13905 G__search_typename2("map<string,TGeoVolumeAssembly*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
13906 G__setnewtype(-1,NULL,0);
13907 G__search_typename2("map<string,TGeoVolumeAssembly*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR),0,-1);
13908 G__setnewtype(-1,NULL,0);
13909 G__search_typename2("map<std::string,TGeoNode*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
13910 G__setnewtype(-1,NULL,0);
13911 G__search_typename2("map<string,TGeoNode*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
13912 G__setnewtype(-1,NULL,0);
13913 G__search_typename2("map<string,TGeoNode*>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
13914 G__setnewtype(-1,NULL,0);
13915 G__search_typename2("map<string,TGeoNode*,less<string> >",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR),0,-1);
13916 G__setnewtype(-1,NULL,0);
13917 G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR),0,-1);
13918 G__setnewtype(-1,NULL,0);
13919 G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR),0,-1);
13920 G__setnewtype(-1,NULL,0);
13921 G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TVectorTlEfloatgR),0,-1);
13922 G__setnewtype(-1,NULL,0);
13923 G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TVectorTlEdoublegR),0,-1);
13924 G__setnewtype(-1,NULL,0);
13925 G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTlEfloatgR),0,-1);
13926 G__setnewtype(-1,NULL,0);
13927 G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR),0,-1);
13928 G__setnewtype(-1,NULL,0);
13929 G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR),0,-1);
13930 G__setnewtype(-1,NULL,0);
13931 G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR),0,-1);
13932 G__setnewtype(-1,NULL,0);
13933 G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR),0,-1);
13934 G__setnewtype(-1,NULL,0);
13935 G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR),0,-1);
13936 G__setnewtype(-1,NULL,0);
13937 G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
13938 G__setnewtype(-1,NULL,0);
13939 G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
13940 G__setnewtype(-1,NULL,0);
13941 G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR),0,-1);
13942 G__setnewtype(-1,NULL,0);
13943 G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR),0,-1);
13944 G__setnewtype(-1,NULL,0);
13945 G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR),0,-1);
13946 G__setnewtype(-1,NULL,0);
13947 G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR),0,-1);
13948 G__setnewtype(-1,NULL,0);
13949 G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR),0,-1);
13950 G__setnewtype(-1,NULL,0);
13951 G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR),0,-1);
13952 G__setnewtype(-1,NULL,0);
13953 G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
13954 G__setnewtype(-1,NULL,0);
13955 G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TElementActionTlEfloatgR),0,-1);
13956 G__setnewtype(-1,NULL,0);
13957 G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR),0,-1);
13958 G__setnewtype(-1,NULL,0);
13959 G__search_typename2("intMap",117,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
13960 G__setnewtype(-1,NULL,0);
13961 }
13962
13963
13964
13965
13966
13967
13968
13969
13970 static void G__setup_memvarBesStatus(void) {
13971 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
13972 { BesStatus *p; p=(BesStatus*)0x1000; if (p) { }
13973 G__memvar_setup((void*)((long)(&p->fMdcGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcGlobal=",0,"! visibility flag for global Mdc");
13974 G__memvar_setup((void*)((long)(&p->fMdcTubes)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcTubes=",0,"! visibility flag for Mdc main tubes");
13975 G__memvar_setup((void*)((long)(&p->fMdcWires)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcWires=",0,"! visibility flag for Mdc wires");
13976 G__memvar_setup((void*)((long)(&p->fTofGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofGlobal=",0,"!visibility flag for global Tof");
13977 G__memvar_setup((void*)((long)(&p->fTofEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofEast=",0,"!visibility flag for Tof east EC");
13978 G__memvar_setup((void*)((long)(&p->fTofBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofBarrel=",0,"!visibility flag for Tof barrel");
13979 G__memvar_setup((void*)((long)(&p->fTofWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofWest=",0,"!visibility flag for Tof west EC");
13980 G__memvar_setup((void*)((long)(&p->fEmcGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcGlobal=",0,"! visivility flag for global Emc");
13981 G__memvar_setup((void*)((long)(&p->fEmcEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcEast=",0,"! visivility flag for Emc east EC");
13982 G__memvar_setup((void*)((long)(&p->fEmcBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcBarrel=",0,"! visivility flag for Emc barrel");
13983 G__memvar_setup((void*)((long)(&p->fEmcWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcWest=",0,"! visivility flag for Emc west EC");
13984 G__memvar_setup((void*)((long)(&p->fEmcSide)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcSide=",0,"! visivility flag for Emc side");
13985 G__memvar_setup((void*)((long)(&p->fMucGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucGlobal=",0,"! visivility flag for global Muc");
13986 G__memvar_setup((void*)((long)(&p->fMucEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucEast=",0,"! visivility flag for Muc east EC");
13987 G__memvar_setup((void*)((long)(&p->fMucBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucBarrel=",0,"! visivility flag for Muc barrel");
13988 G__memvar_setup((void*)((long)(&p->fMucWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucWest=",0,"! visivility flag for Muc west EC");
13989 G__memvar_setup((void*)((long)(&p->fMucStrips)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucStrips=",0,"! visivility flag for Muc strips");
13990 G__memvar_setup((void*)((long)(&p->fFull3DMdc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DMdc=",0,"! visivility flag for full 3D Mdc");
13991 G__memvar_setup((void*)((long)(&p->fFull3DTof)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DTof=",0,"! visivility flag for full 3D Tof");
13992 G__memvar_setup((void*)((long)(&p->fFull3DEmc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DEmc=",0,"! visivility flag for full 3D Emc");
13993 G__memvar_setup((void*)((long)(&p->fFull3DMuc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFull3DMuc=",0,"! visivility flag for full 3D Muc");
13994 G__memvar_setup((void*)((long)(&p->fBeamPipe)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fBeamPipe=",0,"! visibility flag for beam pipe");
13995 G__memvar_setup((void*)((long)(&p->fZRPlaneOnXY)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fZRPlaneOnXY=",0,"! visibility flag for ZRPlaneOnXY");
13996 G__memvar_setup((void*)((long)(&p->fAxis)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fAxis=",0,"! visibility flag for axis");
13997 G__memvar_setup((void*)((long)(&p->fMdcHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcHitsGlobal=",0,"! visibility flag for global Mdc Hits");
13998 G__memvar_setup((void*)((long)(&p->fMdcHits)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMdcHits=",0,"! visibility flag for Mdc Hits");
13999 G__memvar_setup((void*)((long)(&p->fTofHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsGlobal=",0,"! visibility flag for global Tof Hits");
14000 G__memvar_setup((void*)((long)(&p->fTofHitsEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsEast=",0,"! visibility flag for Tof Hits East");
14001 G__memvar_setup((void*)((long)(&p->fTofHitsBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsBarrel=",0,"! visibility flag for Tof Hits Barrel");
14002 G__memvar_setup((void*)((long)(&p->fTofHitsWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTofHitsWest=",0,"! visibility flag for Tof Hits West");
14003 G__memvar_setup((void*)((long)(&p->fEmcHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsGlobal=",0,"! visibility flag for global Emc Hits");
14004 G__memvar_setup((void*)((long)(&p->fEmcHitsEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsEast=",0,"! visibility flag for Emc Hits East");
14005 G__memvar_setup((void*)((long)(&p->fEmcHitsBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsBarrel=",0,"! visibility flag for Emc Hits Barrel");
14006 G__memvar_setup((void*)((long)(&p->fEmcHitsWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsWest=",0,"! visibility flag for Emc Hits West");
14007 G__memvar_setup((void*)((long)(&p->fEmcHitsSide)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fEmcHitsSide=",0,"! visibility flag for Emc Hits Side");
14008 G__memvar_setup((void*)((long)(&p->fMucHitsGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsGlobal=",0,"! visibility flag for global Muc Hits");
14009 G__memvar_setup((void*)((long)(&p->fMucHitsEast)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsEast=",0,"! visibility flag for Muc Hits East");
14010 G__memvar_setup((void*)((long)(&p->fMucHitsBarrel)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsBarrel=",0,"! visibility flag for Muc Hits Barrel");
14011 G__memvar_setup((void*)((long)(&p->fMucHitsWest)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fMucHitsWest=",0,"! visibility flag for Muc Hits West");
14012 G__memvar_setup((void*)((long)(&p->fTracksGlobal)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksGlobal=",0,"! visibility flag for global Tracks");
14013 G__memvar_setup((void*)((long)(&p->fTracksMdc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksMdc=",0,"! visibility flag for Mdc Tracks");
14014 G__memvar_setup((void*)((long)(&p->fTracksTof)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksTof=",0,"! visibility flag for Tof Tracks");
14015 G__memvar_setup((void*)((long)(&p->fTracksEmc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksEmc=",0,"! visibility flag for Emc Tracks");
14016 G__memvar_setup((void*)((long)(&p->fTracksMuc)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksMuc=",0,"! visibility flag for Muc Tracks");
14017 G__memvar_setup((void*)((long)(&p->fTracksExt)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fTracksExt=",0,"! visibility flag for Ext Tracks");
14018 G__memvar_setup((void*)((long)(&p->fFishEye)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fFishEye=",0,"! flags for fish eye view");
14019 G__memvar_setup((void*)((long)(&p->fPhiRangeMin)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fPhiRangeMin=",0,"Minimum of phi range for Z-R projection (in degrees)");
14020 G__memvar_setup((void*)((long)(&p->fPhiRangeMax)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fPhiRangeMax=",0,"Maximum of phi range for Z-R projection (in degrees)");
14021 G__memvar_setup((void*)((long)(&p->fZoom)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fZoom=",0,(char*)NULL);
14022 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14023 }
14024 G__tag_memvar_reset();
14025 }
14026
14027
14028
14029 static void G__setup_memvarBesTView(void) {
14030 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
14031 { BesTView *p; p=(BesTView*)0x1000; if (p) { }
14032 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLatitude=",0,"View angle latitude");
14033 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLongitude=",0,"View angle longitude");
14034 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsi=",0,"View angle psi");
14035 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDview=",0,"Distance from COP to COV");
14036 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDproj=",0,"Distance from COP to projection plane");
14037 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUpix=",0,"pad X size in pixels");
14038 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVpix=",0,"pad Y size in pixels");
14039 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTN[16]=",0,(char*)NULL);
14040 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTB[16]=",0,(char*)NULL);
14041 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax[3]=",0,"Upper limits of object");
14042 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin[3]=",0,"Lower limits of object");
14043 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUVcoord[4]=",0,"Viewing window limits");
14044 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTnorm[16]=",0,"Transformation matrix");
14045 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTback[16]=",0,"Back transformation matrix");
14046 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1[3]=",0,"First coordinate of X axis");
14047 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2[3]=",0,"Second coordinate of X axis");
14048 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1[3]=",0,"First coordinate of Y axis");
14049 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2[3]=",0,"Second coordinate of Y axis");
14050 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ1[3]=",0,"First coordinate of Z axis");
14051 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ2[3]=",0,"Second coordinate of Z axis");
14052 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSystem=",0,"Coordinate system");
14053 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TSeqCollection),-1,-1,2,"fOutline=",0,"Collection of outline's objects");
14054 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDefaultOutline=",0,"Set to TRUE if outline is default cube");
14055 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoRange=",0,"Set to TRUE if range computed automatically");
14056 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,"! Set to TRUE after ExecuteRotateView");
14057 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTViewcLcLdA),-1,-2,1,G__FastAllocString(4096).Format("kPerspective=%lldLL",(long long)BesTView::kPerspective).data(),0,(char*)NULL);
14058 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14059 }
14060 G__tag_memvar_reset();
14061 }
14062
14063
14064
14065 static void G__setup_memvarBes2DView(void) {
14066 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
14067 { Bes2DView *p; p=(Bes2DView*)0x1000; if (p) { }
14068 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFishEye=",0,"variable needed for toggle in menu");
14069 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"f2DViewType=",0,"View type");
14070 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMin=",0,"Minimum of phi range for Z-R projection (in degrees)");
14071 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMax=",0,"Maximum of phi range for Z-R projection (in degrees)");
14072 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveLabel),-1,-1,4,"fLabel=",0,"Label");
14073 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMarkerSize=",0,"size for marker");
14074 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatus3D=",0,"3D view status flags");
14075 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusXY=",0,"XY view status flags");
14076 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusZR=",0,"ZR view status flags");
14077 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusCurrent=",0,"current view status flags");
14078 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomFactor=",0,"zoom factor");
14079 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14080 }
14081 G__tag_memvar_reset();
14082 }
14083
14084
14085
14086 static void G__setup_memvarBesCircle2D(void) {
14087 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
14088 { BesCircle2D *p; p=(BesCircle2D*)0x1000; if (p) { }
14089 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_innerCircleX=",0,(char*)NULL);
14090 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_innerCircleY=",0,(char*)NULL);
14091 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_outerCircleX=",0,(char*)NULL);
14092 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_outerCircleY=",0,(char*)NULL);
14093 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_areaX=",0,(char*)NULL);
14094 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_areaY=",0,(char*)NULL);
14095 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInnerRadius=",0,"[3] inner Radius of circle");
14096 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOuterRadius=",0,"[3] outer Radius of circle");
14097 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCenter=",0,"[3] center of circle");
14098 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNSegment=",0,(char*)NULL);
14099 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14100 }
14101 G__tag_memvar_reset();
14102 }
14103
14104
14105
14106 static void G__setup_memvarBesCursor(void) {
14107 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
14108 { BesCursor *p; p=(BesCursor*)0x1000; if (p) { }
14109 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESCursorType),-1,-1,4,"fCursorType=",0,(char*)NULL);
14110 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShowInfo=",0,(char*)NULL);
14111 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14112 }
14113 G__tag_memvar_reset();
14114 }
14115
14116
14117
14118 static void G__setup_memvarBesEventHeader(void) {
14119 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
14120 { BesEventHeader *p; p=(BesEventHeader*)0x1000; if (p) { }
14121 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fRun=",0,"Run number");
14122 G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fEvent=",0,"Event number");
14123 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMC=",0,"MC event ");
14124 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDay=",0,"Day of Event");
14125 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMonth=",0,"Month of Event");
14126 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fYear=",0,"Year of Event");
14127 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHour=",0,"Hour of Event");
14128 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMin=",0,"Minute of Event");
14129 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSec=",0,"Second of Event");
14130 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvTime=",0,"event start time ");
14131 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEvTimeStatus=",0,"event start time status");
14132 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEvTimeQuality=",0,"event start time quality");
14133 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fP=",0,"Total momentum of all Mdc Tracks (in GeV/c)");
14134 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPt=",0,"Transverse momentum");
14135 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPx=",0,(char*)NULL);
14136 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPy=",0,(char*)NULL);
14137 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPz=",0,(char*)NULL);
14138 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fT=",0,(char*)NULL);
14139 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fE=",0,(char*)NULL);
14140 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTimeType=",0,(char*)NULL);
14141 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fTrigChannelVector=",0,(char*)NULL);
14142 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fTrigConditionVector=",0,(char*)NULL);
14143 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14144 }
14145 G__tag_memvar_reset();
14146 }
14147
14148
14149
14150 static void G__setup_memvarBesView(void) {
14151 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
14152 { BesView *p; p=(BesView*)0x1000; if (p) { }
14153 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFishEye=",0,"variable needed for toggle in menu");
14154 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESViewType),-1,-1,4,"fViewType=",0,"View type");
14155 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMin=",0,"Minimum of phi range for Z-R projection (in degrees)");
14156 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhiRangeMax=",0,"Maximum of phi range for Z-R projection (in degrees)");
14157 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveLabel),-1,-1,4,"fLabel=",0,"Label");
14158 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMarkerSize=",0,"size for marker");
14159 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatus3D=",0,"3D view status flags");
14160 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusXY=",0,"XY view status flags");
14161 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusZR=",0,"ZR view status flags");
14162 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus),-1,-1,4,"fStatusCurrent=",0,"current view status flags");
14163 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZoomFactor=",0,"zoom factor");
14164 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fExtentDefault=",0,(char*)NULL);
14165 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"m_BesR=",0,(char*)NULL);
14166 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"m_BesZ=",0,(char*)NULL);
14167 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14168 }
14169 G__tag_memvar_reset();
14170 }
14171
14172
14173
14174 static void G__setup_memvarBesMarker2D(void) {
14175 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
14176 { BesMarker2D *p; p=(BesMarker2D*)0x1000; if (p) { }
14177 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TString),-1,-1,4,"fName=",0,"name of line");
14178 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TString),-1,-1,4,"fTitle=",0,"title of line");
14179 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWCX=",0,"marker x pos in world coordinaten");
14180 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWCY=",0,"marker y pos in world coordinaten");
14181 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWCZ=",0,"marker z pos in world coordinaten");
14182 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSizeMultiple=",0,"marker size mulitple * TView->GetMarkerSize ");
14183 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14184 }
14185 G__tag_memvar_reset();
14186 }
14187
14188
14189
14190 static void G__setup_memvarBesPaveText(void) {
14191 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
14192 { BesPaveText *p; p=(BesPaveText*)0x1000; if (p) { }
14193 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTextSize=",0,(char*)NULL);
14194 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fdxNDC=",0,(char*)NULL);
14195 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fdyNDC=",0,(char*)NULL);
14196 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14197 }
14198 G__tag_memvar_reset();
14199 }
14200
14201
14202
14203 static void G__setup_memvarBesGeoTrack(void) {
14204 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
14205 { BesGeoTrack *p; p=(BesGeoTrack*)0x1000; if (p) { }
14206 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fHits=",0,(char*)NULL);
14207 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14208 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCharge=",0,(char*)NULL);
14209 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fType=",0,"1: Mdc, 2: Tof, 3: Emc, 4: Muc, 5: Ext");
14210 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14211 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPolyLine3D),-1,-1,4,"fPolyLine3D=",0,(char*)NULL);
14212 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),-1,-1,4,"fMarker=",0,(char*)NULL);
14213 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14214 }
14215 G__tag_memvar_reset();
14216 }
14217
14218
14219
14220 static void G__setup_memvarBesEvent(void) {
14221 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
14222 { BesEvent *p; p=(BesEvent*)0x1000; if (p) { }
14223 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"f_Magnetic=",0,(char*)NULL);
14224 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader),-1,-1,4,"fEventHeader=",0,"Event header");
14225 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TDigiEvent),-1,-1,4,"fDigiEvent=",0,(char*)NULL);
14226 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TEvtHeader),-1,-1,4,"fEvtHeader=",0,(char*)NULL);
14227 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TTrigEvent),-1,-1,4,"fTrigEvent=",0,(char*)NULL);
14228 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecEvTime),-1,-1,4,"fRecEvTime=",0,(char*)NULL);
14229 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fMdcTrackCol=",0,(char*)NULL);
14230 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fTofTrackCol=",0,(char*)NULL);
14231 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fEmcTrackCol=",0,(char*)NULL);
14232 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fMucTrackCol=",0,(char*)NULL);
14233 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"fExtTrackCol=",0,(char*)NULL);
14234 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14235 }
14236 G__tag_memvar_reset();
14237 }
14238
14239
14240
14241 static void G__setup_memvarSubDetectorROOTGeo(void) {
14242 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
14243 { SubDetectorROOTGeo *p; p=(SubDetectorROOTGeo*)0x1000; if (p) { }
14244 G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14245 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SAXProcessor),-1,-1,4,"m_sxp=",0,(char*)NULL);
14246 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ProcessingConfigurator),-1,-1,4,"m_config=",0,(char*)NULL);
14247 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"m_ROOTGeoInit=",0,(char*)NULL);
14248 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"m_childNo=",0,"child no of this subdetector in bes. ");
14249 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"m_2DGeoInit=",0,(char*)NULL);
14250 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,2,"m_TopVolume=",0,(char*)NULL);
14251 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,2,"m_DetectorsArray=",0,(char*)NULL);
14252 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,2,"m_HitsArray=",0,(char*)NULL);
14253 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,2,"m_2DHitsArray=",0,(char*)NULL);
14254 }
14255 G__tag_memvar_reset();
14256 }
14257
14258
14259
14260 static void G__setup_memvarBesPolygon2D(void) {
14261 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
14262 { BesPolygon2D *p; p=(BesPolygon2D*)0x1000; if (p) { }
14263 G__memvar_setup((void*)0,105,0,0,-1,-1,-2,4,"num=",0,(char*)NULL);
14264 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"f_xx=",0,(char*)NULL);
14265 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"f_yy=",0,(char*)NULL);
14266 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"No. of points");
14267 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fP=",0,"[3*fN] Points in world coordinates");
14268 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPBackUp=",0,"[3*fN] for fP BackUp when rotate;");
14269 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCenter[3]=",0,(char*)NULL);
14270 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRotatable=",0,(char*)NULL);
14271 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPaveText),-1,-1,2,"fInfoBox=",0,"! info box");
14272 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14273 }
14274 G__tag_memvar_reset();
14275 }
14276
14277
14278
14279 static void G__setup_memvarMdc2DWire(void) {
14280 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
14281 { Mdc2DWire *p; p=(Mdc2DWire*)0x1000; if (p) { }
14282 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWireType=",0,"1: Axial wire 2: Stereo wire");
14283 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fTube=",0,(char*)NULL);
14284 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"fWireCircle=",0,(char*)NULL);
14285 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fWireCone=",0,(char*)NULL);
14286 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D),-1,-1,4,"fZRPosMarker2D=",0,(char*)NULL);
14287 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWestHole[3]=",0,(char*)NULL);
14288 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEastHole[3]=",0,(char*)NULL);
14289 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWestPhi=",0,(char*)NULL);
14290 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEastPhi=",0,(char*)NULL);
14291 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZRSectionPos[3]=",0,(char*)NULL);
14292 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fZRSectionFlag=",0,(char*)NULL);
14293 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14294 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14295 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHighlighted=",0,(char*)NULL);
14296 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFired=",0,(char*)NULL);
14297 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fColorfulWire=",0,(char*)NULL);
14298 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"qOverflow=",0,(char*)NULL);
14299 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcTube=",0,(char*)NULL);
14300 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwTube=",0,(char*)NULL);
14301 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcTube=",0,(char*)NULL);
14302 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsTube=",0,(char*)NULL);
14303 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcWire=",0,(char*)NULL);
14304 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCircle=",0,(char*)NULL);
14305 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCone=",0,(char*)NULL);
14306 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCircle=",0,(char*)NULL);
14307 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCone=",0,(char*)NULL);
14308 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCircle=",0,(char*)NULL);
14309 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCone=",0,(char*)NULL);
14310 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcWireFired=",0,(char*)NULL);
14311 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCircleFired=",0,(char*)NULL);
14312 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwConeFired=",0,(char*)NULL);
14313 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCircleFired=",0,(char*)NULL);
14314 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcConeFired=",0,(char*)NULL);
14315 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCircleFired=",0,(char*)NULL);
14316 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsConeFired=",0,(char*)NULL);
14317 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcWireHL=",0,(char*)NULL);
14318 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCircleHL=",0,(char*)NULL);
14319 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwConeHL=",0,(char*)NULL);
14320 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCircleHL=",0,(char*)NULL);
14321 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcConeHL=",0,(char*)NULL);
14322 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCircleHL=",0,(char*)NULL);
14323 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsConeHL=",0,(char*)NULL);
14324 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sizeMarker=",0,(char*)NULL);
14325 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cMarker=",0,(char*)NULL);
14326 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cMarkerFired=",0,(char*)NULL);
14327 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cMarkerHL=",0,(char*)NULL);
14328 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sMarker=",0,(char*)NULL);
14329 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sMarkerFired=",0,(char*)NULL);
14330 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"sMarkerHL=",0,(char*)NULL);
14331 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"mdcTime=",0,(char*)NULL);
14332 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"mdcCharge=",0,(char*)NULL);
14333 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"evTime=",0,(char*)NULL);
14334 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14335 }
14336 G__tag_memvar_reset();
14337 }
14338
14339
14340
14341 static void G__setup_memvarMdcROOTGeo(void) {
14342 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
14343 { MdcROOTGeo *p; p=(MdcROOTGeo*)0x1000; if (p) { }
14344 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSegment=66LL",0,(char*)NULL);
14345 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStereoLayerIn=8LL",0,(char*)NULL);
14346 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kAxialLayerIn=12LL",0,(char*)NULL);
14347 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStereoLayerOut=16LL",0,(char*)NULL);
14348 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kAxialLayerOut=7LL",0,(char*)NULL);
14349 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kLayer=50LL",0,(char*)NULL);
14350 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kTrueLayer=43LL",0,"m_kLayer-m_kAxialLayerOut");
14351 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kReplicaMax=288LL",0,(char*)NULL);
14352 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kReplica[50]=",0,(char*)NULL);
14353 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kStereoDir[43]=",0,(char*)NULL);
14354 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kCorrectLayer=10LL",0,(char*)NULL);
14355 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kiCorrectLayer[10]=",0,(char*)NULL);
14356 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kiCorrectReplica[10]=",0,(char*)NULL);
14357 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_TFire=",0,(char*)NULL);
14358 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_QFire=",0,(char*)NULL);
14359 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_QNotOverflow=",0,(char*)NULL);
14360 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_ColorfulWire=",0,(char*)NULL);
14361 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_MdcTimeSubEvTime=",0,(char*)NULL);
14362 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"MDC_TIME_FACTOR=100000LL",0,(char*)NULL);
14363 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"MDC_CHARGE_FACTOR=1000000LL",0,(char*)NULL);
14364 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_MdcColor=",0,(char*)NULL);
14365 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_segmentColor=",0,(char*)NULL);
14366 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_hypeColor=",0,(char*)NULL);
14367 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_tubeColor=",0,(char*)NULL);
14368 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_twistedTubsColor=",0,(char*)NULL);
14369 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_replicaColor=",0,(char*)NULL);
14370 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("map<int,int>"),-1,4,"m_CorrectMap=",0,(char*)NULL);
14371 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Mdc=",0,(char*)NULL);
14372 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeLayer[50]=",0,(char*)NULL);
14373 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeReplica[50][288]=",0,(char*)NULL);
14374 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalSegment[132]=",0,(char*)NULL);
14375 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalReplica[50][288]=",0,(char*)NULL);
14376 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_MdcDigiCol=",0,(char*)NULL);
14377 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"m_MdcXY=",0,(char*)NULL);
14378 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"m_MdcXYSuper[4]=",0,(char*)NULL);
14379 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire),-1,-1,4,"m_Mdc2DWire[43][288]=",0,(char*)NULL);
14380 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MdcZR[2]=",0,(char*)NULL);
14381 }
14382 G__tag_memvar_reset();
14383 }
14384
14385
14386
14387 static void G__setup_memvarTof2DScin(void) {
14388 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
14389 { Tof2DScin *p; p=(Tof2DScin*)0x1000; if (p) { }
14390 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPart=",0,(char*)NULL);
14391 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinXY=",0,(char*)NULL);
14392 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinZR=",0,(char*)NULL);
14393 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinXYFired=",0,(char*)NULL);
14394 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fScinZRFired=",0,(char*)NULL);
14395 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fChargeMax=50LL",0,(char*)NULL);
14396 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTime=",0,(char*)NULL);
14397 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCharge=",0,(char*)NULL);
14398 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZRSectionTolerance[3]=",0,"to avoid on zrSection nothing drawn sometimes");
14399 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMin=",0,(char*)NULL);
14400 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMax=",0,(char*)NULL);
14401 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14402 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14403 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHighlighted=",0,(char*)NULL);
14404 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFired=",0,(char*)NULL);
14405 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScin=",0,(char*)NULL);
14406 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScin=",0,(char*)NULL);
14407 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScin=",0,(char*)NULL);
14408 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScin=",0,(char*)NULL);
14409 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScinFired=",0,(char*)NULL);
14410 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScinFired=",0,(char*)NULL);
14411 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScinFired=",0,(char*)NULL);
14412 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScinFired=",0,(char*)NULL);
14413 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScinHL=",0,(char*)NULL);
14414 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScinHL=",0,(char*)NULL);
14415 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScinHL=",0,(char*)NULL);
14416 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScinHL=",0,(char*)NULL);
14417 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcScinFiredHL=",0,(char*)NULL);
14418 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwScinFiredHL=",0,(char*)NULL);
14419 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcScinFiredHL=",0,(char*)NULL);
14420 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsScinFiredHL=",0,(char*)NULL);
14421 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14422 }
14423 G__tag_memvar_reset();
14424 }
14425
14426
14427
14428 static void G__setup_memvarTofROOTGeo(void) {
14429 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
14430 { TofROOTGeo *p; p=(TofROOTGeo*)0x1000; if (p) { }
14431 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPart=3LL",0,(char*)NULL);
14432 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kLayerBr=2LL",0,(char*)NULL);
14433 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kLayerEc=1LL",0,(char*)NULL);
14434 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kScinBr=88LL",0,(char*)NULL);
14435 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kScinEc=48LL",0,(char*)NULL);
14436 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBucketEc=1LL",0,(char*)NULL);
14437 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBucketBr=2LL",0,(char*)NULL);
14438 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"TOF_TIME_FACTOR=1000000LL",0,(char*)NULL);
14439 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"TOF_CHARGE_FACTOR=1000000LL",0,(char*)NULL);
14440 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_TMatch=",0,(char*)NULL);
14441 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"k_QMatch=",0,(char*)NULL);
14442 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_TofColor=",0,(char*)NULL);
14443 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_BucketColor=",0,(char*)NULL);
14444 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_ScinColor=",0,(char*)NULL);
14445 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Tof=",0,(char*)NULL);
14446 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodePVF[3][2][88]=",0,(char*)NULL);
14447 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeAl[3][2]=",0,(char*)NULL);
14448 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeScin[3][2]=",0,(char*)NULL);
14449 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalScin[3][2][88]=",0,(char*)NULL);
14450 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_TofDigiCol=",0,(char*)NULL);
14451 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin),-1,-1,4,"m_Tof2DScin[3][2][88]=",0,(char*)NULL);
14452 }
14453 G__tag_memvar_reset();
14454 }
14455
14456
14457
14458 static void G__setup_memvarEmc2DCrystal(void) {
14459 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
14460 { Emc2DCrystal *p; p=(Emc2DCrystal*)0x1000; if (p) { }
14461 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPart=",0,(char*)NULL);
14462 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTheta=",0,(char*)NULL);
14463 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalXY=",0,(char*)NULL);
14464 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalZR=",0,(char*)NULL);
14465 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalSide=",0,(char*)NULL);
14466 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalXYFired=",0,(char*)NULL);
14467 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalZRFired=",0,(char*)NULL);
14468 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fCrystalSideFired=",0,(char*)NULL);
14469 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fChargeMax=300LL",0,(char*)NULL);
14470 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTime=",0,(char*)NULL);
14471 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCharge=",0,(char*)NULL);
14472 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZRSectionTolerance[3]=",0,"to avoid on zrSection nothing drawn sometimes");
14473 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMin=",0,(char*)NULL);
14474 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhiMax=",0,(char*)NULL);
14475 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"ecXYPointZ=1420LL",0,"theta0:1407.71, theta5:1416.8");
14476 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"brZRPointR=990LL",0,"these two doule define the tube of emc, R=brZRPointR, Z=+-ecXYPointZ;");
14477 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"sideDeltaPhi=21LL",0,"deg, side emc viewPhi +- sideDeltaPhi range ");
14478 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14479 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14480 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHighlighted=",0,(char*)NULL);
14481 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFired=",0,(char*)NULL);
14482 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystal=",0,"line color");
14483 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystal=",0,"line width");
14484 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystal=",0,"fill color");
14485 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystal=",0,"fill style");
14486 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalTrans=",0,(char*)NULL);
14487 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystalFired=",0,(char*)NULL);
14488 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystalFired=",0,(char*)NULL);
14489 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystalFired=",0,(char*)NULL);
14490 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalFired=",0,(char*)NULL);
14491 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystalHL=",0,(char*)NULL);
14492 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystalHL=",0,(char*)NULL);
14493 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystalHL=",0,(char*)NULL);
14494 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalHL=",0,(char*)NULL);
14495 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcCrystalFiredHL=",0,(char*)NULL);
14496 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwCrystalFiredHL=",0,(char*)NULL);
14497 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcCrystalFiredHL=",0,(char*)NULL);
14498 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsCrystalFiredHL=",0,(char*)NULL);
14499 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14500 }
14501 G__tag_memvar_reset();
14502 }
14503
14504
14505
14506 static void G__setup_memvarEmcROOTGeo(void) {
14507 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
14508 { EmcROOTGeo *p; p=(EmcROOTGeo*)0x1000; if (p) { }
14509 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPart=3LL",0,(char*)NULL);
14510 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPhiBr=120LL",0,(char*)NULL);
14511 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kThetaBr=44LL",0,(char*)NULL);
14512 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kPhiEc=",0,(char*)NULL);
14513 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kThetaEc=",0,(char*)NULL);
14514 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kSectorEc=",0,(char*)NULL);
14515 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kNbEc=",0,(char*)NULL);
14516 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_kRealNbEc=",0,(char*)NULL);
14517 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_EmcColor=",0,(char*)NULL);
14518 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_partColor=",0,(char*)NULL);
14519 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_phiColor=",0,(char*)NULL);
14520 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_thetaColor=",0,(char*)NULL);
14521 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_brCrystalColor=",0,(char*)NULL);
14522 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_ecCrystalColor=",0,(char*)NULL);
14523 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"EMC_TIME_FACTOR=1LL",0,(char*)NULL);
14524 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"EMC_CHARGE_FACTOR=1000LL",0,(char*)NULL);
14525 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Emc=",0,(char*)NULL);
14526 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodePart[3]=",0,(char*)NULL);
14527 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodePhi[3][120]=",0,(char*)NULL);
14528 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeTheta[3][120][44]=",0,"m_kPhiBr > m_kPhiEc, m_kThetaBr > m_kThetaEc");
14529 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeTheta2[3][120][44]=",0,"contains theta phi has tow nodes ");
14530 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalCrystal[3][120][44]=",0,(char*)NULL);
14531 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalCrystal2[3][120][44]=",0,(char*)NULL);
14532 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_PhyNodeOrgArray=",0,(char*)NULL);
14533 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_EmcDigiCol=",0,(char*)NULL);
14534 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal),-1,-1,4,"m_Emc2DCrystal[3][120][44]=",0,(char*)NULL);
14535 }
14536 G__tag_memvar_reset();
14537 }
14538
14539
14540
14541 static void G__setup_memvarMuc2DStrip(void) {
14542 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
14543 { Muc2DStrip *p; p=(Muc2DStrip*)0x1000; if (p) { }
14544 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPart=",0,(char*)NULL);
14545 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSeg=",0,(char*)NULL);
14546 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGap=",0,(char*)NULL);
14547 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStrip=",0,(char*)NULL);
14548 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fStripXY=",0,(char*)NULL);
14549 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"fStripZR=",0,(char*)NULL);
14550 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"fInfoCon=",0,(char*)NULL);
14551 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText),-1,-1,4,"fTip=",0,(char*)NULL);
14552 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHighlighted=",0,(char*)NULL);
14553 G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFired=",0,(char*)NULL);
14554 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcStrip=",0,"line color");
14555 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwStrip=",0,"line width");
14556 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lsStrip=",0,"line width");
14557 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcStrip=",0,"fill color");
14558 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsStrip=",0,"fill style");
14559 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcStripFired=",0,(char*)NULL);
14560 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwStripFired=",0,(char*)NULL);
14561 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lsStripFired=",0,(char*)NULL);
14562 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcStripFired=",0,(char*)NULL);
14563 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsStripFired=",0,(char*)NULL);
14564 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lcStripHL=",0,(char*)NULL);
14565 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lwStripHL=",0,(char*)NULL);
14566 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"lsStripHL=",0,(char*)NULL);
14567 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fcStripHL=",0,(char*)NULL);
14568 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fsStripHL=",0,(char*)NULL);
14569 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"m_kDrawLineRange=2000LL",0,"if view x range > 2000, a barrel strip is very small, so dont draw edge lines ");
14570 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14571 }
14572 G__tag_memvar_reset();
14573 }
14574
14575
14576
14577 static void G__setup_memvarMucROOTGeo(void) {
14578 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
14579 { MucROOTGeo *p; p=(MucROOTGeo*)0x1000; if (p) { }
14580 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPart=3LL",0,(char*)NULL);
14581 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSegMax=8LL",0,(char*)NULL);
14582 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kAbsorberMax=9LL",0,(char*)NULL);
14583 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kGapMax=9LL",0,(char*)NULL);
14584 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kPanelMax=4LL",0,(char*)NULL);
14585 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kStripMax=112LL",0,(char*)NULL);
14586 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kBakelite=2LL",0,(char*)NULL);
14587 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kGasChamber=1LL",0,(char*)NULL);
14588 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kSmallBlockMax=2LL",0,(char*)NULL);
14589 G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"m_kUpDown=2LL",0,(char*)NULL);
14590 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kSeg[3]=",0,(char*)NULL);
14591 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kAbsorber[3]=",0,(char*)NULL);
14592 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kGap[3]=",0,(char*)NULL);
14593 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kPanel[3]=",0,(char*)NULL);
14594 G__memvar_setup((void*)0,105,0,1,-1,-1,-2,4,"m_kBakelitePanel[3][2]=",0,(char*)NULL);
14595 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_StripNum[3][8][9]=",0,(char*)NULL);
14596 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_MucColor=",0,(char*)NULL);
14597 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_absorberColor=",0,(char*)NULL);
14598 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_gapColor=",0,(char*)NULL);
14599 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_gasChamberColor=",0,(char*)NULL);
14600 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_bakeliteColor=",0,(char*)NULL);
14601 G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"m_stripColor=",0,(char*)NULL);
14602 G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"m_kStripZMuliple=12LL",0,"as dz is very thin, multiply so that it can be seen.");
14603 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Muc=",0,(char*)NULL);
14604 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeAbsorber[3][8][9]=",0,(char*)NULL);
14605 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeAbsorberPanel[3][8][9][4]=",0,(char*)NULL);
14606 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeGap[3][8][9]=",0,(char*)NULL);
14607 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeStripPlane[3][8][9]=",0,(char*)NULL);
14608 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode),-1,-1,4,"m_NodeStrip[3][8][9][112]=",0,(char*)NULL);
14609 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalAbsorber[3][8][9][4]=",0,(char*)NULL);
14610 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalGap[3][8][9]=",0,(char*)NULL);
14611 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode),-1,-1,4,"m_PhysicalStrip[3][8][9][112]=",0,(char*)NULL);
14612 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray),-1,-1,4,"m_MucDigiCol=",0,(char*)NULL);
14613 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucXY[3][8]=",0,(char*)NULL);
14614 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucZR[3][8]=",0,(char*)NULL);
14615 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucXYGap[3][8][9]=",0,(char*)NULL);
14616 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_MucZRGap[3][8][9]=",0,(char*)NULL);
14617 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip),-1,-1,4,"m_Muc2DStrip[3][8][9][112]=",0,(char*)NULL);
14618 }
14619 G__tag_memvar_reset();
14620 }
14621
14622
14623
14624 static void G__setup_memvarBesGeometry(void) {
14625 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
14626 { BesGeometry *p; p=(BesGeometry*)0x1000; if (p) { }
14627 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BesR=",0,(char*)NULL);
14628 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BesZ=",0,(char*)NULL);
14629 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BeamPipeRMin=",0,(char*)NULL);
14630 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BeamPipeRMax=",0,(char*)NULL);
14631 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_BeamPipeZ=",0,(char*)NULL);
14632 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Bes=",0,"Bes world volume");
14633 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_BeamPipe=",0,"Beam Pipe volume");
14634 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Mdc=",0,(char*)NULL);
14635 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Tof=",0,(char*)NULL);
14636 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Emc=",0,(char*)NULL);
14637 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"m_Muc=",0,(char*)NULL);
14638 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo),-1,-1,4,"m_MdcROOTGeo=",0,"MdcROOTGeo");
14639 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo),-1,-1,4,"m_TofROOTGeo=",0,"TofROOTGeo");
14640 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo),-1,-1,4,"m_EmcROOTGeo=",0,"EmcROOTGeo");
14641 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo),-1,-1,4,"m_MucROOTGeo=",0,"MucROOTGeo");
14642 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D),-1,-1,4,"m_BeamPipeXY=",0,(char*)NULL);
14643 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_BeamPipeZR=",0,(char*)NULL);
14644 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D),-1,-1,4,"m_ZRPlaneOnXY=",0,(char*)NULL);
14645 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14646 }
14647 G__tag_memvar_reset();
14648 }
14649
14650
14651
14652 static void G__setup_memvarBesGMenuTitle(void) {
14653 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle));
14654 { BesGMenuTitle *p; p=(BesGMenuTitle*)0x1000; if (p) { }
14655 G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPic=",0,"picture shown");
14656 G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixmap_t"),-1,2,"fPicHL=",0,"picture when selected");
14657 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14658 }
14659 G__tag_memvar_reset();
14660 }
14661
14662
14663
14664 static void G__setup_memvarBesGMenuBar(void) {
14665 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar));
14666 { BesGMenuBar *p; p=(BesGMenuBar*)0x1000; if (p) { }
14667 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14668 }
14669 G__tag_memvar_reset();
14670 }
14671
14672
14673
14674 static void G__setup_memvarBesGPictureButton(void) {
14675 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
14676 { BesGPictureButton *p; p=(BesGPictureButton*)0x1000; if (p) { }
14677 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGPicture),-1,-1,2,"fPicHL=",0,"picture shown when button selected");
14678 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fState=",0,(char*)NULL);
14679 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14680 }
14681 G__tag_memvar_reset();
14682 }
14683
14684
14685
14686 static void G__setup_memvarBesHeader(void) {
14687 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
14688 { BesHeader *p; p=(BesHeader*)0x1000; if (p) { }
14689 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMdcOn=",0,"show Mdc information on ?");
14690 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTofOn=",0,"show Tof information on ?");
14691 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEmcOn=",0,"show Emc information on ?");
14692 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14693 }
14694 G__tag_memvar_reset();
14695 }
14696
14697
14698
14699 static void G__setup_memvarBesVisDisplay(void) {
14700 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
14701 { BesVisDisplay *p; p=(BesVisDisplay*)0x1000; if (p) { }
14702 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDisplayMode=",0,"Flag for display mode, 0: 2D XY+ZR, 1: 2D XY, 2: 2D ZR, 3: 3D, 4: 2D+3D");
14703 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPadHeader=",0,(char*)NULL);
14704 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPadXY=",0,(char*)NULL);
14705 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPadZR=",0,(char*)NULL);
14706 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPad3D=",0,(char*)NULL);
14707 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader),-1,-1,4,"fBesHeader=",0,(char*)NULL);
14708 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TImage),-1,-1,4,"fHeaderImage=",0,(char*)NULL);
14709 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TImage),-1,-1,4,"fHeaderHImage=",0,(char*)NULL);
14710 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TImage),-1,-1,4,"fHeaderVImage=",0,(char*)NULL);
14711 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLatticeWidth=",0,"Lattice Width");
14712 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeTitle=",0,"Text Size: Title");
14713 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeTime=",0,"Text Size: Time");
14714 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeData=",0,"Text Size: Data");
14715 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTextSizeFlt=",0,"Text Size: FLT");
14716 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoordx=",0,"x coordinate of text");
14717 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoordy=",0,"y coordinate of text");
14718 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistanceOfRows=",0,"Distance between rows");
14719 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMdcOn=",0,(char*)NULL);
14720 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTofOn=",0,(char*)NULL);
14721 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEmcOn=",0,(char*)NULL);
14722 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry),-1,-1,4,"fBesGeometry=",0,(char*)NULL);
14723 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawAllViews=",0,"Flag True if AllViews selected");
14724 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawParticles=",0,"Flag True if particles to be drawn");
14725 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawParticles2=",0,(char*)NULL);
14726 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawClusters=",0,"Flag True if clusters to be drawn");
14727 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPTcut=",0,"PT cut to display objects");
14728 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPTcutEGMUNU=",0,"PT cut for Electrons, Gammas, MUons, Neutrinos");
14729 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRin=",0,"Inner ATLAS radius");
14730 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRout=",0,"Outer ATLAS radius");
14731 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZin=",0,"Inner ATLAS length along Z");
14732 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZout=",0,"Outer ATLAS length along Z");
14733 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTheta=",0,"Viewing angle theta");
14734 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPhi=",0,"Viewing angle phi");
14735 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBesR=",0,"BesR");
14736 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBesZ=",0,"BesZ");
14737 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TCanvas),-1,-1,4,"fCanvas=",0,"Pointer to the display canvas");
14738 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fTrigPad=",0,"Pointer to the trigger pad ");
14739 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fButtons=",0,"Pointer to the buttons pad");
14740 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad),-1,-1,4,"fPad=",0,"Pointer to the event display main pad");
14741 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fEM1=",0,"Pointer to arc showing ON/OFF trigger EM1");
14742 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fPH1=",0,"Pointer to arc showing ON/OFF trigger PH1");
14743 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fEM2=",0,"Pointer to arc showing ON/OFF trigger EM2");
14744 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fMU1=",0,"Pointer to arc showing ON/OFF trigger MU1");
14745 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fMU2=",0,"Pointer to arc showing ON/OFF trigger MU2");
14746 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fEMU=",0,"Pointer to arc showing ON/OFF trigger EMU");
14747 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fJT1=",0,"Pointer to arc showing ON/OFF trigger JT1");
14748 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fJT3=",0,"Pointer to arc showing ON/OFF trigger JT3");
14749 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fJT4=",0,"Pointer to arc showing ON/OFF trigger JT4");
14750 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TArc),-1,-1,4,"fALL=",0,"Pointer to arc showing ON/OFF trigger ALL");
14751 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume),-1,-1,4,"fBes=",0,"Bes world volume");
14752 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRayPicCount=",0,"Counter of picture");
14753 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo),-1,-1,4,"fMdcROOTGeo=",0,"MdcROOTGeo");
14754 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo),-1,-1,4,"fTofROOTGeo=",0,"TofROOTGeo");
14755 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo),-1,-1,4,"fEmcROOTGeo=",0,"EmcROOTGeo");
14756 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo),-1,-1,4,"fMucROOTGeo=",0,"MucROOTGeo");
14757 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMdcCon=",0,"Mdc Construction flag");
14758 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTofCon=",0,"Tof Construction flag");
14759 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEmcCon=",0,"Emc Construction flag");
14760 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMucCon=",0,"Muc Construction flag");
14761 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAllVis=",0,"All node visible flag");
14762 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fQuarterVis=",0,"Quarter visible flag");
14763 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHalfVis=",0,"Half visible flag");
14764 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNoEndVis=",0,"NoEnd visible flag");
14765 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),-1,-1,4,"fxyView=",0,"XY View pointer;");
14766 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),-1,-1,4,"fzrView=",0,"ZR View pointer;");
14767 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView),-1,-1,4,"f3DView=",0,"3D View pointer;");
14768 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14769 }
14770 G__tag_memvar_reset();
14771 }
14772
14773
14774
14775 static void G__setup_memvarZHelix(void) {
14776 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
14777 { ZHelix *p; p=(ZHelix*)0x1000; if (p) { }
14778 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TrackType),-1,-1,2,"fTrackType=",0,"Type of track");
14779 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAzim=",0,"Azimuth");
14780 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fQovR=",0,"Q/R");
14781 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fQxDh=",0,"Q*D_h");
14782 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTDip=",0,"tan(Dip)");
14783 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRefX=",0,"Helix reference point x coordinate");
14784 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRefY=",0,"Helix reference point y coordinate");
14785 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRefZ=",0,"Helix reference point z coordinate");
14786 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRange[2]=",0,"Range of helix (in phi)");
14787 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EZHelixRangeType),-1,-1,2,"fRType=",0,"Helix range type");
14788 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fChi2=",0,"Chi2 of the fit");
14789 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNDoF=",0,"Degrees of freedom");
14790 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSinAzim=",0,"Sin(Azimuth)");
14791 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCosAzim=",0,"Cos(Azimuth)");
14792 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRSign=",0,"! sign of radius");
14793 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiI=",0,"phi inner");
14794 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiO=",0,"phi outer");
14795 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEnable=",0,"enable of drawing of helix, could be set false for bad tracks");
14796 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14797 }
14798 G__tag_memvar_reset();
14799 }
14800
14801
14802
14803 static void G__setup_memvarvector3(void) {
14804 G__tag_memvar_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
14805 { vector3 *p; p=(vector3*)0x1000; if (p) { }
14806 G__memvar_setup((void*)((long)(&p->x)-(long)(p)),102,0,0,-1,-1,-1,1,"x=",0,(char*)NULL);
14807 G__memvar_setup((void*)((long)(&p->y)-(long)(p)),102,0,0,-1,-1,-1,1,"y=",0,(char*)NULL);
14808 G__memvar_setup((void*)((long)(&p->z)-(long)(p)),102,0,0,-1,-1,-1,1,"z=",0,(char*)NULL);
14809 }
14810 G__tag_memvar_reset();
14811 }
14812
14813 extern "C" void G__cpp_setup_memvarBesVisLib_rootcint() {
14814 }
14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827 static void G__setup_memfuncBesStatus(void) {
14828
14829 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus));
14830 G__memfunc_setup("BesStatus",926,G__BesVisLib_rootcint_169_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14831 G__memfunc_setup("Transfer",837,G__BesVisLib_rootcint_169_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
14832 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14833 G__memfunc_setup("TransferGeometryMdc",1957,G__BesVisLib_rootcint_169_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
14834 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14835 G__memfunc_setup("TransferGeometryTof",1978,G__BesVisLib_rootcint_169_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
14836 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14837 G__memfunc_setup("TransferGeometryEmc",1958,G__BesVisLib_rootcint_169_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
14838 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14839 G__memfunc_setup("TransferGeometryMuc",1974,G__BesVisLib_rootcint_169_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
14840 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14841 G__memfunc_setup("TransferGeometryFull3D",2203,G__BesVisLib_rootcint_169_0_7, 121, -1, -1, 0, 2, 1, 1, 0,
14842 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14843 G__memfunc_setup("TransferGeometryOtherParts",2717,G__BesVisLib_rootcint_169_0_8, 121, -1, -1, 0, 2, 1, 1, 0,
14844 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14845 G__memfunc_setup("TransferHitsMdc",1521,G__BesVisLib_rootcint_169_0_9, 121, -1, -1, 0, 2, 1, 1, 0,
14846 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14847 G__memfunc_setup("TransferHitsTof",1542,G__BesVisLib_rootcint_169_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
14848 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14849 G__memfunc_setup("TransferHitsEmc",1522,G__BesVisLib_rootcint_169_0_11, 121, -1, -1, 0, 2, 1, 1, 0,
14850 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14851 G__memfunc_setup("TransferHitsMuc",1538,G__BesVisLib_rootcint_169_0_12, 121, -1, -1, 0, 2, 1, 1, 0,
14852 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14853 G__memfunc_setup("TransferTracks",1453,G__BesVisLib_rootcint_169_0_13, 121, -1, -1, 0, 2, 1, 1, 0,
14854 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14855 G__memfunc_setup("TransferFishEye",1522,G__BesVisLib_rootcint_169_0_14, 121, -1, -1, 0, 2, 1, 1, 0,
14856 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14857 G__memfunc_setup("TransferPhiRange",1619,G__BesVisLib_rootcint_169_0_15, 121, -1, -1, 0, 2, 1, 1, 0,
14858 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14859 G__memfunc_setup("TransferZoom",1258,G__BesVisLib_rootcint_169_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
14860 "U 'BesStatus' - 0 - right g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
14861 G__memfunc_setup("Default",709,G__BesVisLib_rootcint_169_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EBESViewType' - 0 - type", (char*)NULL, (void*) NULL, 0);
14862 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_169_0_18, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesStatus::Class) ), 0);
14863 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_169_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesStatus::Class_Name) ), 0);
14864 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_169_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesStatus::Class_Version) ), 0);
14865 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_169_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesStatus::Dictionary) ), 0);
14866 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14867 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
14868 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
14869 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_169_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
14870 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_169_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesStatus::DeclFileName) ), 0);
14871 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_169_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesStatus::ImplFileLine) ), 0);
14872 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_169_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesStatus::ImplFileName) ), 0);
14873 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_169_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesStatus::DeclFileLine) ), 0);
14874
14875 G__memfunc_setup("BesStatus", 926, G__BesVisLib_rootcint_169_0_30, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 1, 1, 1, 0, "u 'BesStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
14876
14877 G__memfunc_setup("~BesStatus", 1052, G__BesVisLib_rootcint_169_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14878
14879 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_169_0_32, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 1, 1, 1, 1, 0, "u 'BesStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
14880 G__tag_memfunc_reset();
14881 }
14882
14883 static void G__setup_memfuncBesTView(void) {
14884
14885 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView));
14886 G__memfunc_setup("BesTView",777,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 1, 1, 2, 0, "u 'BesTView' - 11 - -", "Not implemented", (void*) NULL, 0);
14887 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 1, 1, 1, 2, 0, "u 'BesTView' - 11 - -", "Not implemented", (void*) NULL, 0);
14888 G__memfunc_setup("ResetView",926,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0,
14889 "d - 'Double_t' 0 - longitude d - 'Double_t' 0 - latitude "
14890 "d - 'Double_t' 0 - psi i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 0);
14891 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_4, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14892 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_5, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - system", (char*)NULL, (void*) NULL, 0);
14893 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_6, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 3, 1, 1, 0,
14894 "F - 'Float_t' 10 - rmin F - 'Float_t' 10 - rmax "
14895 "i - 'Int_t' 0 '1' system", (char*)NULL, (void*) NULL, 0);
14896 G__memfunc_setup("BesTView",777,G__BesVisLib_rootcint_175_0_7, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesTView), -1, 0, 3, 1, 1, 0,
14897 "D - 'Double_t' 10 - rmin D - 'Double_t' 10 - rmax "
14898 "i - 'Int_t' 0 '1' system", (char*)NULL, (void*) NULL, 0);
14899 G__memfunc_setup("AxisVertex",1043,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0,
14900 "d - 'Double_t' 0 - ang D - 'Double_t' 0 - av "
14901 "i - 'Int_t' 1 - ix1 i - 'Int_t' 1 - ix2 "
14902 "i - 'Int_t' 1 - iy1 i - 'Int_t' 1 - iy2 "
14903 "i - 'Int_t' 1 - iz1 i - 'Int_t' 1 - iz2", (char*)NULL, (void*) NULL, 1);
14904 G__memfunc_setup("DefinePerspectiveView",2160,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14905 G__memfunc_setup("DefineViewDirection",1927,(G__InterfaceMethod) NULL,121, -1, -1, 0, 10, 1, 1, 0,
14906 "D - 'Double_t' 10 - s D - 'Double_t' 10 - c "
14907 "d - 'Double_t' 0 - cosphi d - 'Double_t' 0 - sinphi "
14908 "d - 'Double_t' 0 - costhe d - 'Double_t' 0 - sinthe "
14909 "d - 'Double_t' 0 - cospsi d - 'Double_t' 0 - sinpsi "
14910 "D - 'Double_t' 0 - tnorm D - 'Double_t' 0 - tback", (char*)NULL, (void*) NULL, 1);
14911 G__memfunc_setup("DrawOutlineCube",1517,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14912 "U 'TList' - 0 - outline D - 'Double_t' 0 - rmin "
14913 "D - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 1);
14914 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14915 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
14916 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14917 G__memfunc_setup("ExecuteRotateView",1757,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14918 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
14919 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14920 G__memfunc_setup("FindScope",891,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14921 "D - 'Double_t' 0 - scale D - 'Double_t' 0 - center "
14922 "i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 1);
14923 G__memfunc_setup("GetDistancetoAxis",1731,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0,
14924 "i - 'Int_t' 0 - axis i - 'Int_t' 0 - px "
14925 "i - 'Int_t' 0 - py d - 'Double_t' 1 - ratio", (char*)NULL, (void*) NULL, 1);
14926 G__memfunc_setup("GetDview",799,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14927 G__memfunc_setup("GetDproj",799,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14928 G__memfunc_setup("GetExtent",920,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14929 G__memfunc_setup("GetAutoRange",1190,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14930 G__memfunc_setup("GetLatitude",1116,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14931 G__memfunc_setup("GetLongitude",1227,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14932 G__memfunc_setup("GetPsi",588,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14933 G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14934 "F - 'Float_t' 0 - min F - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
14935 G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14936 "D - 'Double_t' 0 - min D - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 1);
14937 G__memfunc_setup("GetRmax",696,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14938 G__memfunc_setup("GetRmin",694,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14939 G__memfunc_setup("GetOutline",1024,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TSeqCollection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14940 G__memfunc_setup("GetTback",773,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14941 G__memfunc_setup("GetTN",450,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14942 G__memfunc_setup("GetTnorm",816,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14943 G__memfunc_setup("GetSystem",933,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14944 G__memfunc_setup("GetWindow",920,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8,
14945 "d - 'Double_t' 1 - u0 d - 'Double_t' 1 - v0 "
14946 "d - 'Double_t' 1 - du d - 'Double_t' 1 - dv", (char*)NULL, (void*) NULL, 1);
14947 G__memfunc_setup("GetWindowWidth",1432,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14948 G__memfunc_setup("GetWindowHeight",1521,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14949 G__memfunc_setup("FindNormal",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
14950 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14951 "d - 'Double_t' 0 - z d - 'Double_t' 1 - zn", (char*)NULL, (void*) NULL, 1);
14952 G__memfunc_setup("FindPhiSectors",1413,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
14953 "i - 'Int_t' 0 - iopt i - 'Int_t' 1 - kphi "
14954 "D - 'Double_t' 0 - aphi i - 'Int_t' 1 - iphi1 "
14955 "i - 'Int_t' 1 - iphi2", (char*)NULL, (void*) NULL, 1);
14956 G__memfunc_setup("FindThetaSectors",1626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0,
14957 "i - 'Int_t' 0 - iopt d - 'Double_t' 0 - phi "
14958 "i - 'Int_t' 1 - kth D - 'Double_t' 0 - ath "
14959 "i - 'Int_t' 1 - ith1 i - 'Int_t' 1 - ith2", (char*)NULL, (void*) NULL, 1);
14960 G__memfunc_setup("IsClippedNDC",1106,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 1);
14961 G__memfunc_setup("IsPerspective",1350,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14962 G__memfunc_setup("IsViewChanged",1281,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14963 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14964 "F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
14965 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14966 "D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
14967 G__memfunc_setup("NormalWCtoNDC",1211,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14968 "F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
14969 G__memfunc_setup("NormalWCtoNDC",1211,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14970 "D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
14971 G__memfunc_setup("PadRange",770,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rback", (char*)NULL, (void*) NULL, 1);
14972 G__memfunc_setup("ResizePad",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14973 G__memfunc_setup("SetAutoRange",1202,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autorange", (char*)NULL, (void*) NULL, 1);
14974 G__memfunc_setup("SetAxisNDC",918,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0,
14975 "D - 'Double_t' 10 - x1 D - 'Double_t' 10 - x2 "
14976 "D - 'Double_t' 10 - y1 D - 'Double_t' 10 - y2 "
14977 "D - 'Double_t' 10 - z1 D - 'Double_t' 10 - z2", (char*)NULL, (void*) NULL, 1);
14978 G__memfunc_setup("SetDefaultWindow",1641,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14979 G__memfunc_setup("SetDview",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dview", (char*)NULL, (void*) NULL, 1);
14980 G__memfunc_setup("SetDproj",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dproj", (char*)NULL, (void*) NULL, 1);
14981 G__memfunc_setup("SetLatitude",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - latitude", (char*)NULL, (void*) NULL, 1);
14982 G__memfunc_setup("SetLongitude",1239,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - longitude", (char*)NULL, (void*) NULL, 1);
14983 G__memfunc_setup("SetPsi",600,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - psi", (char*)NULL, (void*) NULL, 1);
14984 G__memfunc_setup("SetOutlineToCube",1614,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14985 G__memfunc_setup("SetParallel",1113,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
14986 G__memfunc_setup("SetPerspective",1462,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
14987 G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14988 "D - 'Double_t' 10 - min D - 'Double_t' 10 - max", (char*)NULL, (void*) NULL, 1);
14989 G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0,
14990 "d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
14991 "d - 'Double_t' 0 - z0 d - 'Double_t' 0 - x1 "
14992 "d - 'Double_t' 0 - y1 d - 'Double_t' 0 - z1 "
14993 "i - 'Int_t' 0 '0' flag", (char*)NULL, (void*) NULL, 1);
14994 G__memfunc_setup("SetSystem",945,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - system", (char*)NULL, (void*) NULL, 1);
14995 G__memfunc_setup("SetView",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
14996 "d - 'Double_t' 0 - longitude d - 'Double_t' 0 - latitude "
14997 "d - 'Double_t' 0 - psi i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 1);
14998 G__memfunc_setup("SetViewChanged",1393,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
14999 G__memfunc_setup("SetWindow",932,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15000 "d - 'Double_t' 0 - u0 d - 'Double_t' 0 - v0 "
15001 "d - 'Double_t' 0 - du d - 'Double_t' 0 - dv", (char*)NULL, (void*) NULL, 1);
15002 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15003 "F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15004 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15005 "D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15006 G__memfunc_setup("MoveFocus",919,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0,
15007 "D - 'Double_t' 0 - center d - 'Double_t' 0 - dx "
15008 "d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
15009 "i - 'Int_t' 0 '10' nsteps d - 'Double_t' 0 '0' dlong "
15010 "d - 'Double_t' 0 '0' dlat d - 'Double_t' 0 '0' dpsi", (char*)NULL, (void*) NULL, 1);
15011 G__memfunc_setup("MoveViewCommand",1521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15012 "c - 'Char_t' 0 - chCode i - 'Int_t' 0 '1' count", (char*)NULL, (void*) NULL, 1);
15013 G__memfunc_setup("MoveWindow",1039,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - option", (char*)NULL, (void*) NULL, 1);
15014 G__memfunc_setup("AdjustPad",896,G__BesVisLib_rootcint_175_0_69, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) G__func2void( (void (*)(TVirtualPad*))(&BesTView::AdjustPad) ), 0);
15015 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", "*MENU*", (void*) NULL, 1);
15016 G__memfunc_setup("Centered3DImages",1527,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15017 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15018 G__memfunc_setup("FrontView",932,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15019 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15020 G__memfunc_setup("ZoomIn",604,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15021 G__memfunc_setup("ZoomOut",733,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15022 G__memfunc_setup("ZoomView",832,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15023 "U 'TVirtualPad' - 0 '0' pad d - 'Double_t' 0 '1.25' zoomFactor", (char*)NULL, (void*) NULL, 1);
15024 G__memfunc_setup("UnzoomView",1059,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15025 "U 'TVirtualPad' - 0 '0' pad d - 'Double_t' 0 '1.25' unZoomFactor", (char*)NULL, (void*) NULL, 1);
15026 G__memfunc_setup("RotateView",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15027 "d - 'Double_t' 0 - phi d - 'Double_t' 0 - theta "
15028 "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15029 G__memfunc_setup("SideView",800,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15030 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15031 G__memfunc_setup("TopView",718,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15032 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15033 G__memfunc_setup("ToggleRulers",1247,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15034 G__memfunc_setup("ShowAxis",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15035 G__memfunc_setup("ToggleZoom",1031,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15036 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15037 G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15038 G__memfunc_setup("UnZoom",616,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15039 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_175_0_90, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesTView::Class) ), 0);
15040 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_175_0_91, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesTView::Class_Name) ), 0);
15041 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_175_0_92, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesTView::Class_Version) ), 0);
15042 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_175_0_93, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesTView::Dictionary) ), 0);
15043 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15044 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15045 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15046 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_175_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15047 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_175_0_98, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesTView::DeclFileName) ), 0);
15048 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_175_0_99, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesTView::ImplFileLine) ), 0);
15049 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_175_0_100, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesTView::ImplFileName) ), 0);
15050 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_175_0_101, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesTView::DeclFileLine) ), 0);
15051
15052 G__memfunc_setup("~BesTView", 903, G__BesVisLib_rootcint_175_0_102, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15053 G__tag_memfunc_reset();
15054 }
15055
15056 static void G__setup_memfuncBes2DView(void) {
15057
15058 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView));
15059 G__memfunc_setup("Bes2DView",811,G__BesVisLib_rootcint_182_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15060 G__memfunc_setup("ClearPad",764,G__BesVisLib_rootcint_182_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15061 G__memfunc_setup("DrawLabel",878,G__BesVisLib_rootcint_182_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15062 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15063 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15064 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15065 G__memfunc_setup("GetRSign",771,G__BesVisLib_rootcint_182_0_5, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "f - 'Float_t' 0 - Phi", (char*)NULL, (void*) NULL, 1);
15066 G__memfunc_setup("UpdateView",1022,G__BesVisLib_rootcint_182_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15067 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15068 "F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15069 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15070 "D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15071 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15072 "F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15073 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15074 "D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15075 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15076 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15077 G__memfunc_setup("Set2DViewType",1247,G__BesVisLib_rootcint_182_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - viewType", (char*)NULL, (void*) NULL, 0);
15078 G__memfunc_setup("Get2DViewType",1235,G__BesVisLib_rootcint_182_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15079 G__memfunc_setup("GetMarkerSize",1309,G__BesVisLib_rootcint_182_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15080 G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15081 G__memfunc_setup("UnZoom",616,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15082 G__memfunc_setup("Center",609,G__BesVisLib_rootcint_182_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15083 G__memfunc_setup("Move",407,G__BesVisLib_rootcint_182_0_18, 121, -1, -1, 0, 2, 1, 1, 0,
15084 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
15085 G__memfunc_setup("Reset",515,G__BesVisLib_rootcint_182_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15086 G__memfunc_setup("SetMarkerSize",1321,G__BesVisLib_rootcint_182_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - size", (char*)NULL, (void*) NULL, 0);
15087 G__memfunc_setup("GetFishEyeStatus",1617,G__BesVisLib_rootcint_182_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15088 G__memfunc_setup("GetFishEye",973,G__BesVisLib_rootcint_182_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15089 G__memfunc_setup("SetFishEye",985,G__BesVisLib_rootcint_182_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '0' input", "*TOGGLE*", (void*) NULL, 0);
15090 G__memfunc_setup("PrintCurrent",1264,G__BesVisLib_rootcint_182_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15091 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15092 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15093 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15094 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15095 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15096 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15097 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15098 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_182_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15099 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_182_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15100 G__memfunc_setup("Dump",406,G__BesVisLib_rootcint_182_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15101 G__memfunc_setup("Inspect",726,G__BesVisLib_rootcint_182_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15102 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15103 G__memfunc_setup("SetLineAttributes",1755,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15104 G__memfunc_setup("SetZoomFactor",1328,G__BesVisLib_rootcint_182_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 1);
15105 G__memfunc_setup("GetZoomFactor",1316,G__BesVisLib_rootcint_182_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15106 G__memfunc_setup("GetStatusCurrent",1671,G__BesVisLib_rootcint_182_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15107 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_182_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Bes2DView::Class) ), 0);
15108 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_182_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Bes2DView::Class_Name) ), 0);
15109 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_182_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Bes2DView::Class_Version) ), 0);
15110 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_182_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Bes2DView::Dictionary) ), 0);
15111 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15112 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15113 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15114 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_182_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15115 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_182_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Bes2DView::DeclFileName) ), 0);
15116 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_182_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Bes2DView::ImplFileLine) ), 0);
15117 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_182_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Bes2DView::ImplFileName) ), 0);
15118 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_182_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Bes2DView::DeclFileLine) ), 0);
15119
15120 G__memfunc_setup("Bes2DView", 811, G__BesVisLib_rootcint_182_0_53, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Bes2DView), -1, 0, 1, 1, 1, 0, "u 'Bes2DView' - 11 - -", (char*) NULL, (void*) NULL, 0);
15121
15122 G__memfunc_setup("~Bes2DView", 937, G__BesVisLib_rootcint_182_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15123 G__tag_memfunc_reset();
15124 }
15125
15126 static void G__setup_memfuncBesCircle2D(void) {
15127
15128 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D));
15129 G__memfunc_setup("BesCircle2D",994,G__BesVisLib_rootcint_199_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15130 G__memfunc_setup("BesCircle2D",994,G__BesVisLib_rootcint_199_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 0, 5, 1, 1, 0,
15131 "C - - 10 - name C - - 10 - title "
15132 "d - 'Double_t' 0 - innerRadius d - 'Double_t' 0 - outerRadius "
15133 "D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 0);
15134 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15135 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15136 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15137 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15138 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15139 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15140 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15141 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15142 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15143 G__memfunc_setup("SetCenter",909,G__BesVisLib_rootcint_199_0_8, 121, -1, -1, 0, 3, 1, 1, 0,
15144 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15145 "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
15146 G__memfunc_setup("GetCenter",897,G__BesVisLib_rootcint_199_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 1);
15147 G__memfunc_setup("SetNSegment",1101,G__BesVisLib_rootcint_199_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - np", (char*)NULL, (void*) NULL, 1);
15148 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_199_0_11, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesCircle2D::Class) ), 0);
15149 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_199_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCircle2D::Class_Name) ), 0);
15150 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_199_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesCircle2D::Class_Version) ), 0);
15151 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_199_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesCircle2D::Dictionary) ), 0);
15152 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15153 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15154 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15155 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_199_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15156 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_199_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCircle2D::DeclFileName) ), 0);
15157 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_199_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCircle2D::ImplFileLine) ), 0);
15158 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_199_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCircle2D::ImplFileName) ), 0);
15159 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_199_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCircle2D::DeclFileLine) ), 0);
15160
15161 G__memfunc_setup("BesCircle2D", 994, G__BesVisLib_rootcint_199_0_23, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 0, 1, 1, 1, 0, "u 'BesCircle2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15162
15163 G__memfunc_setup("~BesCircle2D", 1120, G__BesVisLib_rootcint_199_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15164
15165 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_199_0_25, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCircle2D), -1, 1, 1, 1, 1, 0, "u 'BesCircle2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15166 G__tag_memfunc_reset();
15167 }
15168
15169 static void G__setup_memfuncBesCursor(void) {
15170
15171 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor));
15172 G__memfunc_setup("BesCursor",920,G__BesVisLib_rootcint_201_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15173 G__memfunc_setup("SetType",718,G__BesVisLib_rootcint_201_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i 'EBESCursorType' - 0 - cursorType", (char*)NULL, (void*) NULL, 0);
15174 G__memfunc_setup("GetType",706,G__BesVisLib_rootcint_201_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESCursorType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15175 G__memfunc_setup("SetShowInfo",1113,G__BesVisLib_rootcint_201_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - show", (char*)NULL, (void*) NULL, 0);
15176 G__memfunc_setup("GetShowInfo",1101,G__BesVisLib_rootcint_201_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15177 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_201_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesCursor::Class) ), 0);
15178 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_201_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCursor::Class_Name) ), 0);
15179 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_201_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesCursor::Class_Version) ), 0);
15180 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_201_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesCursor::Dictionary) ), 0);
15181 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15182 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15183 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15184 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_201_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15185 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCursor::DeclFileName) ), 0);
15186 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCursor::ImplFileLine) ), 0);
15187 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_201_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesCursor::ImplFileName) ), 0);
15188 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_201_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesCursor::DeclFileLine) ), 0);
15189
15190 G__memfunc_setup("BesCursor", 920, G__BesVisLib_rootcint_201_0_18, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor), -1, 0, 1, 1, 1, 0, "u 'BesCursor' - 11 - -", (char*) NULL, (void*) NULL, 0);
15191
15192 G__memfunc_setup("~BesCursor", 1046, G__BesVisLib_rootcint_201_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15193
15194 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_201_0_20, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesCursor), -1, 1, 1, 1, 1, 0, "u 'BesCursor' - 11 - -", (char*) NULL, (void*) NULL, 0);
15195 G__tag_memfunc_reset();
15196 }
15197
15198 static void G__setup_memfuncBesEventHeader(void) {
15199
15200 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader));
15201 G__memfunc_setup("BesEventHeader",1381,G__BesVisLib_rootcint_202_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15202 G__memfunc_setup("SetEventHeaderGeneral",2101,G__BesVisLib_rootcint_202_0_2, 121, -1, -1, 0, 4, 1, 1, 0,
15203 "n - 'Long64_t' 0 - run n - 'Long64_t' 0 - event "
15204 "i - 'Int_t' 0 - time1 i - 'Int_t' 0 - time2", (char*)NULL, (void*) NULL, 1);
15205 G__memfunc_setup("SetEventTrig",1220,G__BesVisLib_rootcint_202_0_3, 121, -1, -1, 0, 3, 1, 1, 0,
15206 "i - 'Int_t' 0 - timeType u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - trigConditionVector "
15207 "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - trigChannelVector", (char*)NULL, (void*) NULL, 1);
15208 G__memfunc_setup("SetEventMC",958,G__BesVisLib_rootcint_202_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mc", (char*)NULL, (void*) NULL, 1);
15209 G__memfunc_setup("SetEventEvTime",1400,G__BesVisLib_rootcint_202_0_5, 121, -1, -1, 0, 3, 1, 1, 0,
15210 "d - 'Double_t' 0 - time i - 'Int_t' 0 - status "
15211 "d - 'Double_t' 0 - quality", (char*)NULL, (void*) NULL, 1);
15212 G__memfunc_setup("SetEventMdc",1090,G__BesVisLib_rootcint_202_0_6, 121, -1, -1, 0, 5, 1, 1, 0,
15213 "d - 'Double_t' 0 - p d - 'Double_t' 0 - pt "
15214 "d - 'Double_t' 0 - px d - 'Double_t' 0 - py "
15215 "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 1);
15216 G__memfunc_setup("SetEventTof",1111,G__BesVisLib_rootcint_202_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 1);
15217 G__memfunc_setup("SetEventEmc",1091,G__BesVisLib_rootcint_202_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - e", (char*)NULL, (void*) NULL, 1);
15218 G__memfunc_setup("PrintWord",937,G__BesVisLib_rootcint_202_0_9, 121, -1, -1, 0, 4, 1, 1, 8,
15219 "u 'TString' - 1 - word i - 'Int_t' 0 - nbits "
15220 "i - 'Int_t' 0 - trigger i - 'Int_t' 0 '0' trigger2", (char*)NULL, (void*) NULL, 0);
15221 G__memfunc_setup("GetRunNumber",1214,G__BesVisLib_rootcint_202_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15222 G__memfunc_setup("GetEventNumber",1419,G__BesVisLib_rootcint_202_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15223 G__memfunc_setup("GetEventMC",946,G__BesVisLib_rootcint_202_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15224 G__memfunc_setup("GetTimeType",1105,G__BesVisLib_rootcint_202_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15225 G__memfunc_setup("GetTrigChannelVector",2018,G__BesVisLib_rootcint_202_0_14, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15226 G__memfunc_setup("GetTrigConditionVector",2256,G__BesVisLib_rootcint_202_0_15, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15227 G__memfunc_setup("GetEventYear",1203,G__BesVisLib_rootcint_202_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15228 G__memfunc_setup("GetEventMonth",1320,G__BesVisLib_rootcint_202_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15229 G__memfunc_setup("GetEventDay",1088,G__BesVisLib_rootcint_202_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15230 G__memfunc_setup("GetEventHour",1216,G__BesVisLib_rootcint_202_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15231 G__memfunc_setup("GetEventMin",1094,G__BesVisLib_rootcint_202_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15232 G__memfunc_setup("GetEventSec",1085,G__BesVisLib_rootcint_202_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15233 G__memfunc_setup("GetEvTime",874,G__BesVisLib_rootcint_202_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15234 G__memfunc_setup("GetEvTimeStatus",1518,G__BesVisLib_rootcint_202_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15235 G__memfunc_setup("GetEvTimeQuality",1619,G__BesVisLib_rootcint_202_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15236 G__memfunc_setup("GetP",368,G__BesVisLib_rootcint_202_0_25, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15237 G__memfunc_setup("GetPt",484,G__BesVisLib_rootcint_202_0_26, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15238 G__memfunc_setup("GetPx",488,G__BesVisLib_rootcint_202_0_27, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15239 G__memfunc_setup("GetPy",489,G__BesVisLib_rootcint_202_0_28, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15240 G__memfunc_setup("GetPz",490,G__BesVisLib_rootcint_202_0_29, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15241 G__memfunc_setup("GetT",372,G__BesVisLib_rootcint_202_0_30, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15242 G__memfunc_setup("GetE",357,G__BesVisLib_rootcint_202_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15243 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_202_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesEventHeader::Class) ), 0);
15244 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_202_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEventHeader::Class_Name) ), 0);
15245 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_202_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesEventHeader::Class_Version) ), 0);
15246 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_202_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesEventHeader::Dictionary) ), 0);
15247 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15248 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15249 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15250 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_202_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15251 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_202_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEventHeader::DeclFileName) ), 0);
15252 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_202_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEventHeader::ImplFileLine) ), 0);
15253 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_202_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEventHeader::ImplFileName) ), 0);
15254 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_202_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEventHeader::DeclFileLine) ), 0);
15255
15256 G__memfunc_setup("BesEventHeader", 1381, G__BesVisLib_rootcint_202_0_44, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 0, 1, 1, 1, 0, "u 'BesEventHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
15257
15258 G__memfunc_setup("~BesEventHeader", 1507, G__BesVisLib_rootcint_202_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15259
15260 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_202_0_46, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 1, 1, 1, 1, 0, "u 'BesEventHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
15261 G__tag_memfunc_reset();
15262 }
15263
15264 static void G__setup_memfuncBesView(void) {
15265
15266 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView));
15267 G__memfunc_setup("BesView",693,G__BesVisLib_rootcint_242_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15268 G__memfunc_setup("SetViewType",1129,G__BesVisLib_rootcint_242_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15269 "i 'EBESViewType' - 0 - ViewType g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15270 G__memfunc_setup("SetViewTypeBare",1507,G__BesVisLib_rootcint_242_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
15271 "i 'EBESViewType' - 0 - ViewType g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15272 G__memfunc_setup("DefaultRange",1202,G__BesVisLib_rootcint_242_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15273 G__memfunc_setup("ClearPad",764,G__BesVisLib_rootcint_242_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15274 G__memfunc_setup("DrawLabel",878,G__BesVisLib_rootcint_242_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15275 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15276 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15277 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15278 G__memfunc_setup("GetRSign",771,G__BesVisLib_rootcint_242_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "f - 'Float_t' 0 - Phi", (char*)NULL, (void*) NULL, 1);
15279 G__memfunc_setup("UpdateView",1022,G__BesVisLib_rootcint_242_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' resetview", (char*)NULL, (void*) NULL, 1);
15280 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15281 "F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15282 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15283 "D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15284 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15285 "F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15286 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15287 "D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15288 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15289 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15290 G__memfunc_setup("SetZoomRatio",1232,G__BesVisLib_rootcint_242_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ratio", (char*)NULL, (void*) NULL, 0);
15291 G__memfunc_setup("GetZoomRatio",1220,G__BesVisLib_rootcint_242_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15292 G__memfunc_setup("GetViewType",1117,G__BesVisLib_rootcint_242_0_17, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EBESViewType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15293 G__memfunc_setup("GetMarkerSize",1309,G__BesVisLib_rootcint_242_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15294 G__memfunc_setup("View3D",530,G__BesVisLib_rootcint_242_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15295 G__memfunc_setup("ViewXY",588,G__BesVisLib_rootcint_242_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15296 G__memfunc_setup("ViewZR",583,G__BesVisLib_rootcint_242_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15297 G__memfunc_setup("ZoomIn",604,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15298 G__memfunc_setup("ZoomOut",733,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15299 G__memfunc_setup("Center",609,G__BesVisLib_rootcint_242_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15300 G__memfunc_setup("Move",407,G__BesVisLib_rootcint_242_0_25, 121, -1, -1, 0, 2, 1, 1, 0,
15301 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
15302 G__memfunc_setup("Front3D",640,G__BesVisLib_rootcint_242_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15303 G__memfunc_setup("Side3D",508,G__BesVisLib_rootcint_242_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15304 G__memfunc_setup("Top3D",426,G__BesVisLib_rootcint_242_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15305 G__memfunc_setup("SetPhiRange",1082,G__BesVisLib_rootcint_242_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
15306 "f - 'Float_t' 0 '0' PhiMin f - 'Float_t' 0 '180' PhiMax", (char*)NULL, (void*) NULL, 0);
15307 G__memfunc_setup("Reset",515,G__BesVisLib_rootcint_242_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
15308 G__memfunc_setup("SetMarkerSize",1321,G__BesVisLib_rootcint_242_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - size", (char*)NULL, (void*) NULL, 0);
15309 G__memfunc_setup("GetVisMdcGlobal",1463,G__BesVisLib_rootcint_242_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15310 G__memfunc_setup("GetVisMdcTubes",1385,G__BesVisLib_rootcint_242_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15311 G__memfunc_setup("GetVisMdcWires",1392,G__BesVisLib_rootcint_242_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15312 G__memfunc_setup("SetVisMdcGlobal",1475,G__BesVisLib_rootcint_242_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15313 G__memfunc_setup("SetVisMdcTubes",1397,G__BesVisLib_rootcint_242_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15314 G__memfunc_setup("SetVisMdcWires",1404,G__BesVisLib_rootcint_242_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15315 G__memfunc_setup("GetVisTofGlobal",1484,G__BesVisLib_rootcint_242_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15316 G__memfunc_setup("GetVisTofEast",1288,G__BesVisLib_rootcint_242_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15317 G__memfunc_setup("GetVisTofBarrel",1491,G__BesVisLib_rootcint_242_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15318 G__memfunc_setup("GetVisTofWest",1310,G__BesVisLib_rootcint_242_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15319 G__memfunc_setup("GetVisZoom",1015,G__BesVisLib_rootcint_242_0_42, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15320 G__memfunc_setup("SetVisTofGlobal",1496,G__BesVisLib_rootcint_242_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15321 G__memfunc_setup("SetVisTofEast",1300,G__BesVisLib_rootcint_242_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15322 G__memfunc_setup("SetVisTofBarrel",1503,G__BesVisLib_rootcint_242_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15323 G__memfunc_setup("SetVisTofWest",1322,G__BesVisLib_rootcint_242_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15324 G__memfunc_setup("SetVisZoom",1027,G__BesVisLib_rootcint_242_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15325 G__memfunc_setup("GetVisEmcGlobal",1464,G__BesVisLib_rootcint_242_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15326 G__memfunc_setup("GetVisEmcEast",1268,G__BesVisLib_rootcint_242_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15327 G__memfunc_setup("GetVisEmcBarrel",1471,G__BesVisLib_rootcint_242_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15328 G__memfunc_setup("GetVisEmcWest",1290,G__BesVisLib_rootcint_242_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15329 G__memfunc_setup("GetVisEmcSide",1260,G__BesVisLib_rootcint_242_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15330 G__memfunc_setup("SetVisEmcGlobal",1476,G__BesVisLib_rootcint_242_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15331 G__memfunc_setup("SetVisEmcEast",1280,G__BesVisLib_rootcint_242_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15332 G__memfunc_setup("SetVisEmcBarrel",1483,G__BesVisLib_rootcint_242_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15333 G__memfunc_setup("SetVisEmcWest",1302,G__BesVisLib_rootcint_242_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15334 G__memfunc_setup("SetVisEmcSide",1272,G__BesVisLib_rootcint_242_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15335 G__memfunc_setup("GetVisMucGlobal",1480,G__BesVisLib_rootcint_242_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15336 G__memfunc_setup("GetVisMucEast",1284,G__BesVisLib_rootcint_242_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15337 G__memfunc_setup("GetVisMucBarrel",1487,G__BesVisLib_rootcint_242_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15338 G__memfunc_setup("GetVisMucWest",1306,G__BesVisLib_rootcint_242_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15339 G__memfunc_setup("GetVisMucStrips",1532,G__BesVisLib_rootcint_242_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15340 G__memfunc_setup("SetVisMucGlobal",1492,G__BesVisLib_rootcint_242_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15341 G__memfunc_setup("SetVisMucEast",1296,G__BesVisLib_rootcint_242_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15342 G__memfunc_setup("SetVisMucBarrel",1499,G__BesVisLib_rootcint_242_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15343 G__memfunc_setup("SetVisMucWest",1318,G__BesVisLib_rootcint_242_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15344 G__memfunc_setup("SetVisMucStrips",1544,G__BesVisLib_rootcint_242_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15345 G__memfunc_setup("GetVisFull3DMdc",1392,G__BesVisLib_rootcint_242_0_68, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15346 G__memfunc_setup("GetVisFull3DTof",1413,G__BesVisLib_rootcint_242_0_69, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15347 G__memfunc_setup("GetVisFull3DEmc",1393,G__BesVisLib_rootcint_242_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15348 G__memfunc_setup("GetVisFull3DMuc",1409,G__BesVisLib_rootcint_242_0_71, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15349 G__memfunc_setup("SetVisFull3DMdc",1404,G__BesVisLib_rootcint_242_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15350 G__memfunc_setup("SetVisFull3DTof",1425,G__BesVisLib_rootcint_242_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15351 G__memfunc_setup("SetVisFull3DEmc",1405,G__BesVisLib_rootcint_242_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15352 G__memfunc_setup("SetVisFull3DMuc",1421,G__BesVisLib_rootcint_242_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15353 G__memfunc_setup("GetVisBeamPipe",1365,G__BesVisLib_rootcint_242_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15354 G__memfunc_setup("GetVisZRPlaneOnXY",1628,G__BesVisLib_rootcint_242_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15355 G__memfunc_setup("GetVisAxis",999,G__BesVisLib_rootcint_242_0_78, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15356 G__memfunc_setup("SetVisBeamPipe",1377,G__BesVisLib_rootcint_242_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15357 G__memfunc_setup("SetVisZRPlaneOnXY",1640,G__BesVisLib_rootcint_242_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15358 G__memfunc_setup("SetVisAxis",1011,G__BesVisLib_rootcint_242_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15359 G__memfunc_setup("GetVisMdcHitsGlobal",1871,G__BesVisLib_rootcint_242_0_82, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15360 G__memfunc_setup("GetVisMdcHits",1278,G__BesVisLib_rootcint_242_0_83, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15361 G__memfunc_setup("SetVisMdcHitsGlobal",1883,G__BesVisLib_rootcint_242_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15362 G__memfunc_setup("SetVisMdcHits",1290,G__BesVisLib_rootcint_242_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15363 G__memfunc_setup("GetVisTofHitsGlobal",1892,G__BesVisLib_rootcint_242_0_86, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15364 G__memfunc_setup("GetVisTofHitsEast",1696,G__BesVisLib_rootcint_242_0_87, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15365 G__memfunc_setup("GetVisTofHitsBarrel",1899,G__BesVisLib_rootcint_242_0_88, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15366 G__memfunc_setup("GetVisTofHitsWest",1718,G__BesVisLib_rootcint_242_0_89, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15367 G__memfunc_setup("SetVisTofHitsGlobal",1904,G__BesVisLib_rootcint_242_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15368 G__memfunc_setup("SetVisTofHitsEast",1708,G__BesVisLib_rootcint_242_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15369 G__memfunc_setup("SetVisTofHitsBarrel",1911,G__BesVisLib_rootcint_242_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15370 G__memfunc_setup("SetVisTofHitsWest",1730,G__BesVisLib_rootcint_242_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15371 G__memfunc_setup("GetVisEmcHitsGlobal",1872,G__BesVisLib_rootcint_242_0_94, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15372 G__memfunc_setup("GetVisEmcHitsEast",1676,G__BesVisLib_rootcint_242_0_95, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15373 G__memfunc_setup("GetVisEmcHitsBarrel",1879,G__BesVisLib_rootcint_242_0_96, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15374 G__memfunc_setup("GetVisEmcHitsWest",1698,G__BesVisLib_rootcint_242_0_97, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15375 G__memfunc_setup("GetVisEmcHitsSide",1668,G__BesVisLib_rootcint_242_0_98, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15376 G__memfunc_setup("SetVisEmcHitsGlobal",1884,G__BesVisLib_rootcint_242_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15377 G__memfunc_setup("SetVisEmcHitsEast",1688,G__BesVisLib_rootcint_242_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15378 G__memfunc_setup("SetVisEmcHitsBarrel",1891,G__BesVisLib_rootcint_242_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15379 G__memfunc_setup("SetVisEmcHitsWest",1710,G__BesVisLib_rootcint_242_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15380 G__memfunc_setup("SetVisEmcHitsSide",1680,G__BesVisLib_rootcint_242_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15381 G__memfunc_setup("GetVisMucHitsGlobal",1888,G__BesVisLib_rootcint_242_0_104, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15382 G__memfunc_setup("GetVisMucHitsEast",1692,G__BesVisLib_rootcint_242_0_105, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15383 G__memfunc_setup("GetVisMucHitsBarrel",1895,G__BesVisLib_rootcint_242_0_106, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15384 G__memfunc_setup("GetVisMucHitsWest",1714,G__BesVisLib_rootcint_242_0_107, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15385 G__memfunc_setup("SetVisMucHitsGlobal",1900,G__BesVisLib_rootcint_242_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15386 G__memfunc_setup("SetVisMucHitsEast",1704,G__BesVisLib_rootcint_242_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15387 G__memfunc_setup("SetVisMucHitsBarrel",1907,G__BesVisLib_rootcint_242_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15388 G__memfunc_setup("SetVisMucHitsWest",1726,G__BesVisLib_rootcint_242_0_111, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15389 G__memfunc_setup("GetVisTracksGlobal",1803,G__BesVisLib_rootcint_242_0_112, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15390 G__memfunc_setup("GetVisTracksMdc",1486,G__BesVisLib_rootcint_242_0_113, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15391 G__memfunc_setup("GetVisTracksTof",1507,G__BesVisLib_rootcint_242_0_114, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15392 G__memfunc_setup("GetVisTracksEmc",1487,G__BesVisLib_rootcint_242_0_115, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15393 G__memfunc_setup("GetVisTracksMuc",1503,G__BesVisLib_rootcint_242_0_116, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15394 G__memfunc_setup("GetVisTracksExt",1515,G__BesVisLib_rootcint_242_0_117, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15395 G__memfunc_setup("SetVisTracksGlobal",1815,G__BesVisLib_rootcint_242_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15396 G__memfunc_setup("SetVisTracksMdc",1498,G__BesVisLib_rootcint_242_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15397 G__memfunc_setup("SetVisTracksTof",1519,G__BesVisLib_rootcint_242_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15398 G__memfunc_setup("SetVisTracksEmc",1499,G__BesVisLib_rootcint_242_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15399 G__memfunc_setup("SetVisTracksMuc",1515,G__BesVisLib_rootcint_242_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15400 G__memfunc_setup("SetVisTracksExt",1527,G__BesVisLib_rootcint_242_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15401 G__memfunc_setup("GetFishEyeStatus",1617,G__BesVisLib_rootcint_242_0_124, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15402 G__memfunc_setup("GetFishEye",973,G__BesVisLib_rootcint_242_0_125, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15403 G__memfunc_setup("SetFishEye",985,G__BesVisLib_rootcint_242_0_126, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '0' input", "*TOGGLE*", (void*) NULL, 0);
15404 G__memfunc_setup("PrintCurrent",1264,G__BesVisLib_rootcint_242_0_127, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15405 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15406 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15407 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15408 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15409 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15410 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15411 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15412 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_242_0_135, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15413 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_242_0_136, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15414 G__memfunc_setup("Dump",406,G__BesVisLib_rootcint_242_0_137, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15415 G__memfunc_setup("Inspect",726,G__BesVisLib_rootcint_242_0_138, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15416 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15417 G__memfunc_setup("SetLineAttributes",1755,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15418 G__memfunc_setup("SetZoomFactor",1328,G__BesVisLib_rootcint_242_0_141, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 1);
15419 G__memfunc_setup("GetZoomFactor",1316,G__BesVisLib_rootcint_242_0_142, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15420 G__memfunc_setup("GetStatusCurrent",1671,G__BesVisLib_rootcint_242_0_143, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15421 G__memfunc_setup("GetStatus3D",1051,G__BesVisLib_rootcint_242_0_144, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15422 G__memfunc_setup("GetStatusXY",1109,G__BesVisLib_rootcint_242_0_145, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15423 G__memfunc_setup("GetStatusZR",1104,G__BesVisLib_rootcint_242_0_146, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15424 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_242_0_147, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesView::Class) ), 0);
15425 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_242_0_148, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesView::Class_Name) ), 0);
15426 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_242_0_149, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesView::Class_Version) ), 0);
15427 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_242_0_150, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesView::Dictionary) ), 0);
15428 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15429 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15430 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15431 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_242_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15432 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_242_0_155, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesView::DeclFileName) ), 0);
15433 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_242_0_156, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesView::ImplFileLine) ), 0);
15434 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_242_0_157, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesView::ImplFileName) ), 0);
15435 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_242_0_158, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesView::DeclFileLine) ), 0);
15436
15437 G__memfunc_setup("BesView", 693, G__BesVisLib_rootcint_242_0_159, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesView), -1, 0, 1, 1, 1, 0, "u 'BesView' - 11 - -", (char*) NULL, (void*) NULL, 0);
15438
15439 G__memfunc_setup("~BesView", 819, G__BesVisLib_rootcint_242_0_160, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15440 G__tag_memfunc_reset();
15441 }
15442
15443 static void G__setup_memfuncBesMarker2D(void) {
15444
15445 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D));
15446 G__memfunc_setup("BesMarker2D",1010,G__BesVisLib_rootcint_243_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15447 G__memfunc_setup("BesMarker2D",1010,G__BesVisLib_rootcint_243_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 5, 1, 1, 0,
15448 "C - - 10 - name C - - 10 - title "
15449 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
15450 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
15451 G__memfunc_setup("BesMarker2D",1010,G__BesVisLib_rootcint_243_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 5, 1, 1, 0,
15452 "C - - 10 - name C - - 10 - title "
15453 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15454 "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
15455 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15456 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15457 G__memfunc_setup("GetCenterPixel",1411,G__BesVisLib_rootcint_243_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
15458 "i - 'Int_t' 1 - px i - 'Int_t' 1 - py", (char*)NULL, (void*) NULL, 1);
15459 G__memfunc_setup("SetMarkerSizeMultiple",2165,G__BesVisLib_rootcint_243_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15460 G__memfunc_setup("GetMarkerSizeMultiple",2153,G__BesVisLib_rootcint_243_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15461 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15462 G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15463 G__memfunc_setup("GetWCX",530,G__BesVisLib_rootcint_243_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15464 G__memfunc_setup("GetWCY",531,G__BesVisLib_rootcint_243_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15465 G__memfunc_setup("GetWCZ",532,G__BesVisLib_rootcint_243_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15466 G__memfunc_setup("SetWCX",542,G__BesVisLib_rootcint_243_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15467 G__memfunc_setup("SetWCY",543,G__BesVisLib_rootcint_243_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15468 G__memfunc_setup("SetWCZ",544,G__BesVisLib_rootcint_243_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - input", (char*)NULL, (void*) NULL, 1);
15469 G__memfunc_setup("SetParameter",1229,G__BesVisLib_rootcint_243_0_17, 121, -1, -1, 0, 5, 1, 1, 0,
15470 "C - - 10 - name C - - 10 - title "
15471 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
15472 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
15473 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15474 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15475 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_243_0_19, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesMarker2D::Class) ), 0);
15476 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_243_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesMarker2D::Class_Name) ), 0);
15477 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_243_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesMarker2D::Class_Version) ), 0);
15478 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_243_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesMarker2D::Dictionary) ), 0);
15479 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15480 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15481 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15482 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_243_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15483 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_243_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesMarker2D::DeclFileName) ), 0);
15484 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_243_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesMarker2D::ImplFileLine) ), 0);
15485 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_243_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesMarker2D::ImplFileName) ), 0);
15486 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_243_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesMarker2D::DeclFileLine) ), 0);
15487
15488 G__memfunc_setup("BesMarker2D", 1010, G__BesVisLib_rootcint_243_0_31, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 0, 1, 1, 1, 0, "u 'BesMarker2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15489
15490 G__memfunc_setup("~BesMarker2D", 1136, G__BesVisLib_rootcint_243_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15491
15492 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_243_0_33, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesMarker2D), -1, 1, 1, 1, 1, 0, "u 'BesMarker2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15493 G__tag_memfunc_reset();
15494 }
15495
15496 static void G__setup_memfuncBesPaveText(void) {
15497
15498 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText));
15499 G__memfunc_setup("BesPaveText",1099,G__BesVisLib_rootcint_244_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15500 G__memfunc_setup("BesPaveText",1099,G__BesVisLib_rootcint_244_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 0, 5, 1, 1, 0,
15501 "d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
15502 "d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
15503 "C - 'Option_t' 10 '\"br\"' option", (char*)NULL, (void*) NULL, 0);
15504 G__memfunc_setup("BesPaveText",1099,G__BesVisLib_rootcint_244_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 0, 1, 1, 1, 0, "u 'BesPaveText' - 11 - pavetext", (char*)NULL, (void*) NULL, 0);
15505 G__memfunc_setup("SetText",721,G__BesVisLib_rootcint_244_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TString,allocator<TString> >' 'vector<TString>' 0 - infoCon", (char*)NULL, (void*) NULL, 1);
15506 G__memfunc_setup("SetPos",606,G__BesVisLib_rootcint_244_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
15507 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15508 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_244_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesPaveText::Class) ), 0);
15509 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_244_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPaveText::Class_Name) ), 0);
15510 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_244_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesPaveText::Class_Version) ), 0);
15511 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_244_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesPaveText::Dictionary) ), 0);
15512 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15513 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15514 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15515 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_244_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15516 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_244_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPaveText::DeclFileName) ), 0);
15517 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_244_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPaveText::ImplFileLine) ), 0);
15518 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_244_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPaveText::ImplFileName) ), 0);
15519 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_244_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPaveText::DeclFileLine) ), 0);
15520
15521 G__memfunc_setup("~BesPaveText", 1225, G__BesVisLib_rootcint_244_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15522
15523 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_244_0_19, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPaveText), -1, 1, 1, 1, 1, 0, "u 'BesPaveText' - 11 - -", (char*) NULL, (void*) NULL, 0);
15524 G__tag_memfunc_reset();
15525 }
15526
15527 static void G__setup_memfuncBesGeoTrack(void) {
15528
15529 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack));
15530 G__memfunc_setup("BesGeoTrack",1066,G__BesVisLib_rootcint_249_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15531 G__memfunc_setup("BesGeoTrack",1066,G__BesVisLib_rootcint_249_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeoTrack), -1, 0, 4, 1, 1, 0,
15532 "i - 'Int_t' 0 - id i - 'Int_t' 0 - pdgcode "
15533 "U 'TVirtualGeoTrack' - 0 '0' parent U 'TObject' - 0 '0' particle", (char*)NULL, (void*) NULL, 0);
15534 G__memfunc_setup("Init",404,G__BesVisLib_rootcint_249_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15535 G__memfunc_setup("AddHit",558,G__BesVisLib_rootcint_249_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15536 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_249_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
15537 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_249_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15538 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_249_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 1);
15539 G__memfunc_setup("SetTrackType",1219,G__BesVisLib_rootcint_249_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
15540 G__memfunc_setup("AddPoint",787,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15541 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15542 "d - 'Double_t' 0 - z d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 1);
15543 G__memfunc_setup("SetMarker",910,G__BesVisLib_rootcint_249_0_10, 121, -1, -1, 0, 3, 1, 1, 0,
15544 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15545 "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
15546 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15547 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15548 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15549 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15550 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15551 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15552 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15553 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15554 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15555 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_249_0_16, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGeoTrack::Class) ), 0);
15556 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_249_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeoTrack::Class_Name) ), 0);
15557 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_249_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGeoTrack::Class_Version) ), 0);
15558 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_249_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGeoTrack::Dictionary) ), 0);
15559 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15560 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15561 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15562 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_249_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15563 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_249_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeoTrack::DeclFileName) ), 0);
15564 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_249_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeoTrack::ImplFileLine) ), 0);
15565 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_249_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeoTrack::ImplFileName) ), 0);
15566 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_249_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeoTrack::DeclFileLine) ), 0);
15567
15568 G__memfunc_setup("~BesGeoTrack", 1192, G__BesVisLib_rootcint_249_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15569 G__tag_memfunc_reset();
15570 }
15571
15572 static void G__setup_memfuncBesEvent(void) {
15573
15574 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent));
15575 G__memfunc_setup("Is_tofBarrel",1212,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 4, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
15576 G__memfunc_setup("Is_tofCounter",1348,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 4, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
15577 G__memfunc_setup("BesEvent",796,G__BesVisLib_rootcint_529_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15578 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15579 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15580 G__memfunc_setup("Print",525,G__BesVisLib_rootcint_529_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15581 G__memfunc_setup("SetEvent",814,G__BesVisLib_rootcint_529_0_7, 121, -1, -1, 0, 4, 1, 1, 0,
15582 "U 'TDigiEvent' - 0 - digiEvent U 'TDisTrack' - 0 - recEvent "
15583 "U 'TEvtHeader' - 0 - evtHeader U 'TRecEvTime' - 0 - recEvTime", ", TTrigEvent *trigEvent);", (void*) NULL, 1);
15584 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_529_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15585 G__memfunc_setup("SetTracks",916,G__BesVisLib_rootcint_529_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15586 G__memfunc_setup("SetMdcTracks",1192,G__BesVisLib_rootcint_529_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15587 G__memfunc_setup("SetTofTracks",1213,G__BesVisLib_rootcint_529_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15588 G__memfunc_setup("SetEmcShowers",1324,G__BesVisLib_rootcint_529_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15589 G__memfunc_setup("SetMucTracks",1209,G__BesVisLib_rootcint_529_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15590 G__memfunc_setup("SetExtTracks",1221,G__BesVisLib_rootcint_529_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15591 G__memfunc_setup("ConstructMdcTrackFromRec",2428,G__BesVisLib_rootcint_529_0_15, 121, -1, -1, 0, 3, 1, 1, 0,
15592 "U 'BesGeoTrack' - 0 - mdcTrack U 'TRecMdcTrack' - 10 - recTrack "
15593 "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15594 G__memfunc_setup("ConstructMucTrackFromRec",2445,G__BesVisLib_rootcint_529_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
15595 "U 'BesGeoTrack' - 0 - mucTrack U 'TRecMucTrack' - 10 - recTrack", (char*)NULL, (void*) NULL, 1);
15596 G__memfunc_setup("ConstructEmcTrackFromRec",2429,G__BesVisLib_rootcint_529_0_17, 121, -1, -1, 0, 2, 1, 1, 0,
15597 "U 'BesGeoTrack' - 0 - emcTrack U 'TRecEmcShower' - 10 - recTrack", (char*)NULL, (void*) NULL, 1);
15598 G__memfunc_setup("ConstructTofTrackFromRec",2449,G__BesVisLib_rootcint_529_0_18, 121, -1, -1, 0, 3, 1, 1, 0,
15599 "U 'BesGeoTrack' - 0 - tofTrack U 'TRecTofTrack' - 10 - recTrack "
15600 "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 1);
15601 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_529_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15602 G__memfunc_setup("DrawTracks",1014,G__BesVisLib_rootcint_529_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15603 G__memfunc_setup("SetMagnetic",1108,G__BesVisLib_rootcint_529_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15604 G__memfunc_setup("GetMdcDigiCol",1231,G__BesVisLib_rootcint_529_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15605 G__memfunc_setup("GetTofDigiCol",1252,G__BesVisLib_rootcint_529_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15606 G__memfunc_setup("GetEmcDigiCol",1232,G__BesVisLib_rootcint_529_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15607 G__memfunc_setup("GetMucDigiCol",1248,G__BesVisLib_rootcint_529_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15608 G__memfunc_setup("GetMdcDigiNum",1249,G__BesVisLib_rootcint_529_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15609 G__memfunc_setup("GetTofDigiNum",1270,G__BesVisLib_rootcint_529_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15610 G__memfunc_setup("GetEmcDigiNum",1250,G__BesVisLib_rootcint_529_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15611 G__memfunc_setup("GetMucDigiNum",1266,G__BesVisLib_rootcint_529_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15612 G__memfunc_setup("GetMdcDigi",945,G__BesVisLib_rootcint_529_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMdcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15613 G__memfunc_setup("GetTofDigi",966,G__BesVisLib_rootcint_529_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TTofDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15614 G__memfunc_setup("GetEmcDigi",946,G__BesVisLib_rootcint_529_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TEmcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15615 G__memfunc_setup("GetMucDigi",962,G__BesVisLib_rootcint_529_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TMucDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15616 G__memfunc_setup("GetMdcTrackCol",1351,G__BesVisLib_rootcint_529_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15617 G__memfunc_setup("GetTofTrackCol",1372,G__BesVisLib_rootcint_529_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15618 G__memfunc_setup("GetEmcShowerCol",1483,G__BesVisLib_rootcint_529_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15619 G__memfunc_setup("GetMucTrackCol",1368,G__BesVisLib_rootcint_529_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15620 G__memfunc_setup("GetExtTrackCol",1380,G__BesVisLib_rootcint_529_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15621 G__memfunc_setup("GetDedxCol",963,G__BesVisLib_rootcint_529_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObjArray), -1, 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15622 G__memfunc_setup("GetMdcTrackNum",1369,G__BesVisLib_rootcint_529_0_40, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15623 G__memfunc_setup("GetTofTrackNum",1390,G__BesVisLib_rootcint_529_0_41, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15624 G__memfunc_setup("GetEmcShowerNum",1501,G__BesVisLib_rootcint_529_0_42, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15625 G__memfunc_setup("GetMucTrackNum",1386,G__BesVisLib_rootcint_529_0_43, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15626 G__memfunc_setup("GetExtTrackNum",1398,G__BesVisLib_rootcint_529_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15627 G__memfunc_setup("GetDedxNum",981,G__BesVisLib_rootcint_529_0_45, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15628 G__memfunc_setup("GetMdcTrack",1065,G__BesVisLib_rootcint_529_0_46, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecMdcTrack), -1, 0, 2, 1, 1, 9,
15629 "i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15630 G__memfunc_setup("GetTofTrack",1086,G__BesVisLib_rootcint_529_0_47, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecTofTrack), -1, 0, 2, 1, 1, 9,
15631 "i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15632 G__memfunc_setup("GetEmcShower",1197,G__BesVisLib_rootcint_529_0_48, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecEmcShower), -1, 0, 2, 1, 1, 9,
15633 "i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15634 G__memfunc_setup("GetMucTrack",1082,G__BesVisLib_rootcint_529_0_49, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecMucTrack), -1, 0, 2, 1, 1, 9,
15635 "i - 'Int_t' 0 - i U 'TDisTrack' - 0 - recEvent", (char*)NULL, (void*) NULL, 0);
15636 G__memfunc_setup("GetDedx",677,G__BesVisLib_rootcint_529_0_50, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TRecMdcDedx), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15637 G__memfunc_setup("GetRun",597,G__BesVisLib_rootcint_529_0_51, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15638 G__memfunc_setup("GetEvent",802,G__BesVisLib_rootcint_529_0_52, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15639 G__memfunc_setup("GetYear",689,G__BesVisLib_rootcint_529_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15640 G__memfunc_setup("GetMonth",806,G__BesVisLib_rootcint_529_0_54, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15641 G__memfunc_setup("GetDay",574,G__BesVisLib_rootcint_529_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15642 G__memfunc_setup("GetHour",702,G__BesVisLib_rootcint_529_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15643 G__memfunc_setup("GetMin",580,G__BesVisLib_rootcint_529_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15644 G__memfunc_setup("GetSec",571,G__BesVisLib_rootcint_529_0_58, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15645 G__memfunc_setup("GetMC",432,G__BesVisLib_rootcint_529_0_59, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15646 G__memfunc_setup("GetHeader",873,G__BesVisLib_rootcint_529_0_60, 117, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEventHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15647 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_529_0_61, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesEvent::Class) ), 0);
15648 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_529_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEvent::Class_Name) ), 0);
15649 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_529_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesEvent::Class_Version) ), 0);
15650 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_529_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesEvent::Dictionary) ), 0);
15651 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15652 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15653 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15654 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_529_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15655 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_529_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEvent::DeclFileName) ), 0);
15656 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_529_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEvent::ImplFileLine) ), 0);
15657 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_529_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesEvent::ImplFileName) ), 0);
15658 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_529_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesEvent::DeclFileLine) ), 0);
15659
15660 G__memfunc_setup("BesEvent", 796, G__BesVisLib_rootcint_529_0_73, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent), -1, 0, 1, 1, 1, 0, "u 'BesEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
15661
15662 G__memfunc_setup("~BesEvent", 922, G__BesVisLib_rootcint_529_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15663
15664 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_529_0_75, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesEvent), -1, 1, 1, 1, 1, 0, "u 'BesEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
15665 G__tag_memfunc_reset();
15666 }
15667
15668 static void G__setup_memfuncSubDetectorROOTGeo(void) {
15669
15670 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo));
15671 G__memfunc_setup("SubDetectorROOTGeo",1731,G__BesVisLib_rootcint_798_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15672 G__memfunc_setup("ReadGdml",768,G__BesVisLib_rootcint_798_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15673 "C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 1);
15674 G__memfunc_setup("IsInitialized",1330,G__BesVisLib_rootcint_798_0_3, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15675 G__memfunc_setup("SetChildNo",973,G__BesVisLib_rootcint_798_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - childNo", (char*)NULL, (void*) NULL, 1);
15676 G__memfunc_setup("GetLogicalVolume",1619,G__BesVisLib_rootcint_798_0_5, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - vn", (char*)NULL, (void*) NULL, 1);
15677 G__memfunc_setup("GetTopVolume",1227,G__BesVisLib_rootcint_798_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15678 G__memfunc_setup("GetAssemblyVolume",1752,G__BesVisLib_rootcint_798_0_7, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolumeAssembly), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - an", (char*)NULL, (void*) NULL, 1);
15679 G__memfunc_setup("GetNode",678,G__BesVisLib_rootcint_798_0_8, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - nn", (char*)NULL, (void*) NULL, 1);
15680 G__memfunc_setup("GetHitsNum",1000,G__BesVisLib_rootcint_798_0_9, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15681 G__memfunc_setup("GetHit",581,G__BesVisLib_rootcint_798_0_10, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 1);
15682 G__memfunc_setup("SetDetectorOn",1315,G__BesVisLib_rootcint_798_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15683
15684 G__memfunc_setup("SubDetectorROOTGeo", 1731, G__BesVisLib_rootcint_798_0_12, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo), -1, 0, 1, 1, 1, 0, "u 'SubDetectorROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
15685
15686 G__memfunc_setup("~SubDetectorROOTGeo", 1857, G__BesVisLib_rootcint_798_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15687 G__tag_memfunc_reset();
15688 }
15689
15690 static void G__setup_memfuncBesPolygon2D(void) {
15691
15692 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D));
15693 G__memfunc_setup("BesPolygon2D",1144,G__BesVisLib_rootcint_836_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15694 G__memfunc_setup("BesPolygon2D",1144,G__BesVisLib_rootcint_836_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 0, 4, 1, 1, 0,
15695 "C - - 10 - name C - - 10 - title "
15696 "i - 'Int_t' 0 - N D - 'Double_t' 0 - P", (char*)NULL, (void*) NULL, 0);
15697 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15698 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15699 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15700 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15701 G__memfunc_setup("SetZRSign",873,G__BesVisLib_rootcint_836_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - sign", (char*)NULL, (void*) NULL, 1);
15702 G__memfunc_setup("Resize",626,G__BesVisLib_rootcint_836_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ScaleFactor", (char*)NULL, (void*) NULL, 1);
15703 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15704 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15705 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15706 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15707 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15708 G__memfunc_setup("SetInfoBox",993,G__BesVisLib_rootcint_836_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15709 G__memfunc_setup("GetCenter",897,G__BesVisLib_rootcint_836_0_11, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - Center", (char*)NULL, (void*) NULL, 1);
15710 G__memfunc_setup("RotatePhi",912,G__BesVisLib_rootcint_836_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
15711 G__memfunc_setup("Restore",740,G__BesVisLib_rootcint_836_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15712 G__memfunc_setup("SetSize",711,G__BesVisLib_rootcint_836_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
15713 G__memfunc_setup("IsRotatable",1114,G__BesVisLib_rootcint_836_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15714 G__memfunc_setup("SetRotatable",1226,G__BesVisLib_rootcint_836_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15715 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
15716 G__memfunc_setup("SetTitle",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
15717 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15718 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_836_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15719 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_836_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
15720 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
15721 G__memfunc_setup("SetPoints",937,G__BesVisLib_rootcint_836_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - P", (char*)NULL, (void*) NULL, 0);
15722 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_836_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesPolygon2D::Class) ), 0);
15723 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_836_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPolygon2D::Class_Name) ), 0);
15724 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_836_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesPolygon2D::Class_Version) ), 0);
15725 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_836_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesPolygon2D::Dictionary) ), 0);
15726 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15727 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15728 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15729 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_836_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15730 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_836_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPolygon2D::DeclFileName) ), 0);
15731 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_836_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPolygon2D::ImplFileLine) ), 0);
15732 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_836_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesPolygon2D::ImplFileName) ), 0);
15733 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_836_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesPolygon2D::DeclFileLine) ), 0);
15734
15735 G__memfunc_setup("BesPolygon2D", 1144, G__BesVisLib_rootcint_836_0_36, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 0, 1, 1, 1, 0, "u 'BesPolygon2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15736
15737 G__memfunc_setup("~BesPolygon2D", 1270, G__BesVisLib_rootcint_836_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15738
15739 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_836_0_38, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesPolygon2D), -1, 1, 1, 1, 1, 0, "u 'BesPolygon2D' - 11 - -", (char*) NULL, (void*) NULL, 0);
15740 G__tag_memfunc_reset();
15741 }
15742
15743 static void G__setup_memfuncMdc2DWire(void) {
15744
15745 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire));
15746 G__memfunc_setup("Mdc2DWire",801,G__BesVisLib_rootcint_837_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15747 G__memfunc_setup("Mdc2DWire",801,G__BesVisLib_rootcint_837_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 7, 1, 1, 0,
15748 "C - - 10 - name C - - 10 - title "
15749 "d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
15750 "d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi "
15751 "D - 'Double_t' 0 - center", (char*)NULL, (void*) NULL, 0);
15752 G__memfunc_setup("Mdc2DWire",801,G__BesVisLib_rootcint_837_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 4, 1, 1, 0,
15753 "C - - 10 - name C - - 10 - title "
15754 "i - 'Int_t' 0 - N D - 'Double_t' 0 - P", (char*)NULL, (void*) NULL, 0);
15755 G__memfunc_setup("Init",404,G__BesVisLib_rootcint_837_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15756 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_837_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15757 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15758 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15759 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15760 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15761 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15762 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_837_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
15763 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_837_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
15764 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_837_0_10, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15765 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_837_0_11, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15766 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_837_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
15767 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_837_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15768 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_837_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15769 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15770 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15771 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15772 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15773 G__memfunc_setup("HasZRSection",1181,G__BesVisLib_rootcint_837_0_18, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15774 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_837_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15775 G__memfunc_setup("SetTime",699,G__BesVisLib_rootcint_837_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
15776 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_837_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
15777 G__memfunc_setup("SetColorfulWire",1545,G__BesVisLib_rootcint_837_0_22, 121, -1, -1, 0, 2, 1, 1, 0,
15778 "g - 'Bool_t' 0 - colorfulWire g - 'Bool_t' 0 - subEvTime", (char*)NULL, (void*) NULL, 0);
15779 G__memfunc_setup("SetQOverflow",1233,G__BesVisLib_rootcint_837_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - qOvfl", (char*)NULL, (void*) NULL, 0);
15780 G__memfunc_setup("SetEvTime",886,G__BesVisLib_rootcint_837_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
15781 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_837_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Mdc2DWire::Class) ), 0);
15782 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_837_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Mdc2DWire::Class_Name) ), 0);
15783 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_837_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Mdc2DWire::Class_Version) ), 0);
15784 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_837_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Mdc2DWire::Dictionary) ), 0);
15785 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15786 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15787 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15788 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_837_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15789 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_837_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Mdc2DWire::DeclFileName) ), 0);
15790 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_837_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Mdc2DWire::ImplFileLine) ), 0);
15791 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_837_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Mdc2DWire::ImplFileName) ), 0);
15792 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_837_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Mdc2DWire::DeclFileLine) ), 0);
15793
15794 G__memfunc_setup("Mdc2DWire", 801, G__BesVisLib_rootcint_837_0_37, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 1, 1, 1, 0, "u 'Mdc2DWire' - 11 - -", (char*) NULL, (void*) NULL, 0);
15795
15796 G__memfunc_setup("~Mdc2DWire", 927, G__BesVisLib_rootcint_837_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15797
15798 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_837_0_39, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 1, 1, 1, 1, 0, "u 'Mdc2DWire' - 11 - -", (char*) NULL, (void*) NULL, 0);
15799 G__tag_memfunc_reset();
15800 }
15801
15802 static void G__setup_memfuncMdcROOTGeo(void) {
15803
15804 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo));
15805 G__memfunc_setup("MdcROOTGeo",883,G__BesVisLib_rootcint_838_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15806 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_838_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15807 "C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
15808 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_838_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
15809 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_838_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15810 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_838_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15811 G__memfunc_setup("CorrectReplica",1426,G__BesVisLib_rootcint_838_0_6, 105, -1, -1, 0, 2, 1, 1, 0,
15812 "i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
15813 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_838_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15814 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_838_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15815 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_838_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15816 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_838_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15817 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_838_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15818 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_838_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15819 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_838_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15820 G__memfunc_setup("SetTFire",774,G__BesVisLib_rootcint_838_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15821 G__memfunc_setup("SetQFire",771,G__BesVisLib_rootcint_838_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15822 G__memfunc_setup("SetQNotOverflow",1538,G__BesVisLib_rootcint_838_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15823 G__memfunc_setup("SetColorfulWire",1545,G__BesVisLib_rootcint_838_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15824 G__memfunc_setup("SetMdcTimeSubEvTime",1859,G__BesVisLib_rootcint_838_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15825 G__memfunc_setup("SetVisMdcDetector",1708,G__BesVisLib_rootcint_838_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15826 G__memfunc_setup("SetVisMdcHits",1290,G__BesVisLib_rootcint_838_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15827 G__memfunc_setup("GetSegmentNb",1187,G__BesVisLib_rootcint_838_0_21, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15828 G__memfunc_setup("GetLayerNb",973,G__BesVisLib_rootcint_838_0_22, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15829 G__memfunc_setup("GetReplicaNb",1168,G__BesVisLib_rootcint_838_0_23, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15830 G__memfunc_setup("SetVolumeMdc",1208,G__BesVisLib_rootcint_838_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
15831 G__memfunc_setup("GetVolumeMdc",1196,G__BesVisLib_rootcint_838_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15832 G__memfunc_setup("GetVolumeSegment",1643,G__BesVisLib_rootcint_838_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - segment", (char*)NULL, (void*) NULL, 0);
15833 G__memfunc_setup("GetVolumeLayer",1429,G__BesVisLib_rootcint_838_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15834 G__memfunc_setup("GetVolumeReplica",1624,G__BesVisLib_rootcint_838_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15835 G__memfunc_setup("GetSegment",1011,G__BesVisLib_rootcint_838_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
15836 "i - - 0 - segment i - - 0 - no", (char*)NULL, (void*) NULL, 0);
15837 G__memfunc_setup("GetLayer",797,G__BesVisLib_rootcint_838_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15838 G__memfunc_setup("GetReplica",992,G__BesVisLib_rootcint_838_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
15839 "i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
15840 G__memfunc_setup("GetPhysicalSegment",1840,G__BesVisLib_rootcint_838_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "i - - 0 - segment", (char*)NULL, (void*) NULL, 0);
15841 G__memfunc_setup("GetPhysicalReplica",1821,G__BesVisLib_rootcint_838_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 2, 1, 1, 0,
15842 "i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
15843 G__memfunc_setup("Get2DWire",813,G__BesVisLib_rootcint_838_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Mdc2DWire), -1, 0, 2, 1, 1, 0,
15844 "i - 'Int_t' 0 - layer i - 'Int_t' 0 - replica", (char*)NULL, (void*) NULL, 0);
15845 G__memfunc_setup("GetSimuLayer",1211,G__BesVisLib_rootcint_838_0_35, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trueLayer", (char*)NULL, (void*) NULL, 0);
15846 G__memfunc_setup("IsHit",481,G__BesVisLib_rootcint_838_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
15847 "i - 'Int_t' 0 - layer i - 'Int_t' 0 - wire", (char*)NULL, (void*) NULL, 0);
15848 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_838_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
15849 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_838_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
15850
15851 G__memfunc_setup("MdcROOTGeo", 883, G__BesVisLib_rootcint_838_0_39, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 1, 1, 1, 0, "u 'MdcROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
15852
15853 G__memfunc_setup("~MdcROOTGeo", 1009, G__BesVisLib_rootcint_838_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15854 G__tag_memfunc_reset();
15855 }
15856
15857 static void G__setup_memfuncTof2DScin(void) {
15858
15859 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin));
15860 G__memfunc_setup("Tof2DScin",812,G__BesVisLib_rootcint_839_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15861 G__memfunc_setup("Tof2DScin",812,G__BesVisLib_rootcint_839_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 5, 1, 1, 0,
15862 "C - - 10 - name C - - 10 - title "
15863 "i - 'Int_t' 0 - N D - 'Double_t' 0 - P "
15864 "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
15865 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_839_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15866 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15867 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15868 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15869 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15870 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15871 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_839_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
15872 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_839_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
15873 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_839_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15874 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_839_0_9, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15875 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_839_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
15876 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_839_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15877 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_839_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15878 G__memfunc_setup("SetTime",699,G__BesVisLib_rootcint_839_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 1);
15879 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_839_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - charge", (char*)NULL, (void*) NULL, 1);
15880 G__memfunc_setup("GetTime",687,G__BesVisLib_rootcint_839_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15881 G__memfunc_setup("GetCharge",874,G__BesVisLib_rootcint_839_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15882 G__memfunc_setup("ResetTimeCharge",1500,G__BesVisLib_rootcint_839_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15883 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15884 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15885 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
15886 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15887 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_839_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15888 G__memfunc_setup("HasZRSection",1181,G__BesVisLib_rootcint_839_0_22, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15889 G__memfunc_setup("GetAngle",775,G__BesVisLib_rootcint_839_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
15890 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "degree, 0~360", (void*) NULL, 0);
15891 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_839_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15892 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_839_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Tof2DScin::Class) ), 0);
15893 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_839_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Tof2DScin::Class_Name) ), 0);
15894 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_839_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Tof2DScin::Class_Version) ), 0);
15895 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_839_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Tof2DScin::Dictionary) ), 0);
15896 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15897 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
15898 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
15899 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_839_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
15900 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_839_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Tof2DScin::DeclFileName) ), 0);
15901 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_839_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Tof2DScin::ImplFileLine) ), 0);
15902 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_839_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Tof2DScin::ImplFileName) ), 0);
15903 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_839_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Tof2DScin::DeclFileLine) ), 0);
15904
15905 G__memfunc_setup("Tof2DScin", 812, G__BesVisLib_rootcint_839_0_37, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 1, 1, 1, 0, "u 'Tof2DScin' - 11 - -", (char*) NULL, (void*) NULL, 0);
15906
15907 G__memfunc_setup("~Tof2DScin", 938, G__BesVisLib_rootcint_839_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15908
15909 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_839_0_39, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 1, 1, 1, 1, 0, "u 'Tof2DScin' - 11 - -", (char*) NULL, (void*) NULL, 0);
15910 G__tag_memfunc_reset();
15911 }
15912
15913 static void G__setup_memfuncTofROOTGeo(void) {
15914
15915 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo));
15916 G__memfunc_setup("TofROOTGeo",904,G__BesVisLib_rootcint_840_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15917 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_840_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15918 "C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
15919 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_840_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
15920 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_840_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15921 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_840_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15922 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_840_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15923 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_840_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15924 G__memfunc_setup("SetTMatch",877,G__BesVisLib_rootcint_840_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15925 G__memfunc_setup("SetQMatch",874,G__BesVisLib_rootcint_840_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", (char*)NULL, (void*) NULL, 0);
15926 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_840_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15927 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_840_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15928 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_840_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15929 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_840_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15930 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_840_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15931 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_840_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15932 G__memfunc_setup("SetVisTofDetector",1729,G__BesVisLib_rootcint_840_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15933 G__memfunc_setup("SetVisTofHits",1311,G__BesVisLib_rootcint_840_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15934 G__memfunc_setup("GetPartNb",871,G__BesVisLib_rootcint_840_0_18, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15935 G__memfunc_setup("GetScinNb",861,G__BesVisLib_rootcint_840_0_19, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
15936 G__memfunc_setup("GetLayerNb",973,G__BesVisLib_rootcint_840_0_20, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
15937 G__memfunc_setup("SetVolumeTof",1229,G__BesVisLib_rootcint_840_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
15938 G__memfunc_setup("GetVolumeTof",1217,G__BesVisLib_rootcint_840_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15939 G__memfunc_setup("GetVolumePart",1327,G__BesVisLib_rootcint_840_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
15940 G__memfunc_setup("GetVolumePVF",1156,G__BesVisLib_rootcint_840_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
15941 "i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15942 G__memfunc_setup("GetVolumeAl",1093,G__BesVisLib_rootcint_840_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
15943 "i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15944 G__memfunc_setup("GetVolumeScin",1317,G__BesVisLib_rootcint_840_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
15945 "i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15946 G__memfunc_setup("GetVolumeBucket",1526,G__BesVisLib_rootcint_840_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
15947 "i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15948 G__memfunc_setup("GetPVF",524,G__BesVisLib_rootcint_840_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
15949 "i - - 0 - part i - - 0 - layer "
15950 "i - - 0 - scin", (char*)NULL, (void*) NULL, 0);
15951 G__memfunc_setup("GetAl",461,G__BesVisLib_rootcint_840_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
15952 "i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15953 G__memfunc_setup("GetScin",685,G__BesVisLib_rootcint_840_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
15954 "i - - 0 - part i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
15955 G__memfunc_setup("GetPhysicalScin",1514,G__BesVisLib_rootcint_840_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
15956 "i - - 0 - part i - - 0 - layer "
15957 "i - - 0 - scin", (char*)NULL, (void*) NULL, 0);
15958 G__memfunc_setup("Get2DScin",803,G__BesVisLib_rootcint_840_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Tof2DScin), -1, 0, 3, 1, 1, 0,
15959 "i - 'Int_t' 0 - part i - 'Int_t' 0 - layer "
15960 "i - 'Int_t' 0 - scin", (char*)NULL, (void*) NULL, 0);
15961 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_840_0_33, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - phyNode", (char*)NULL, (void*) NULL, 0);
15962 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_840_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
15963 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_840_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
15964
15965 G__memfunc_setup("TofROOTGeo", 904, G__BesVisLib_rootcint_840_0_36, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 1, 1, 1, 0, "u 'TofROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
15966
15967 G__memfunc_setup("~TofROOTGeo", 1030, G__BesVisLib_rootcint_840_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15968 G__tag_memfunc_reset();
15969 }
15970
15971 static void G__setup_memfuncEmc2DCrystal(void) {
15972
15973 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal));
15974 G__memfunc_setup("Emc2DCrystal",1133,G__BesVisLib_rootcint_841_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15975 G__memfunc_setup("Emc2DCrystal",1133,G__BesVisLib_rootcint_841_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 6, 1, 1, 0,
15976 "C - - 10 - name C - - 10 - title "
15977 "i - 'Int_t' 0 - N D - 'Double_t' 0 - P "
15978 "i - 'Int_t' 0 - part i - 'Int_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
15979 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_841_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15980 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15981 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15982 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15983 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15984 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15985 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_841_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
15986 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_841_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
15987 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_841_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15988 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_841_0_9, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15989 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_841_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
15990 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_841_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15991 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_841_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15992 G__memfunc_setup("SetTime",699,G__BesVisLib_rootcint_841_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 1);
15993 G__memfunc_setup("SetCharge",886,G__BesVisLib_rootcint_841_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - charge", (char*)NULL, (void*) NULL, 1);
15994 G__memfunc_setup("GetTime",687,G__BesVisLib_rootcint_841_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15995 G__memfunc_setup("GetCharge",874,G__BesVisLib_rootcint_841_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15996 G__memfunc_setup("ResetTimeCharge",1500,G__BesVisLib_rootcint_841_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15997 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15998 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15999 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16000 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16001 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_841_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16002 G__memfunc_setup("GetTheta",790,G__BesVisLib_rootcint_841_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16003 G__memfunc_setup("HasZRSection",1181,G__BesVisLib_rootcint_841_0_23, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16004 G__memfunc_setup("GetAngle",775,G__BesVisLib_rootcint_841_0_24, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
16005 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "degree, 0~360", (void*) NULL, 0);
16006 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_841_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16007 G__memfunc_setup("IsXYVisible",1083,G__BesVisLib_rootcint_841_0_26, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16008 G__memfunc_setup("IsSideVisible",1295,G__BesVisLib_rootcint_841_0_27, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16009 G__memfunc_setup("SetXYPoint",999,G__BesVisLib_rootcint_841_0_28, 121, -1, -1, 0, 4, 1, 1, 0,
16010 "D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2 "
16011 "D - 'Double_t' 0 - newP d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
16012 G__memfunc_setup("SetZRPoint",994,G__BesVisLib_rootcint_841_0_29, 121, -1, -1, 0, 4, 1, 1, 0,
16013 "D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2 "
16014 "D - 'Double_t' 0 - newP d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 1);
16015 G__memfunc_setup("ProjectECToSide",1447,G__BesVisLib_rootcint_841_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
16016 "D - 'Double_t' 0 - p1 D - 'Double_t' 0 - newP", (char*)NULL, (void*) NULL, 1);
16017 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_841_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Emc2DCrystal::Class) ), 0);
16018 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_841_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Emc2DCrystal::Class_Name) ), 0);
16019 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_841_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Emc2DCrystal::Class_Version) ), 0);
16020 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_841_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Emc2DCrystal::Dictionary) ), 0);
16021 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16022 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16023 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16024 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_841_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16025 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_841_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Emc2DCrystal::DeclFileName) ), 0);
16026 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_841_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Emc2DCrystal::ImplFileLine) ), 0);
16027 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_841_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Emc2DCrystal::ImplFileName) ), 0);
16028 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_841_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Emc2DCrystal::DeclFileLine) ), 0);
16029
16030 G__memfunc_setup("Emc2DCrystal", 1133, G__BesVisLib_rootcint_841_0_43, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 1, 1, 1, 0, "u 'Emc2DCrystal' - 11 - -", (char*) NULL, (void*) NULL, 0);
16031
16032 G__memfunc_setup("~Emc2DCrystal", 1259, G__BesVisLib_rootcint_841_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16033
16034 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_841_0_45, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 1, 1, 1, 1, 0, "u 'Emc2DCrystal' - 11 - -", (char*) NULL, (void*) NULL, 0);
16035 G__tag_memfunc_reset();
16036 }
16037
16038 static void G__setup_memfuncEmcROOTGeo(void) {
16039
16040 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo));
16041 G__memfunc_setup("EmcROOTGeo",884,G__BesVisLib_rootcint_842_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16042 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_842_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
16043 "C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
16044 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_842_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16045 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_842_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16046 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_842_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16047 G__memfunc_setup("SetVolumeAppendInVis",2021,G__BesVisLib_rootcint_842_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16048 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_842_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16049 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_842_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16050 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_842_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16051 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_842_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16052 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_842_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16053 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_842_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16054 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_842_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16055 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_842_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16056 G__memfunc_setup("SetVisEmcDetector",1709,G__BesVisLib_rootcint_842_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16057 G__memfunc_setup("SetVisEmcHits",1291,G__BesVisLib_rootcint_842_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16058 G__memfunc_setup("GetPartNb",871,G__BesVisLib_rootcint_842_0_17, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16059 G__memfunc_setup("GetThetaNb",966,G__BesVisLib_rootcint_842_0_18, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16060 G__memfunc_setup("GetPhiNb",753,G__BesVisLib_rootcint_842_0_19, 105, -1, -1, 0, 2, 1, 1, 0,
16061 "i - - 0 - part i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16062 G__memfunc_setup("SetVolumeEmc",1209,G__BesVisLib_rootcint_842_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16063 G__memfunc_setup("GetVolumeEmc",1197,G__BesVisLib_rootcint_842_0_21, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16064 G__memfunc_setup("GetVolumePart",1327,G__BesVisLib_rootcint_842_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16065 G__memfunc_setup("GetVolumePhi",1209,G__BesVisLib_rootcint_842_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16066 "i - - 0 - part i - - 0 - phi", (char*)NULL, (void*) NULL, 0);
16067 G__memfunc_setup("GetVolumeTheta",1422,G__BesVisLib_rootcint_842_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16068 "i - - 0 - part i - - 0 - phi "
16069 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16070 G__memfunc_setup("GetVolumeCrystal",1658,G__BesVisLib_rootcint_842_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16071 "i - - 0 - part i - - 0 - phi "
16072 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16073 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_842_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16074 G__memfunc_setup("GetPhi",577,G__BesVisLib_rootcint_842_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 2, 1, 1, 0,
16075 "i - - 0 - part i - - 0 - phi", (char*)NULL, (void*) NULL, 0);
16076 G__memfunc_setup("GetTheta",790,G__BesVisLib_rootcint_842_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16077 "i - - 0 - part i - - 0 - phi "
16078 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16079 G__memfunc_setup("GetTheta2",840,G__BesVisLib_rootcint_842_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16080 "i - - 0 - part i - - 0 - phi "
16081 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16082 G__memfunc_setup("GetCrystal",1026,G__BesVisLib_rootcint_842_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16083 "i - - 0 - part i - - 0 - phi "
16084 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16085 G__memfunc_setup("GetCrystal2",1076,G__BesVisLib_rootcint_842_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16086 "i - - 0 - part i - - 0 - phi "
16087 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16088 G__memfunc_setup("GetPhysicalCrystal",1855,G__BesVisLib_rootcint_842_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16089 "i - - 0 - part i - - 0 - phi "
16090 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16091 G__memfunc_setup("GetPhysicalCrystal2",1905,G__BesVisLib_rootcint_842_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16092 "i - - 0 - part i - - 0 - phi "
16093 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16094 G__memfunc_setup("HasTwoNodes",1103,G__BesVisLib_rootcint_842_0_34, 103, -1, -1, 0, 3, 1, 1, 0,
16095 "i - - 0 - part i - - 0 - phi "
16096 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16097 G__memfunc_setup("ComputeThetaPhi",1524,G__BesVisLib_rootcint_842_0_35, 121, -1, -1, 0, 5, 1, 1, 0,
16098 "i - - 0 - id i - - 0 - sector "
16099 "i - - 0 - nb i - - 1 - CryNumberTheta "
16100 "i - - 1 - CryNumberPhi", (char*)NULL, (void*) NULL, 0);
16101 G__memfunc_setup("ComputeEndCopyNb",1599,G__BesVisLib_rootcint_842_0_36, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - num", (char*)NULL, (void*) NULL, 0);
16102 G__memfunc_setup("Get2DCrystal",1144,G__BesVisLib_rootcint_842_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Emc2DCrystal), -1, 0, 3, 1, 1, 0,
16103 "i - 'Int_t' 0 - part i - 'Int_t' 0 - phi "
16104 "i - 'Int_t' 0 - theta", (char*)NULL, (void*) NULL, 0);
16105 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_842_0_38, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - phyNode", (char*)NULL, (void*) NULL, 0);
16106 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_842_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16107 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_842_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16108 G__memfunc_setup("Align",491,G__BesVisLib_rootcint_842_0_41, 121, -1, -1, 0, 4, 1, 1, 0,
16109 "U 'TGeoPhysicalNode' - 0 - phyNode U 'TGeoMatrix' - 0 '0' newmat "
16110 "U 'TGeoShape' - 0 '0' newshape g - 'Bool_t' 0 'kFALSE' check", (char*)NULL, (void*) NULL, 0);
16111 G__memfunc_setup("RestorePhyNode",1435,G__BesVisLib_rootcint_842_0_42, 121, -1, -1, 0, 2, 1, 1, 0,
16112 "U 'TGeoPhysicalNode' - 0 - phyNode U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
16113
16114 G__memfunc_setup("EmcROOTGeo", 884, G__BesVisLib_rootcint_842_0_43, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 1, 1, 1, 0, "u 'EmcROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16115
16116 G__memfunc_setup("~EmcROOTGeo", 1010, G__BesVisLib_rootcint_842_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16117 G__tag_memfunc_reset();
16118 }
16119
16120 static void G__setup_memfuncMuc2DStrip(void) {
16121
16122 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip));
16123 G__memfunc_setup("Muc2DStrip",941,G__BesVisLib_rootcint_843_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16124 G__memfunc_setup("Muc2DStrip",941,G__BesVisLib_rootcint_843_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 8, 1, 1, 0,
16125 "C - - 10 - name C - - 10 - title "
16126 "i - 'Int_t' 0 - N D - 'Double_t' 0 - P "
16127 "i - 'Int_t' 0 - part i - 'Int_t' 0 - seg "
16128 "i - 'Int_t' 0 - gap i - 'Int_t' 0 - strip", (char*)NULL, (void*) NULL, 0);
16129 G__memfunc_setup("SetStyle",829,G__BesVisLib_rootcint_843_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16130 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16131 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16132 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16133 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16134 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16135 G__memfunc_setup("SetHighlighted",1421,G__BesVisLib_rootcint_843_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16136 G__memfunc_setup("SetFired",790,G__BesVisLib_rootcint_843_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 1);
16137 G__memfunc_setup("IsHighlighted",1309,G__BesVisLib_rootcint_843_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16138 G__memfunc_setup("IsFired",678,G__BesVisLib_rootcint_843_0_9, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16139 G__memfunc_setup("AddInfo",661,G__BesVisLib_rootcint_843_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - info", (char*)NULL, (void*) NULL, 1);
16140 G__memfunc_setup("CloseInfo",898,G__BesVisLib_rootcint_843_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16141 G__memfunc_setup("ClearInfo",883,G__BesVisLib_rootcint_843_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16142 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16143 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16144 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
16145 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16146 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_843_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16147 G__memfunc_setup("GetSeg",575,G__BesVisLib_rootcint_843_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16148 G__memfunc_setup("GetGap",568,G__BesVisLib_rootcint_843_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16149 G__memfunc_setup("GetStrip",818,G__BesVisLib_rootcint_843_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16150 G__memfunc_setup("IsZRVisible",1078,G__BesVisLib_rootcint_843_0_20, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16151 G__memfunc_setup("GetAngle",775,G__BesVisLib_rootcint_843_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0,
16152 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y", "degree, 0~360", (void*) NULL, 0);
16153 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_843_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16154 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_843_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&Muc2DStrip::Class) ), 0);
16155 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_843_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Muc2DStrip::Class_Name) ), 0);
16156 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_843_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&Muc2DStrip::Class_Version) ), 0);
16157 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_843_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&Muc2DStrip::Dictionary) ), 0);
16158 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16159 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16160 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16161 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_843_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16162 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_843_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Muc2DStrip::DeclFileName) ), 0);
16163 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_843_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Muc2DStrip::ImplFileLine) ), 0);
16164 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_843_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&Muc2DStrip::ImplFileName) ), 0);
16165 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_843_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&Muc2DStrip::DeclFileLine) ), 0);
16166
16167 G__memfunc_setup("Muc2DStrip", 941, G__BesVisLib_rootcint_843_0_35, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 1, 1, 1, 0, "u 'Muc2DStrip' - 11 - -", (char*) NULL, (void*) NULL, 0);
16168
16169 G__memfunc_setup("~Muc2DStrip", 1067, G__BesVisLib_rootcint_843_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16170
16171 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_843_0_37, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 1, 1, 1, 1, 0, "u 'Muc2DStrip' - 11 - -", (char*) NULL, (void*) NULL, 0);
16172 G__tag_memfunc_reset();
16173 }
16174
16175 static void G__setup_memfuncMucROOTGeo(void) {
16176
16177 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo));
16178 G__memfunc_setup("MucROOTGeo",900,G__BesVisLib_rootcint_844_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16179 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_844_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
16180 "C - - 10 - gdmlFile C - - 10 - setupName", (char*)NULL, (void*) NULL, 0);
16181 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_844_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16182 G__memfunc_setup("Init2DGeometry",1366,G__BesVisLib_rootcint_844_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16183 G__memfunc_setup("SetNode",690,G__BesVisLib_rootcint_844_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16184 G__memfunc_setup("SetVolumeDefaultVis",1947,G__BesVisLib_rootcint_844_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16185 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_844_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16186 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_844_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16187 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_844_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16188 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_844_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16189 G__memfunc_setup("SetPhysicalNode",1519,G__BesVisLib_rootcint_844_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16190 G__memfunc_setup("SetDetector",1126,G__BesVisLib_rootcint_844_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16191 G__memfunc_setup("SetHits",708,G__BesVisLib_rootcint_844_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16192 G__memfunc_setup("SetVisMucDetector",1725,G__BesVisLib_rootcint_844_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16193 G__memfunc_setup("SetVisMucHits",1307,G__BesVisLib_rootcint_844_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16194 G__memfunc_setup("GetPartNb",871,G__BesVisLib_rootcint_844_0_16, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16195 G__memfunc_setup("GetSegNb",751,G__BesVisLib_rootcint_844_0_17, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16196 G__memfunc_setup("GetGapNb",744,G__BesVisLib_rootcint_844_0_18, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16197 G__memfunc_setup("GetStripNb",994,G__BesVisLib_rootcint_844_0_19, 105, -1, -1, 0, 3, 1, 1, 0,
16198 "i - - 0 - part i - - 0 - seg "
16199 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16200 G__memfunc_setup("GetAbsorberNb",1280,G__BesVisLib_rootcint_844_0_20, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16201 G__memfunc_setup("SetVolumeMuc",1225,G__BesVisLib_rootcint_844_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
16202 G__memfunc_setup("GetVolumeMuc",1213,G__BesVisLib_rootcint_844_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16203 G__memfunc_setup("GetVolumeAbsorber",1736,G__BesVisLib_rootcint_844_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16204 "i - - 0 - part i - - 0 - seg "
16205 "i - - 0 - absorber", (char*)NULL, (void*) NULL, 0);
16206 G__memfunc_setup("GetVolumeAbsorberSmallBlock",2732,G__BesVisLib_rootcint_844_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16207 "i - - 0 - gap i - - 0 - sb", (char*)NULL, (void*) NULL, 0);
16208 G__memfunc_setup("GetVolumeAbsorberPanel",2232,G__BesVisLib_rootcint_844_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16209 "i - - 0 - part i - - 0 - seg "
16210 "i - - 0 - absorber i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16211 G__memfunc_setup("GetVolumeGap",1200,G__BesVisLib_rootcint_844_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16212 "i - - 0 - part i - - 0 - seg "
16213 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16214 G__memfunc_setup("GetVolumeBox",1217,G__BesVisLib_rootcint_844_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16215 "i - - 0 - part i - - 0 - seg "
16216 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16217 G__memfunc_setup("GetVolumeBoxSurface",1930,G__BesVisLib_rootcint_844_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16218 "i - - 0 - part i - - 0 - seg "
16219 "i - - 0 - gap i - - 0 - up", (char*)NULL, (void*) NULL, 0);
16220 G__memfunc_setup("GetVolumeStripPlane",1946,G__BesVisLib_rootcint_844_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16221 "i - - 0 - part i - - 0 - seg "
16222 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16223 G__memfunc_setup("GetVolumeStrip",1450,G__BesVisLib_rootcint_844_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16224 "i - - 0 - part i - - 0 - seg "
16225 "i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16226 G__memfunc_setup("GetVolumeGasChamber",1893,G__BesVisLib_rootcint_844_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 5, 1, 1, 0,
16227 "i - - 0 - part i - - 0 - seg "
16228 "i - - 0 - gap i - - 0 - panel "
16229 "i - - 0 - gasChamber", (char*)NULL, (void*) NULL, 0);
16230 G__memfunc_setup("GetVolumeGasBorder",1809,G__BesVisLib_rootcint_844_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 5, 1, 1, 0,
16231 "i - - 0 - part i - - 0 - seg "
16232 "i - - 0 - gap i - - 0 - panel "
16233 "i - - 0 - gasChamber", (char*)NULL, (void*) NULL, 0);
16234 G__memfunc_setup("GetVolumeBakelite",1721,G__BesVisLib_rootcint_844_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 6, 1, 1, 0,
16235 "i - - 0 - part i - - 0 - seg "
16236 "i - - 0 - gap i - - 0 - RpcUpDown "
16237 "i - - 0 - panel i - - 0 - bakelite", (char*)NULL, (void*) NULL, 0);
16238 G__memfunc_setup("GetAbsorber",1104,G__BesVisLib_rootcint_844_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16239 "i - - 0 - part i - - 0 - seg "
16240 "i - - 0 - absorber", (char*)NULL, (void*) NULL, 0);
16241 G__memfunc_setup("GetAbsorberPanel",1600,G__BesVisLib_rootcint_844_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 4, 1, 1, 0,
16242 "i - - 0 - part i - - 0 - seg "
16243 "i - - 0 - absorber i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16244 G__memfunc_setup("GetGap",568,G__BesVisLib_rootcint_844_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16245 "i - - 0 - part i - - 0 - seg "
16246 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16247 G__memfunc_setup("GetStripPlane",1314,G__BesVisLib_rootcint_844_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 3, 1, 1, 0,
16248 "i - - 0 - part i - - 0 - seg "
16249 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16250 G__memfunc_setup("GetStrip",818,G__BesVisLib_rootcint_844_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoNode), -1, 0, 4, 1, 1, 0,
16251 "i - - 0 - part i - - 0 - seg "
16252 "i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16253 G__memfunc_setup("GetPhysicalAbsorber",1933,G__BesVisLib_rootcint_844_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 4, 1, 1, 0,
16254 "i - - 0 - part i - - 0 - seg "
16255 "i - - 0 - gap i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16256 G__memfunc_setup("GetPhysicalGap",1397,G__BesVisLib_rootcint_844_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16257 "i - - 0 - part i - - 0 - seg "
16258 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16259 G__memfunc_setup("GetPhysicalStrip",1647,G__BesVisLib_rootcint_844_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 4, 1, 1, 0,
16260 "i - - 0 - part i - - 0 - seg "
16261 "i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16262 G__memfunc_setup("Get2DStrip",936,G__BesVisLib_rootcint_844_0_42, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_Muc2DStrip), -1, 0, 4, 1, 1, 0,
16263 "i - - 0 - part i - - 0 - seg "
16264 "i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16265 G__memfunc_setup("GetPart",695,G__BesVisLib_rootcint_844_0_43, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - phyNode", (char*)NULL, (void*) NULL, 0);
16266 G__memfunc_setup("IsZRVisible",1078,G__BesVisLib_rootcint_844_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0,
16267 "i - - 0 - part i - - 0 - seg", (char*)NULL, (void*) NULL, 0);
16268 G__memfunc_setup("Range360",646,G__BesVisLib_rootcint_844_0_45, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - input", (char*)NULL, (void*) NULL, 0);
16269 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_844_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16270 G__memfunc_setup("DrawHits",806,G__BesVisLib_rootcint_844_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16271
16272 G__memfunc_setup("MucROOTGeo", 900, G__BesVisLib_rootcint_844_0_48, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 1, 1, 1, 0, "u 'MucROOTGeo' - 11 - -", (char*) NULL, (void*) NULL, 0);
16273
16274 G__memfunc_setup("~MucROOTGeo", 1026, G__BesVisLib_rootcint_844_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16275 G__tag_memfunc_reset();
16276 }
16277
16278 static void G__setup_memfuncBesGeometry(void) {
16279
16280 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry));
16281 G__memfunc_setup("BesGeometry",1126,G__BesVisLib_rootcint_845_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16282 G__memfunc_setup("InitFromGDML",1100,G__BesVisLib_rootcint_845_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - fPath", (char*)NULL, (void*) NULL, 1);
16283 G__memfunc_setup("InitFromROOT",1132,G__BesVisLib_rootcint_845_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volBes", (char*)NULL, (void*) NULL, 1);
16284 G__memfunc_setup("InitGeometry",1248,G__BesVisLib_rootcint_845_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16285 G__memfunc_setup("GetFilename",1089,G__BesVisLib_rootcint_845_0_5, 67, -1, -1, 0, 1, 1, 1, 1, "C - - 10 - RunPeriod", (char*)NULL, (void*) NULL, 0);
16286 G__memfunc_setup("SetDefaultVis",1315,G__BesVisLib_rootcint_845_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16287 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
16288 G__memfunc_setup("Draw3D",517,G__BesVisLib_rootcint_845_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16289 G__memfunc_setup("Draw2DXY",693,G__BesVisLib_rootcint_845_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16290 G__memfunc_setup("Draw2DZR",688,G__BesVisLib_rootcint_845_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16291 G__memfunc_setup("GetBesR",652,G__BesVisLib_rootcint_845_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16292 G__memfunc_setup("GetBesZ",660,G__BesVisLib_rootcint_845_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16293 G__memfunc_setup("GetVolBes",875,G__BesVisLib_rootcint_845_0_13, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16294 G__memfunc_setup("GetVolumeBeamPipe",1691,G__BesVisLib_rootcint_845_0_14, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16295 G__memfunc_setup("GetMdcROOTGeo",1171,G__BesVisLib_rootcint_845_0_15, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16296 G__memfunc_setup("GetTofROOTGeo",1192,G__BesVisLib_rootcint_845_0_16, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16297 G__memfunc_setup("GetEmcROOTGeo",1172,G__BesVisLib_rootcint_845_0_17, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16298 G__memfunc_setup("GetMucROOTGeo",1188,G__BesVisLib_rootcint_845_0_18, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16299 G__memfunc_setup("GetVolumeMdc",1196,G__BesVisLib_rootcint_845_0_19, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16300 G__memfunc_setup("GetVolumeMdcSegment",1919,G__BesVisLib_rootcint_845_0_20, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - segment", (char*)NULL, (void*) NULL, 0);
16301 G__memfunc_setup("GetVolumeMdcLayer",1705,G__BesVisLib_rootcint_845_0_21, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16302 G__memfunc_setup("GetVolumeMdcReplica",1900,G__BesVisLib_rootcint_845_0_22, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - layer", (char*)NULL, (void*) NULL, 0);
16303 G__memfunc_setup("GetPhysicalMdcReplica",2097,G__BesVisLib_rootcint_845_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 2, 1, 1, 0,
16304 "i - - 0 - layer i - - 0 - replica", (char*)NULL, (void*) NULL, 0);
16305 G__memfunc_setup("GetVolumeTof",1217,G__BesVisLib_rootcint_845_0_24, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16306 G__memfunc_setup("GetPhysicalTofScin",1811,G__BesVisLib_rootcint_845_0_25, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16307 "i - - 0 - part i - - 0 - layer "
16308 "i - - 0 - scin", (char*)NULL, (void*) NULL, 0);
16309 G__memfunc_setup("GetVolumeEmc",1197,G__BesVisLib_rootcint_845_0_26, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16310 G__memfunc_setup("GetVolumeEmcPart",1604,G__BesVisLib_rootcint_845_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "i - - 0 - part", (char*)NULL, (void*) NULL, 0);
16311 G__memfunc_setup("GetVolumeEmcPhi",1486,G__BesVisLib_rootcint_845_0_28, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 2, 1, 1, 0,
16312 "i - - 0 - part i - - 0 - phi", (char*)NULL, (void*) NULL, 0);
16313 G__memfunc_setup("GetVolumeEmcTheta",1699,G__BesVisLib_rootcint_845_0_29, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16314 "i - - 0 - part i - - 0 - phi "
16315 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16316 G__memfunc_setup("GetVolumeEmcCrystal",1935,G__BesVisLib_rootcint_845_0_30, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16317 "i - - 0 - part i - - 0 - phi "
16318 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16319 G__memfunc_setup("GetPhysicalEmcCrystal",2132,G__BesVisLib_rootcint_845_0_31, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16320 "i - - 0 - part i - - 0 - phi "
16321 "i - - 0 - theta", (char*)NULL, (void*) NULL, 0);
16322 G__memfunc_setup("GetVolumeMuc",1213,G__BesVisLib_rootcint_845_0_32, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16323 G__memfunc_setup("GetVolumeMucAbsorber",2029,G__BesVisLib_rootcint_845_0_33, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16324 "i - - 0 - part i - - 0 - seg "
16325 "i - - 0 - absorber", (char*)NULL, (void*) NULL, 0);
16326 G__memfunc_setup("GetVolumeMucAbsorberPanel",2525,G__BesVisLib_rootcint_845_0_34, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16327 "i - - 0 - part i - - 0 - seg "
16328 "i - - 0 - absorber i - - 0 - panel", (char*)NULL, (void*) NULL, 0);
16329 G__memfunc_setup("GetVolumeMucGap",1493,G__BesVisLib_rootcint_845_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16330 "i - - 0 - part i - - 0 - seg "
16331 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16332 G__memfunc_setup("GetVolumeMucStripPlane",2239,G__BesVisLib_rootcint_845_0_36, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 3, 1, 1, 0,
16333 "i - - 0 - part i - - 0 - seg "
16334 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16335 G__memfunc_setup("GetVolumeMucStrip",1743,G__BesVisLib_rootcint_845_0_37, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 4, 1, 1, 0,
16336 "i - - 0 - part i - - 0 - seg "
16337 "i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16338 G__memfunc_setup("GetVolumeMucGasChamber",2186,G__BesVisLib_rootcint_845_0_38, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 5, 1, 1, 0,
16339 "i - - 0 - part i - - 0 - seg "
16340 "i - - 0 - gap i - - 0 - panel "
16341 "i - - 0 - gasChamber", (char*)NULL, (void*) NULL, 0);
16342 G__memfunc_setup("GetVolumeMucBakelite",2014,G__BesVisLib_rootcint_845_0_39, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 6, 1, 1, 0,
16343 "i - - 0 - part i - - 0 - seg "
16344 "i - - 0 - gap i - - 0 - RpcUpDown "
16345 "i - - 0 - panel i - - 0 - bakelite", (char*)NULL, (void*) NULL, 0);
16346 G__memfunc_setup("GetPhysicalMucGap",1690,G__BesVisLib_rootcint_845_0_40, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 3, 1, 1, 0,
16347 "i - - 0 - part i - - 0 - seg "
16348 "i - - 0 - gap", (char*)NULL, (void*) NULL, 0);
16349 G__memfunc_setup("GetPhysicalMucStrip",1940,G__BesVisLib_rootcint_845_0_41, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoPhysicalNode), -1, 0, 4, 1, 1, 0,
16350 "i - - 0 - part i - - 0 - seg "
16351 "i - - 0 - gap i - - 0 - strip", (char*)NULL, (void*) NULL, 0);
16352 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_845_0_42, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGeometry::Class) ), 0);
16353 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_845_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeometry::Class_Name) ), 0);
16354 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_845_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGeometry::Class_Version) ), 0);
16355 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_845_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGeometry::Dictionary) ), 0);
16356 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16357 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16358 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16359 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_845_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16360 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_845_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeometry::DeclFileName) ), 0);
16361 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_845_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeometry::ImplFileLine) ), 0);
16362 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_845_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGeometry::ImplFileName) ), 0);
16363 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_845_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGeometry::DeclFileLine) ), 0);
16364
16365 G__memfunc_setup("BesGeometry", 1126, G__BesVisLib_rootcint_845_0_54, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 0, 1, 1, 1, 0, "u 'BesGeometry' - 11 - -", (char*) NULL, (void*) NULL, 0);
16366
16367 G__memfunc_setup("~BesGeometry", 1252, G__BesVisLib_rootcint_845_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16368
16369 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_845_0_56, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 1, 1, 1, 1, 0, "u 'BesGeometry' - 11 - -", (char*) NULL, (void*) NULL, 0);
16370 G__tag_memfunc_reset();
16371 }
16372
16373 static void G__setup_memfuncBesGMenuTitle(void) {
16374
16375 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle));
16376 G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
16377 G__memfunc_setup("BesGMenuTitle",1272,G__BesVisLib_rootcint_925_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle), -1, 0, 6, 1, 1, 0,
16378 "U 'TGWindow' - 10 '0' p U 'TGHotString' - 0 '0' s "
16379 "U 'TGPopupMenu' - 0 '0' menu k - 'GContext_t' 0 'GetDefaultGC()()' norm "
16380 "k - 'FontStruct_t' 0 'GetDefaultFontStruct()' font h - 'UInt_t' 0 '0' options", (char*)NULL, (void*) NULL, 0);
16381 G__memfunc_setup("SetPicture",1032,G__BesVisLib_rootcint_925_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - pic", (char*)NULL, (void*) NULL, 1);
16382 G__memfunc_setup("SetPictureHL",1180,G__BesVisLib_rootcint_925_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixmap_t' 0 - pic", (char*)NULL, (void*) NULL, 1);
16383 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_925_0_5, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGMenuTitle::Class) ), 0);
16384 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_925_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuTitle::Class_Name) ), 0);
16385 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_925_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGMenuTitle::Class_Version) ), 0);
16386 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_925_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGMenuTitle::Dictionary) ), 0);
16387 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16388 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16389 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16390 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_925_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16391 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_925_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuTitle::DeclFileName) ), 0);
16392 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_925_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuTitle::ImplFileLine) ), 0);
16393 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_925_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuTitle::ImplFileName) ), 0);
16394 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_925_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuTitle::DeclFileLine) ), 0);
16395
16396 G__memfunc_setup("~BesGMenuTitle", 1398, G__BesVisLib_rootcint_925_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16397 G__tag_memfunc_reset();
16398 }
16399
16400 static void G__setup_memfuncBesGMenuBar(void) {
16401
16402 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar));
16403 G__memfunc_setup("AddFrameBefore",1351,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
16404 "U 'TGFrame' - 0 - f U 'TGLayoutHints' - 0 '0' l "
16405 "U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
16406 G__memfunc_setup("BesGMenuBar",1035,G__BesVisLib_rootcint_926_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuBar), -1, 0, 4, 1, 1, 0,
16407 "U 'TGWindow' - 10 '0' p h - 'UInt_t' 0 '60' w "
16408 "h - 'UInt_t' 0 '20' h h - 'UInt_t' 0 'kHorizontalFrame|kRaisedFrame' options", (char*)NULL, (void*) NULL, 0);
16409 G__memfunc_setup("AddPopup",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16410 "U 'TGHotString' - 0 - s U 'TGPopupMenu' - 0 - menu "
16411 "U 'TGLayoutHints' - 0 - l U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
16412 G__memfunc_setup("AddPopup",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16413 "C - - 10 - s U 'TGPopupMenu' - 0 - menu "
16414 "U 'TGLayoutHints' - 0 - l U 'TGPopupMenu' - 0 '0' before", (char*)NULL, (void*) NULL, 1);
16415 G__memfunc_setup("GetMenuTitle",1207,G__BesVisLib_rootcint_926_0_5, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGMenuTitle), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
16416 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_926_0_6, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGMenuBar::Class) ), 0);
16417 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_926_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuBar::Class_Name) ), 0);
16418 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_926_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGMenuBar::Class_Version) ), 0);
16419 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_926_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGMenuBar::Dictionary) ), 0);
16420 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16421 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16422 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16423 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_926_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16424 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_926_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuBar::DeclFileName) ), 0);
16425 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_926_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuBar::ImplFileLine) ), 0);
16426 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_926_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGMenuBar::ImplFileName) ), 0);
16427 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_926_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGMenuBar::DeclFileLine) ), 0);
16428
16429 G__memfunc_setup("~BesGMenuBar", 1161, G__BesVisLib_rootcint_926_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16430 G__tag_memfunc_reset();
16431 }
16432
16433 static void G__setup_memfuncBesGPictureButton(void) {
16434
16435 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton));
16436 G__memfunc_setup("BesGPictureButton",1721,G__BesVisLib_rootcint_934_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton), -1, 0, 5, 1, 1, 0,
16437 "U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
16438 "i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
16439 "h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
16440 G__memfunc_setup("BesGPictureButton",1721,G__BesVisLib_rootcint_934_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton), -1, 0, 6, 1, 1, 0,
16441 "U 'TGWindow' - 10 - p U 'TGPicture' - 10 - pic "
16442 "C - - 10 - cmd i - 'Int_t' 0 '-1' id "
16443 "k - 'GContext_t' 0 'GetDefaultGC()()' norm h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
16444 G__memfunc_setup("BesGPictureButton",1721,G__BesVisLib_rootcint_934_0_3, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGPictureButton), -1, 0, 5, 1, 1, 0,
16445 "U 'TGWindow' - 10 '0' p C - - 10 '0' pic "
16446 "i - 'Int_t' 0 '-1' id k - 'GContext_t' 0 'GetDefaultGC()()' norm "
16447 "h - 'UInt_t' 0 'kRaisedFrame|kDoubleBorder' option", (char*)NULL, (void*) NULL, 0);
16448 G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
16449 G__memfunc_setup("IsStateOn",890,G__BesVisLib_rootcint_934_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16450 G__memfunc_setup("SetState",813,G__BesVisLib_rootcint_934_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
16451 G__memfunc_setup("SetPicture",1032,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - new_pic", (char*)NULL, (void*) NULL, 1);
16452 G__memfunc_setup("SetPictureHL",1180,G__BesVisLib_rootcint_934_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGPicture' - 10 - hl_pic", (char*)NULL, (void*) NULL, 1);
16453 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_934_0_9, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesGPictureButton::Class) ), 0);
16454 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_934_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGPictureButton::Class_Name) ), 0);
16455 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_934_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesGPictureButton::Class_Version) ), 0);
16456 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_934_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesGPictureButton::Dictionary) ), 0);
16457 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16458 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16459 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16460 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_934_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16461 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_934_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGPictureButton::DeclFileName) ), 0);
16462 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_934_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGPictureButton::ImplFileLine) ), 0);
16463 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_934_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesGPictureButton::ImplFileName) ), 0);
16464 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_934_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesGPictureButton::DeclFileLine) ), 0);
16465
16466 G__memfunc_setup("~BesGPictureButton", 1847, G__BesVisLib_rootcint_934_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16467 G__tag_memfunc_reset();
16468 }
16469
16470 static void G__setup_memfuncBesHeader(void) {
16471
16472 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader));
16473 G__memfunc_setup("BesHeader",867,G__BesVisLib_rootcint_935_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16474 G__memfunc_setup("BesHeader",867,G__BesVisLib_rootcint_935_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesHeader), -1, 0, 5, 1, 1, 0,
16475 "d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
16476 "d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
16477 "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
16478 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16479 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16480 G__memfunc_setup("SetMdcOn",765,G__BesVisLib_rootcint_935_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mdcOn", "*TOGGLE*", (void*) NULL, 0);
16481 G__memfunc_setup("GetMdcOn",753,G__BesVisLib_rootcint_935_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16482 G__memfunc_setup("TransferMdcOn",1302,G__BesVisLib_rootcint_935_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", "*SIGNAL*", (void*) NULL, 0);
16483 G__memfunc_setup("SetTofOn",786,G__BesVisLib_rootcint_935_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - tofOn", "*TOGGLE*", (void*) NULL, 0);
16484 G__memfunc_setup("GetTofOn",774,G__BesVisLib_rootcint_935_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16485 G__memfunc_setup("TransferTofOn",1323,G__BesVisLib_rootcint_935_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", "*SIGNAL*", (void*) NULL, 0);
16486 G__memfunc_setup("SetEmcOn",766,G__BesVisLib_rootcint_935_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - emcOn", "*TOGGLE*", (void*) NULL, 0);
16487 G__memfunc_setup("GetEmcOn",754,G__BesVisLib_rootcint_935_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16488 G__memfunc_setup("TransferEmcOn",1303,G__BesVisLib_rootcint_935_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - input", "*SIGNAL*", (void*) NULL, 0);
16489 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16490 G__memfunc_setup("DeleteText",1016,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16491 G__memfunc_setup("EditText",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16492 G__memfunc_setup("InsertLine",1021,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16493 G__memfunc_setup("InsertText",1050,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
16494 G__memfunc_setup("ReadFile",764,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16495 "C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
16496 "i - 'Int_t' 0 '50' nlines i - 'Int_t' 0 '0' fromline", (char*)NULL, (void*) NULL, 1);
16497 G__memfunc_setup("SetAllWith",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16498 "C - - 10 - text C - 'Option_t' 10 - option "
16499 "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 1);
16500 G__memfunc_setup("SetLabel",780,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - label", (char*)NULL, (void*) NULL, 1);
16501 G__memfunc_setup("SetMargin",906,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.05' margin", (char*)NULL, (void*) NULL, 1);
16502 G__memfunc_setup("SetBorderSize",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '4' bordersize", (char*)NULL, (void*) NULL, 1);
16503 G__memfunc_setup("SetCornerRadius",1533,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.2' rad", (char*)NULL, (void*) NULL, 1);
16504 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 1);
16505 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16506 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_935_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16507 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_935_0_27, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TObject), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16508 G__memfunc_setup("Dump",406,G__BesVisLib_rootcint_935_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16509 G__memfunc_setup("Inspect",726,G__BesVisLib_rootcint_935_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16510 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16511 G__memfunc_setup("SetLineAttributes",1755,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16512 G__memfunc_setup("SetFillAttributes",1754,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16513 G__memfunc_setup("SetTextAttributes",1784,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16514 G__memfunc_setup("SetTextAngle",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0' tangle", (char*)NULL, (void*) NULL, 1);
16515 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_935_0_35, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesHeader::Class) ), 0);
16516 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_935_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesHeader::Class_Name) ), 0);
16517 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_935_0_37, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesHeader::Class_Version) ), 0);
16518 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_935_0_38, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesHeader::Dictionary) ), 0);
16519 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16520 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16521 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16522 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_935_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16523 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_935_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesHeader::DeclFileName) ), 0);
16524 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_935_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesHeader::ImplFileLine) ), 0);
16525 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_935_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesHeader::ImplFileName) ), 0);
16526 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_935_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesHeader::DeclFileLine) ), 0);
16527
16528 G__memfunc_setup("~BesHeader", 993, G__BesVisLib_rootcint_935_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16529 G__tag_memfunc_reset();
16530 }
16531
16532 static void G__setup_memfuncBesVisDisplay(void) {
16533
16534 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay));
16535 G__memfunc_setup("BesVisDisplay",1314,G__BesVisLib_rootcint_957_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16536 G__memfunc_setup("BesVisDisplay",1314,G__BesVisLib_rootcint_957_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesVisDisplay), -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 0);
16537 G__memfunc_setup("SetCanvas",904,G__BesVisLib_rootcint_957_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 '0' c", (char*)NULL, (void*) NULL, 1);
16538 G__memfunc_setup("SetDisplayMode",1415,G__BesVisLib_rootcint_957_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
16539 G__memfunc_setup("GetDisplayMode",1403,G__BesVisLib_rootcint_957_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16540 G__memfunc_setup("IsVHeader",859,G__BesVisLib_rootcint_957_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16541 G__memfunc_setup("SwitchDisplayMode",1741,G__BesVisLib_rootcint_957_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 1);
16542 G__memfunc_setup("ResizePad",903,G__BesVisLib_rootcint_957_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16543 G__memfunc_setup("SwitchPad",903,G__BesVisLib_rootcint_957_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16544 G__memfunc_setup("GetPadXY",742,G__BesVisLib_rootcint_957_0_10, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16545 G__memfunc_setup("GetPadZR",737,G__BesVisLib_rootcint_957_0_11, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16546 G__memfunc_setup("GetPad3D",684,G__BesVisLib_rootcint_957_0_12, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16547 G__memfunc_setup("DrawHeader",983,G__BesVisLib_rootcint_957_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16548 G__memfunc_setup("Reset",515,G__BesVisLib_rootcint_957_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16549 G__memfunc_setup("InitGeometryFromGDML",1944,G__BesVisLib_rootcint_957_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - fPath", (char*)NULL, (void*) NULL, 1);
16550 G__memfunc_setup("InitGeometryFromROOT",1976,G__BesVisLib_rootcint_957_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - bes", (char*)NULL, (void*) NULL, 1);
16551 G__memfunc_setup("GetBesGeometry",1414,G__BesVisLib_rootcint_957_0_17, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_BesGeometry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16552 G__memfunc_setup("SetMdcOn",765,G__BesVisLib_rootcint_957_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - MdcOn", "*TOGGLE*", (void*) NULL, 1);
16553 G__memfunc_setup("GetMdcOn",753,G__BesVisLib_rootcint_957_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16554 G__memfunc_setup("SetTofOn",786,G__BesVisLib_rootcint_957_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - TofOn", "*TOGGLE*", (void*) NULL, 1);
16555 G__memfunc_setup("GetTofOn",774,G__BesVisLib_rootcint_957_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16556 G__memfunc_setup("SetEmcOn",766,G__BesVisLib_rootcint_957_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - EmcOn", "*TOGGLE*", (void*) NULL, 1);
16557 G__memfunc_setup("GetEmcOn",754,G__BesVisLib_rootcint_957_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16558 G__memfunc_setup("AllViews",807,G__BesVisLib_rootcint_957_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16559 G__memfunc_setup("Clear",487,G__BesVisLib_rootcint_957_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16560 G__memfunc_setup("DisplayTrigger",1450,G__BesVisLib_rootcint_957_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trig", (char*)NULL, (void*) NULL, 1);
16561 G__memfunc_setup("DistancetoPrimitive",1991,G__BesVisLib_rootcint_957_0_27, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
16562 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16563 G__memfunc_setup("Draw",398,G__BesVisLib_rootcint_957_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16564 G__memfunc_setup("Draw2D",516,G__BesVisLib_rootcint_957_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
16565 G__memfunc_setup("Draw3D",517,G__BesVisLib_rootcint_957_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
16566 G__memfunc_setup("Draw2DXY",693,G__BesVisLib_rootcint_957_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
16567 G__memfunc_setup("Draw2DZR",688,G__BesVisLib_rootcint_957_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
16568 G__memfunc_setup("DrawAllViews",1205,G__BesVisLib_rootcint_957_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16569 G__memfunc_setup("DrawClusters",1251,G__BesVisLib_rootcint_957_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16570 G__memfunc_setup("DrawParticles",1333,G__BesVisLib_rootcint_957_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16571 G__memfunc_setup("DrawParticles2",1383,G__BesVisLib_rootcint_957_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16572 G__memfunc_setup("DrawTitle",912,G__BesVisLib_rootcint_957_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16573 G__memfunc_setup("DrawView",809,G__BesVisLib_rootcint_957_0_38, 121, -1, -1, 0, 2, 1, 1, 0,
16574 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
16575 G__memfunc_setup("DrawViewRange",1302,G__BesVisLib_rootcint_957_0_39, 121, -1, -1, 0, 4, 1, 1, 0,
16576 "d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
16577 "d - 'Double_t' 0 - z0 d - 'Double_t' 0 - zoomSize", (char*)NULL, (void*) NULL, 0);
16578 G__memfunc_setup("DrawViewGL",956,G__BesVisLib_rootcint_957_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16579 G__memfunc_setup("DrawViewX3D",1016,G__BesVisLib_rootcint_957_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16580 G__memfunc_setup("DrawViewRaytracer",1750,G__BesVisLib_rootcint_957_0_42, 121, -1, -1, 0, 3, 1, 1, 0,
16581 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi "
16582 "f - 'Float_t' 0 - psi", (char*)NULL, (void*) NULL, 1);
16583 G__memfunc_setup("DrawViewX3D",1016,G__BesVisLib_rootcint_957_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "c - - 0 - option", (char*)NULL, (void*) NULL, 1);
16584 G__memfunc_setup("DrawImageSequence",1706,G__BesVisLib_rootcint_957_0_44, 121, -1, -1, 0, 2, 1, 1, 0,
16585 "i - 'Int_t' 0 - thetaStart i - 'Int_t' 0 - thetaStep", (char*)NULL, (void*) NULL, 0);
16586 G__memfunc_setup("ExecuteEvent",1237,G__BesVisLib_rootcint_957_0_45, 121, -1, -1, 0, 3, 1, 1, 0,
16587 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16588 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16589 G__memfunc_setup("GetEvent",802,G__BesVisLib_rootcint_957_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - event", "*MENU*", (void*) NULL, 1);
16590 G__memfunc_setup("GetVolBes",875,G__BesVisLib_rootcint_957_0_47, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16591 G__memfunc_setup("GetMdcROOTGeo",1171,G__BesVisLib_rootcint_957_0_48, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MdcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16592 G__memfunc_setup("GetTofROOTGeo",1192,G__BesVisLib_rootcint_957_0_49, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TofROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16593 G__memfunc_setup("GetEmcROOTGeo",1172,G__BesVisLib_rootcint_957_0_50, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_EmcROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16594 G__memfunc_setup("GetMucROOTGeo",1188,G__BesVisLib_rootcint_957_0_51, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_MucROOTGeo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16595 G__memfunc_setup("Init",404,G__BesVisLib_rootcint_957_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16596 G__memfunc_setup("Pad",277,G__BesVisLib_rootcint_957_0_53, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16597 G__memfunc_setup("Paint",508,G__BesVisLib_rootcint_957_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16598 G__memfunc_setup("PaintFruit",1030,G__BesVisLib_rootcint_957_0_55, 121, -1, -1, 0, 6, 1, 1, 0,
16599 "U 'TObject' - 0 - obj f - 'Float_t' 0 - eta "
16600 "f - 'Float_t' 0 - phi f - 'Float_t' 0 - pt "
16601 "i - 'Int_t' 0 - type C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16602 G__memfunc_setup("PaintParticles",1443,G__BesVisLib_rootcint_957_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
16603 G__memfunc_setup("PTcut",496,G__BesVisLib_rootcint_957_0_57, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16604 G__memfunc_setup("PTcutEGMUNU",961,G__BesVisLib_rootcint_957_0_58, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16605 G__memfunc_setup("Rin",297,G__BesVisLib_rootcint_957_0_59, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16606 G__memfunc_setup("Rout",426,G__BesVisLib_rootcint_957_0_60, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16607 G__memfunc_setup("SetDrawClusters",1551,G__BesVisLib_rootcint_957_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' draw", "*MENU*", (void*) NULL, 1);
16608 G__memfunc_setup("SetDrawParticles",1633,G__BesVisLib_rootcint_957_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' draw", "*MENU*", (void*) NULL, 1);
16609 G__memfunc_setup("SetPTcut",796,G__BesVisLib_rootcint_957_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '0.4' ptcut", "*MENU*", (void*) NULL, 1);
16610 G__memfunc_setup("SetPTcutEGMUNU",1261,G__BesVisLib_rootcint_957_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '5' ptcut", "*MENU*", (void*) NULL, 1);
16611 G__memfunc_setup("SetView",711,G__BesVisLib_rootcint_957_0_65, 121, -1, -1, 0, 2, 1, 1, 0,
16612 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
16613 G__memfunc_setup("ShowNextEvent",1346,G__BesVisLib_rootcint_957_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' delta", (char*)NULL, (void*) NULL, 1);
16614 G__memfunc_setup("SetMdcCon",864,G__BesVisLib_rootcint_957_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mdcCon", (char*)NULL, (void*) NULL, 0);
16615 G__memfunc_setup("SetTofCon",885,G__BesVisLib_rootcint_957_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofCon", (char*)NULL, (void*) NULL, 0);
16616 G__memfunc_setup("SetEmcCon",865,G__BesVisLib_rootcint_957_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - emcCon", (char*)NULL, (void*) NULL, 0);
16617 G__memfunc_setup("SetMucCon",881,G__BesVisLib_rootcint_957_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mucCon", (char*)NULL, (void*) NULL, 0);
16618 G__memfunc_setup("SetAllVisible",1299,G__BesVisLib_rootcint_957_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
16619 G__memfunc_setup("SetQuarterVisible",1758,G__BesVisLib_rootcint_957_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
16620 G__memfunc_setup("SetHalfVisible",1397,G__BesVisLib_rootcint_957_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
16621 G__memfunc_setup("SetNoEndVisible",1486,G__BesVisLib_rootcint_957_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
16622 G__memfunc_setup("SetMdcFiredCell",1450,G__BesVisLib_rootcint_957_0_75, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16623 G__memfunc_setup("SetTofFiredCell",1471,G__BesVisLib_rootcint_957_0_76, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16624 G__memfunc_setup("SetEmcFiredCell",1451,G__BesVisLib_rootcint_957_0_77, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16625 G__memfunc_setup("SetMucFiredCell",1467,G__BesVisLib_rootcint_957_0_78, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16626 G__memfunc_setup("SizeFruit",933,G__BesVisLib_rootcint_957_0_79, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16627 G__memfunc_setup("SizeParticles",1346,G__BesVisLib_rootcint_957_0_80, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16628 G__memfunc_setup("Zin",305,G__BesVisLib_rootcint_957_0_81, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16629 G__memfunc_setup("Zout",434,G__BesVisLib_rootcint_957_0_82, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16630 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_957_0_83, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&BesVisDisplay::Class) ), 0);
16631 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_957_0_84, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesVisDisplay::Class_Name) ), 0);
16632 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_957_0_85, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&BesVisDisplay::Class_Version) ), 0);
16633 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_957_0_86, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BesVisDisplay::Dictionary) ), 0);
16634 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16635 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16636 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16637 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_957_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16638 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_957_0_91, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesVisDisplay::DeclFileName) ), 0);
16639 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_957_0_92, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesVisDisplay::ImplFileLine) ), 0);
16640 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_957_0_93, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&BesVisDisplay::ImplFileName) ), 0);
16641 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_957_0_94, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&BesVisDisplay::DeclFileLine) ), 0);
16642
16643 G__memfunc_setup("~BesVisDisplay", 1440, G__BesVisLib_rootcint_957_0_95, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16644 G__tag_memfunc_reset();
16645 }
16646
16647 static void G__setup_memfuncZHelix(void) {
16648
16649 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix));
16650 G__memfunc_setup("ZHelix",596,G__BesVisLib_rootcint_960_0_1, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16651 G__memfunc_setup("ZHelix",596,G__BesVisLib_rootcint_960_0_2, 105, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 0, 14, 1, 1, 0,
16652 "d - 'Double_t' 0 - Azim d - 'Double_t' 0 - QovR "
16653 "d - 'Double_t' 0 - QxDh d - 'Double_t' 0 - refx "
16654 "d - 'Double_t' 0 - refy d - 'Double_t' 0 - refz "
16655 "d - 'Double_t' 0 - TDip d - 'Double_t' 0 - phii "
16656 "d - 'Double_t' 0 - phio f - 'Float_t' 0 - Chi2 "
16657 "i - 'Int_t' 0 - NDoF i 'EZHelixRangeType' - 0 'kHelixPhi' RangeType "
16658 "d - 'Double_t' 0 '0' RangeMin d - 'Double_t' 0 '2*TMath::Pi()' RangeMax", (char*)NULL, (void*) NULL, 0);
16659 G__memfunc_setup("Phi2XYZ",606,G__BesVisLib_rootcint_960_0_3, 121, -1, -1, 0, 4, 1, 1, 0,
16660 "d - 'Double_t' 0 - phi d - 'Double_t' 1 - x "
16661 "d - 'Double_t' 1 - y d - 'Double_t' 1 - z", (char*)NULL, (void*) NULL, 0);
16662 G__memfunc_setup("Phi2ZR",511,G__BesVisLib_rootcint_960_0_4, 121, -1, -1, 0, 3, 1, 1, 0,
16663 "d - 'Double_t' 0 - phi d - 'Double_t' 1 - z "
16664 "d - 'Double_t' 1 - r", (char*)NULL, (void*) NULL, 0);
16665 G__memfunc_setup("SetRange",793,G__BesVisLib_rootcint_960_0_5, 121, -1, -1, 0, 3, 1, 1, 0,
16666 "i 'EZHelixRangeType' - 0 - RangeType d - 'Double_t' 0 - RangeMin "
16667 "d - 'Double_t' 0 - RangeMax", (char*)NULL, (void*) NULL, 0);
16668 G__memfunc_setup("SetTrackType",1219,G__BesVisLib_rootcint_960_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TrackType' - 0 - tt", (char*)NULL, (void*) NULL, 0);
16669 G__memfunc_setup("SetPoints",937,G__BesVisLib_rootcint_960_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
16670 G__memfunc_setup("X2Phi",427,G__BesVisLib_rootcint_960_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
16671 G__memfunc_setup("Y2Phi",428,G__BesVisLib_rootcint_960_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
16672 G__memfunc_setup("Z2Phi",429,G__BesVisLib_rootcint_960_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
16673 G__memfunc_setup("R2Phi",421,G__BesVisLib_rootcint_960_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 0);
16674 G__memfunc_setup("Phi2S",422,G__BesVisLib_rootcint_960_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
16675 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
16676 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
16677 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"3D\"' option", (char*)NULL, (void*) NULL, 1);
16678 G__memfunc_setup("SetNextPoint",1237,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
16679 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
16680 "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
16681 G__memfunc_setup("SetPoint",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
16682 "i - 'Int_t' 0 - point d - 'Double_t' 0 - x "
16683 "d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
16684 G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16685 G__memfunc_setup("DrawClass",900,G__BesVisLib_rootcint_960_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16686 G__memfunc_setup("DrawClone",895,G__BesVisLib_rootcint_960_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16687 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
16688 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
16689 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
16690 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
16691 G__memfunc_setup("Class",502,G__BesVisLib_rootcint_960_0_23, 85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ZHelix::Class) ), 0);
16692 G__memfunc_setup("Class_Name",982,G__BesVisLib_rootcint_960_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ZHelix::Class_Name) ), 0);
16693 G__memfunc_setup("Class_Version",1339,G__BesVisLib_rootcint_960_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ZHelix::Class_Version) ), 0);
16694 G__memfunc_setup("Dictionary",1046,G__BesVisLib_rootcint_960_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ZHelix::Dictionary) ), 0);
16695 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__BesVisLib_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16696 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
16697 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
16698 G__memfunc_setup("StreamerNVirtual",1656,G__BesVisLib_rootcint_960_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
16699 G__memfunc_setup("DeclFileName",1145,G__BesVisLib_rootcint_960_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ZHelix::DeclFileName) ), 0);
16700 G__memfunc_setup("ImplFileLine",1178,G__BesVisLib_rootcint_960_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ZHelix::ImplFileLine) ), 0);
16701 G__memfunc_setup("ImplFileName",1171,G__BesVisLib_rootcint_960_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ZHelix::ImplFileName) ), 0);
16702 G__memfunc_setup("DeclFileLine",1152,G__BesVisLib_rootcint_960_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ZHelix::DeclFileLine) ), 0);
16703
16704 G__memfunc_setup("ZHelix", 596, G__BesVisLib_rootcint_960_0_35, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 0, 1, 1, 1, 0, "u 'ZHelix' - 11 - -", (char*) NULL, (void*) NULL, 0);
16705
16706 G__memfunc_setup("~ZHelix", 722, G__BesVisLib_rootcint_960_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16707
16708 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_960_0_37, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_ZHelix), -1, 1, 1, 1, 1, 0, "u 'ZHelix' - 11 - -", (char*) NULL, (void*) NULL, 0);
16709 G__tag_memfunc_reset();
16710 }
16711
16712 static void G__setup_memfuncvector3(void) {
16713
16714 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3));
16715
16716 G__memfunc_setup("vector3", 710, G__BesVisLib_rootcint_961_0_1, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16717
16718 G__memfunc_setup("vector3", 710, G__BesVisLib_rootcint_961_0_2, (int) ('i'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3), -1, 0, 1, 1, 1, 0, "u 'vector3' - 11 - -", (char*) NULL, (void*) NULL, 0);
16719
16720 G__memfunc_setup("~vector3", 836, G__BesVisLib_rootcint_961_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16721
16722 G__memfunc_setup("operator=", 937, G__BesVisLib_rootcint_961_0_4, (int) ('u'), G__get_linked_tagnum(&G__BesVisLib_rootcintLN_vector3), -1, 1, 1, 1, 1, 0, "u 'vector3' - 11 - -", (char*) NULL, (void*) NULL, 0);
16723 G__tag_memfunc_reset();
16724 }
16725
16726
16727
16728
16729
16730 extern "C" void G__cpp_setup_memfuncBesVisLib_rootcint() {
16731 }
16732
16733
16734
16735
16736 static void G__cpp_setup_global0() {
16737
16738
16739 G__resetplocal();
16740
16741 }
16742
16743 static void G__cpp_setup_global1() {
16744 }
16745
16746 static void G__cpp_setup_global2() {
16747 }
16748
16749 static void G__cpp_setup_global3() {
16750 }
16751
16752 static void G__cpp_setup_global4() {
16753 }
16754
16755 static void G__cpp_setup_global5() {
16756 }
16757
16758 static void G__cpp_setup_global6() {
16759 }
16760
16761 static void G__cpp_setup_global7() {
16762 }
16763
16764 static void G__cpp_setup_global8() {
16765
16766 G__resetglobalenv();
16767 }
16768 extern "C" void G__cpp_setup_globalBesVisLib_rootcint() {
16769 G__cpp_setup_global0();
16770 G__cpp_setup_global1();
16771 G__cpp_setup_global2();
16772 G__cpp_setup_global3();
16773 G__cpp_setup_global4();
16774 G__cpp_setup_global5();
16775 G__cpp_setup_global6();
16776 G__cpp_setup_global7();
16777 G__cpp_setup_global8();
16778 }
16779
16780
16781
16782
16783 static void G__cpp_setup_func0() {
16784 G__lastifuncposition();
16785
16786 }
16787
16788 static void G__cpp_setup_func1() {
16789 }
16790
16791 static void G__cpp_setup_func2() {
16792 }
16793
16794 static void G__cpp_setup_func3() {
16795 }
16796
16797 static void G__cpp_setup_func4() {
16798 }
16799
16800 static void G__cpp_setup_func5() {
16801 }
16802
16803 static void G__cpp_setup_func6() {
16804 }
16805
16806 static void G__cpp_setup_func7() {
16807 }
16808
16809 static void G__cpp_setup_func8() {
16810 }
16811
16812 static void G__cpp_setup_func9() {
16813 }
16814
16815 static void G__cpp_setup_func10() {
16816 }
16817
16818 static void G__cpp_setup_func11() {
16819 }
16820
16821 static void G__cpp_setup_func12() {
16822 }
16823
16824 static void G__cpp_setup_func13() {
16825 }
16826
16827 static void G__cpp_setup_func14() {
16828 }
16829
16830 static void G__cpp_setup_func15() {
16831 }
16832
16833 static void G__cpp_setup_func16() {
16834 }
16835
16836 static void G__cpp_setup_func17() {
16837 }
16838
16839 static void G__cpp_setup_func18() {
16840 }
16841
16842 static void G__cpp_setup_func19() {
16843 }
16844
16845 static void G__cpp_setup_func20() {
16846 }
16847
16848 static void G__cpp_setup_func21() {
16849 }
16850
16851 static void G__cpp_setup_func22() {
16852 }
16853
16854 static void G__cpp_setup_func23() {
16855 }
16856
16857 static void G__cpp_setup_func24() {
16858
16859 G__resetifuncposition();
16860 }
16861
16862 extern "C" void G__cpp_setup_funcBesVisLib_rootcint() {
16863 G__cpp_setup_func0();
16864 G__cpp_setup_func1();
16865 G__cpp_setup_func2();
16866 G__cpp_setup_func3();
16867 G__cpp_setup_func4();
16868 G__cpp_setup_func5();
16869 G__cpp_setup_func6();
16870 G__cpp_setup_func7();
16871 G__cpp_setup_func8();
16872 G__cpp_setup_func9();
16873 G__cpp_setup_func10();
16874 G__cpp_setup_func11();
16875 G__cpp_setup_func12();
16876 G__cpp_setup_func13();
16877 G__cpp_setup_func14();
16878 G__cpp_setup_func15();
16879 G__cpp_setup_func16();
16880 G__cpp_setup_func17();
16881 G__cpp_setup_func18();
16882 G__cpp_setup_func19();
16883 G__cpp_setup_func20();
16884 G__cpp_setup_func21();
16885 G__cpp_setup_func22();
16886 G__cpp_setup_func23();
16887 G__cpp_setup_func24();
16888 }
16889
16890
16891
16892
16893
16894 G__linked_taginfo G__BesVisLib_rootcintLN_TClass = { "TClass" , 99 , -1 };
16895 G__linked_taginfo G__BesVisLib_rootcintLN_TBuffer = { "TBuffer" , 99 , -1 };
16896 G__linked_taginfo G__BesVisLib_rootcintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
16897 G__linked_taginfo G__BesVisLib_rootcintLN_TObject = { "TObject" , 99 , -1 };
16898 G__linked_taginfo G__BesVisLib_rootcintLN_TNamed = { "TNamed" , 99 , -1 };
16899 G__linked_taginfo G__BesVisLib_rootcintLN_TString = { "TString" , 99 , -1 };
16900 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
16901 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
16902 G__linked_taginfo G__BesVisLib_rootcintLN_string = { "string" , 99 , -1 };
16903 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
16904 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
16905 G__linked_taginfo G__BesVisLib_rootcintLN_TList = { "TList" , 99 , -1 };
16906 G__linked_taginfo G__BesVisLib_rootcintLN_TObjArray = { "TObjArray" , 99 , -1 };
16907 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
16908 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
16909 G__linked_taginfo G__BesVisLib_rootcintLN_EBESViewType = { "EBESViewType" , 101 , -1 };
16910 G__linked_taginfo G__BesVisLib_rootcintLN_BesStatus = { "BesStatus" , 99 , -1 };
16911 G__linked_taginfo G__BesVisLib_rootcintLN_TAttLine = { "TAttLine" , 99 , -1 };
16912 G__linked_taginfo G__BesVisLib_rootcintLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
16913 G__linked_taginfo G__BesVisLib_rootcintLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
16914 G__linked_taginfo G__BesVisLib_rootcintLN_TView = { "TView" , 99 , -1 };
16915 G__linked_taginfo G__BesVisLib_rootcintLN_BesTView = { "BesTView" , 99 , -1 };
16916 G__linked_taginfo G__BesVisLib_rootcintLN_BesTViewcLcLdA = { "BesTView::$" , 101 , -1 };
16917 G__linked_taginfo G__BesVisLib_rootcintLN_TPaveLabel = { "TPaveLabel" , 99 , -1 };
16918 G__linked_taginfo G__BesVisLib_rootcintLN_TPad = { "TPad" , 99 , -1 };
16919 G__linked_taginfo G__BesVisLib_rootcintLN_TCanvas = { "TCanvas" , 99 , -1 };
16920 G__linked_taginfo G__BesVisLib_rootcintLN_Bes2DView = { "Bes2DView" , 99 , -1 };
16921 G__linked_taginfo G__BesVisLib_rootcintLN_TAttFill = { "TAttFill" , 99 , -1 };
16922 G__linked_taginfo G__BesVisLib_rootcintLN_BesCircle2D = { "BesCircle2D" , 99 , -1 };
16923 G__linked_taginfo G__BesVisLib_rootcintLN_EBESCursorType = { "EBESCursorType" , 101 , -1 };
16924 G__linked_taginfo G__BesVisLib_rootcintLN_BesCursor = { "BesCursor" , 99 , -1 };
16925 G__linked_taginfo G__BesVisLib_rootcintLN_BesEventHeader = { "BesEventHeader" , 99 , -1 };
16926 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
16927 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
16928 G__linked_taginfo G__BesVisLib_rootcintLN_TBox = { "TBox" , 99 , -1 };
16929 G__linked_taginfo G__BesVisLib_rootcintLN_TPave = { "TPave" , 99 , -1 };
16930 G__linked_taginfo G__BesVisLib_rootcintLN_TAttText = { "TAttText" , 99 , -1 };
16931 G__linked_taginfo G__BesVisLib_rootcintLN_TPaveText = { "TPaveText" , 99 , -1 };
16932 G__linked_taginfo G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
16933 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoAtt = { "TGeoAtt" , 99 , -1 };
16934 G__linked_taginfo G__BesVisLib_rootcintLN_TAttMarker = { "TAttMarker" , 99 , -1 };
16935 G__linked_taginfo G__BesVisLib_rootcintLN_TVirtualGeoTrack = { "TVirtualGeoTrack" , 99 , -1 };
16936 G__linked_taginfo G__BesVisLib_rootcintLN_TAtt3D = { "TAtt3D" , 99 , -1 };
16937 G__linked_taginfo G__BesVisLib_rootcintLN_TPolyLine3D = { "TPolyLine3D" , 99 , -1 };
16938 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoTrack = { "TGeoTrack" , 99 , -1 };
16939 G__linked_taginfo G__BesVisLib_rootcintLN_TMarker = { "TMarker" , 99 , -1 };
16940 G__linked_taginfo G__BesVisLib_rootcintLN_BesView = { "BesView" , 99 , -1 };
16941 G__linked_taginfo G__BesVisLib_rootcintLN_BesMarker2D = { "BesMarker2D" , 99 , -1 };
16942 G__linked_taginfo G__BesVisLib_rootcintLN_BesPaveText = { "BesPaveText" , 99 , -1 };
16943 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
16944 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
16945 G__linked_taginfo G__BesVisLib_rootcintLN_BesGeoTrack = { "BesGeoTrack" , 99 , -1 };
16946 G__linked_taginfo G__BesVisLib_rootcintLN_TMdcDigi = { "TMdcDigi" , 99 , -1 };
16947 G__linked_taginfo G__BesVisLib_rootcintLN_TEmcDigi = { "TEmcDigi" , 99 , -1 };
16948 G__linked_taginfo G__BesVisLib_rootcintLN_TTofDigi = { "TTofDigi" , 99 , -1 };
16949 G__linked_taginfo G__BesVisLib_rootcintLN_TMucDigi = { "TMucDigi" , 99 , -1 };
16950 G__linked_taginfo G__BesVisLib_rootcintLN_TDigiEvent = { "TDigiEvent" , 99 , -1 };
16951 G__linked_taginfo G__BesVisLib_rootcintLN_TRecMdcTrack = { "TRecMdcTrack" , 99 , -1 };
16952 G__linked_taginfo G__BesVisLib_rootcintLN_TRecTofTrack = { "TRecTofTrack" , 99 , -1 };
16953 G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR = { "map<int,int,less<int>,allocator<pair<const int,int> > >" , 99 , -1 };
16954 G__linked_taginfo G__BesVisLib_rootcintLN_TRecEmcShower = { "TRecEmcShower" , 99 , -1 };
16955 G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
16956 G__linked_taginfo G__BesVisLib_rootcintLN_TRecMucTrack = { "TRecMucTrack" , 99 , -1 };
16957 G__linked_taginfo G__BesVisLib_rootcintLN_TRecMdcDedx = { "TRecMdcDedx" , 99 , -1 };
16958 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
16959 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
16960 G__linked_taginfo G__BesVisLib_rootcintLN_TRecEvTime = { "TRecEvTime" , 99 , -1 };
16961 G__linked_taginfo G__BesVisLib_rootcintLN_pairlEintcOfloatgR = { "pair<int,float>" , 115 , -1 };
16962 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR = { "vector<pair<int,float>,allocator<pair<int,float> > >" , 99 , -1 };
16963 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,float>,allocator<pair<int,float> > >::iterator>" , 99 , -1 };
16964 G__linked_taginfo G__BesVisLib_rootcintLN_TEvtHeader = { "TEvtHeader" , 99 , -1 };
16965 G__linked_taginfo G__BesVisLib_rootcintLN_TDisTrack = { "TDisTrack" , 99 , -1 };
16966 G__linked_taginfo G__BesVisLib_rootcintLN_TTrigEvent = { "TTrigEvent" , 99 , -1 };
16967 G__linked_taginfo G__BesVisLib_rootcintLN_BesEvent = { "BesEvent" , 99 , -1 };
16968 G__linked_taginfo G__BesVisLib_rootcintLN_Event_t = { "Event_t" , 115 , -1 };
16969 G__linked_taginfo G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR = { "pair<unsigned int,int>" , 115 , -1 };
16970 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR = { "vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >" , 99 , -1 };
16971 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >::iterator>" , 99 , -1 };
16972 G__linked_taginfo G__BesVisLib_rootcintLN_TQObject = { "TQObject" , 99 , -1 };
16973 G__linked_taginfo G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR = { "map<int,TGeoElementRN*,less<int>,allocator<pair<const int,TGeoElementRN*> > >" , 99 , -1 };
16974 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
16975 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
16976 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoShape = { "TGeoShape" , 99 , -1 };
16977 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoNode = { "TGeoNode" , 99 , -1 };
16978 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoVolumeAssembly = { "TGeoVolumeAssembly" , 99 , -1 };
16979 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR = { "vector<TGeoVolumeAssembly::ThreadData_t*,allocator<TGeoVolumeAssembly::ThreadData_t*> >" , 99 , -1 };
16980 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGeoVolumeAssembly::ThreadData_t*,allocator<TGeoVolumeAssembly::ThreadData_t*> >::iterator>" , 99 , -1 };
16981 G__linked_taginfo G__BesVisLib_rootcintLN_TGeoPhysicalNode = { "TGeoPhysicalNode" , 99 , -1 };
16982 G__linked_taginfo G__BesVisLib_rootcintLN_ProcessingConfigurator = { "ProcessingConfigurator" , 99 , -1 };
16983 G__linked_taginfo G__BesVisLib_rootcintLN_SAXProcessor = { "SAXProcessor" , 99 , -1 };
16984 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR = { "vector<ContentGroup::ContentItem,allocator<ContentGroup::ContentItem> >" , 99 , -1 };
16985 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ContentGroup::ContentItem,allocator<ContentGroup::ContentItem> >::iterator>" , 99 , -1 };
16986 G__linked_taginfo G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR = { "vector<ContentChoice*,allocator<ContentChoice*> >" , 99 , -1 };
16987 G__linked_taginfo G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ContentChoice*,allocator<ContentChoice*> >::iterator>" , 99 , -1 };
16988 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR = { "map<string,define::constant,less<string>,allocator<pair<const string,define::constant> > >" , 99 , -1 };
16989 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR = { "map<string,define::quantity,less<string>,allocator<pair<const string,define::quantity> > >" , 99 , -1 };
16990 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR = { "map<string,define::expression,less<string>,allocator<pair<const string,define::expression> > >" , 99 , -1 };
16991 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR = { "map<string,define::position,less<string>,allocator<pair<const string,define::position> > >" , 99 , -1 };
16992 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR = { "map<string,define::rotation,less<string>,allocator<pair<const string,define::rotation> > >" , 99 , -1 };
16993 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR = { "map<string,TGeoTranslation*,less<string>,allocator<pair<const string,TGeoTranslation*> > >" , 99 , -1 };
16994 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR = { "map<string,TGeoRotation*,less<string>,allocator<pair<const string,TGeoRotation*> > >" , 99 , -1 };
16995 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR = { "map<string,TGeoShape*,less<string>,allocator<pair<const string,TGeoShape*> > >" , 99 , -1 };
16996 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR = { "map<string,TGeoVolume*,less<string>,allocator<pair<const string,TGeoVolume*> > >" , 99 , -1 };
16997 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR = { "map<string,TGeoVolumeAssembly*,less<string>,allocator<pair<const string,TGeoVolumeAssembly*> > >" , 99 , -1 };
16998 G__linked_taginfo G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR = { "map<string,TGeoNode*,less<string>,allocator<pair<const string,TGeoNode*> > >" , 99 , -1 };
16999 G__linked_taginfo G__BesVisLib_rootcintLN_SubDetectorROOTGeo = { "SubDetectorROOTGeo" , 99 , -1 };
17000 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
17001 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
17002 G__linked_taginfo G__BesVisLib_rootcintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
17003 G__linked_taginfo G__BesVisLib_rootcintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
17004 G__linked_taginfo G__BesVisLib_rootcintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
17005 G__linked_taginfo G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
17006 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
17007 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
17008 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
17009 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
17010 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
17011 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
17012 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
17013 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
17014 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
17015 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
17016 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
17017 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
17018 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
17019 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
17020 G__linked_taginfo G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
17021 G__linked_taginfo G__BesVisLib_rootcintLN_BesPolygon2D = { "BesPolygon2D" , 99 , -1 };
17022 G__linked_taginfo G__BesVisLib_rootcintLN_Mdc2DWire = { "Mdc2DWire" , 99 , -1 };
17023 G__linked_taginfo G__BesVisLib_rootcintLN_MdcROOTGeo = { "MdcROOTGeo" , 99 , -1 };
17024 G__linked_taginfo G__BesVisLib_rootcintLN_Tof2DScin = { "Tof2DScin" , 99 , -1 };
17025 G__linked_taginfo G__BesVisLib_rootcintLN_TofROOTGeo = { "TofROOTGeo" , 99 , -1 };
17026 G__linked_taginfo G__BesVisLib_rootcintLN_Emc2DCrystal = { "Emc2DCrystal" , 99 , -1 };
17027 G__linked_taginfo G__BesVisLib_rootcintLN_EmcROOTGeo = { "EmcROOTGeo" , 99 , -1 };
17028 G__linked_taginfo G__BesVisLib_rootcintLN_Muc2DStrip = { "Muc2DStrip" , 99 , -1 };
17029 G__linked_taginfo G__BesVisLib_rootcintLN_MucROOTGeo = { "MucROOTGeo" , 99 , -1 };
17030 G__linked_taginfo G__BesVisLib_rootcintLN_BesGeometry = { "BesGeometry" , 99 , -1 };
17031 G__linked_taginfo G__BesVisLib_rootcintLN_TGObject = { "TGObject" , 99 , -1 };
17032 G__linked_taginfo G__BesVisLib_rootcintLN_TGWindow = { "TGWindow" , 99 , -1 };
17033 G__linked_taginfo G__BesVisLib_rootcintLN_TGPicture = { "TGPicture" , 99 , -1 };
17034 G__linked_taginfo G__BesVisLib_rootcintLN_TGFrame = { "TGFrame" , 99 , -1 };
17035 G__linked_taginfo G__BesVisLib_rootcintLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
17036 G__linked_taginfo G__BesVisLib_rootcintLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
17037 G__linked_taginfo G__BesVisLib_rootcintLN_TGHotString = { "TGHotString" , 99 , -1 };
17038 G__linked_taginfo G__BesVisLib_rootcintLN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
17039 G__linked_taginfo G__BesVisLib_rootcintLN_TGWidget = { "TGWidget" , 99 , -1 };
17040 G__linked_taginfo G__BesVisLib_rootcintLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
17041 G__linked_taginfo G__BesVisLib_rootcintLN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
17042 G__linked_taginfo G__BesVisLib_rootcintLN_TGMenuTitle = { "TGMenuTitle" , 99 , -1 };
17043 G__linked_taginfo G__BesVisLib_rootcintLN_BesGMenuTitle = { "BesGMenuTitle" , 99 , -1 };
17044 G__linked_taginfo G__BesVisLib_rootcintLN_BesGMenuBar = { "BesGMenuBar" , 99 , -1 };
17045 G__linked_taginfo G__BesVisLib_rootcintLN_TGButton = { "TGButton" , 99 , -1 };
17046 G__linked_taginfo G__BesVisLib_rootcintLN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
17047 G__linked_taginfo G__BesVisLib_rootcintLN_BesGPictureButton = { "BesGPictureButton" , 99 , -1 };
17048 G__linked_taginfo G__BesVisLib_rootcintLN_BesHeader = { "BesHeader" , 99 , -1 };
17049 G__linked_taginfo G__BesVisLib_rootcintLN_TArc = { "TArc" , 99 , -1 };
17050 G__linked_taginfo G__BesVisLib_rootcintLN_TImage = { "TImage" , 99 , -1 };
17051 G__linked_taginfo G__BesVisLib_rootcintLN_BesVisDisplay = { "BesVisDisplay" , 99 , -1 };
17052 G__linked_taginfo G__BesVisLib_rootcintLN_EZHelixRangeType = { "EZHelixRangeType" , 101 , -1 };
17053 G__linked_taginfo G__BesVisLib_rootcintLN_TrackType = { "TrackType" , 101 , -1 };
17054 G__linked_taginfo G__BesVisLib_rootcintLN_ZHelix = { "ZHelix" , 99 , -1 };
17055 G__linked_taginfo G__BesVisLib_rootcintLN_vector3 = { "vector3" , 115 , -1 };
17056
17057
17058 extern "C" void G__cpp_reset_tagtableBesVisLib_rootcint() {
17059 G__BesVisLib_rootcintLN_TClass.tagnum = -1 ;
17060 G__BesVisLib_rootcintLN_TBuffer.tagnum = -1 ;
17061 G__BesVisLib_rootcintLN_TMemberInspector.tagnum = -1 ;
17062 G__BesVisLib_rootcintLN_TObject.tagnum = -1 ;
17063 G__BesVisLib_rootcintLN_TNamed.tagnum = -1 ;
17064 G__BesVisLib_rootcintLN_TString.tagnum = -1 ;
17065 G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
17066 G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
17067 G__BesVisLib_rootcintLN_string.tagnum = -1 ;
17068 G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
17069 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
17070 G__BesVisLib_rootcintLN_TList.tagnum = -1 ;
17071 G__BesVisLib_rootcintLN_TObjArray.tagnum = -1 ;
17072 G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
17073 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17074 G__BesVisLib_rootcintLN_EBESViewType.tagnum = -1 ;
17075 G__BesVisLib_rootcintLN_BesStatus.tagnum = -1 ;
17076 G__BesVisLib_rootcintLN_TAttLine.tagnum = -1 ;
17077 G__BesVisLib_rootcintLN_TSeqCollection.tagnum = -1 ;
17078 G__BesVisLib_rootcintLN_TVirtualPad.tagnum = -1 ;
17079 G__BesVisLib_rootcintLN_TView.tagnum = -1 ;
17080 G__BesVisLib_rootcintLN_BesTView.tagnum = -1 ;
17081 G__BesVisLib_rootcintLN_BesTViewcLcLdA.tagnum = -1 ;
17082 G__BesVisLib_rootcintLN_TPaveLabel.tagnum = -1 ;
17083 G__BesVisLib_rootcintLN_TPad.tagnum = -1 ;
17084 G__BesVisLib_rootcintLN_TCanvas.tagnum = -1 ;
17085 G__BesVisLib_rootcintLN_Bes2DView.tagnum = -1 ;
17086 G__BesVisLib_rootcintLN_TAttFill.tagnum = -1 ;
17087 G__BesVisLib_rootcintLN_BesCircle2D.tagnum = -1 ;
17088 G__BesVisLib_rootcintLN_EBESCursorType.tagnum = -1 ;
17089 G__BesVisLib_rootcintLN_BesCursor.tagnum = -1 ;
17090 G__BesVisLib_rootcintLN_BesEventHeader.tagnum = -1 ;
17091 G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
17092 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
17093 G__BesVisLib_rootcintLN_TBox.tagnum = -1 ;
17094 G__BesVisLib_rootcintLN_TPave.tagnum = -1 ;
17095 G__BesVisLib_rootcintLN_TAttText.tagnum = -1 ;
17096 G__BesVisLib_rootcintLN_TPaveText.tagnum = -1 ;
17097 G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
17098 G__BesVisLib_rootcintLN_TGeoAtt.tagnum = -1 ;
17099 G__BesVisLib_rootcintLN_TAttMarker.tagnum = -1 ;
17100 G__BesVisLib_rootcintLN_TVirtualGeoTrack.tagnum = -1 ;
17101 G__BesVisLib_rootcintLN_TAtt3D.tagnum = -1 ;
17102 G__BesVisLib_rootcintLN_TPolyLine3D.tagnum = -1 ;
17103 G__BesVisLib_rootcintLN_TGeoTrack.tagnum = -1 ;
17104 G__BesVisLib_rootcintLN_TMarker.tagnum = -1 ;
17105 G__BesVisLib_rootcintLN_BesView.tagnum = -1 ;
17106 G__BesVisLib_rootcintLN_BesMarker2D.tagnum = -1 ;
17107 G__BesVisLib_rootcintLN_BesPaveText.tagnum = -1 ;
17108 G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
17109 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
17110 G__BesVisLib_rootcintLN_BesGeoTrack.tagnum = -1 ;
17111 G__BesVisLib_rootcintLN_TMdcDigi.tagnum = -1 ;
17112 G__BesVisLib_rootcintLN_TEmcDigi.tagnum = -1 ;
17113 G__BesVisLib_rootcintLN_TTofDigi.tagnum = -1 ;
17114 G__BesVisLib_rootcintLN_TMucDigi.tagnum = -1 ;
17115 G__BesVisLib_rootcintLN_TDigiEvent.tagnum = -1 ;
17116 G__BesVisLib_rootcintLN_TRecMdcTrack.tagnum = -1 ;
17117 G__BesVisLib_rootcintLN_TRecTofTrack.tagnum = -1 ;
17118 G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR.tagnum = -1 ;
17119 G__BesVisLib_rootcintLN_TRecEmcShower.tagnum = -1 ;
17120 G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
17121 G__BesVisLib_rootcintLN_TRecMucTrack.tagnum = -1 ;
17122 G__BesVisLib_rootcintLN_TRecMdcDedx.tagnum = -1 ;
17123 G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
17124 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17125 G__BesVisLib_rootcintLN_TRecEvTime.tagnum = -1 ;
17126 G__BesVisLib_rootcintLN_pairlEintcOfloatgR.tagnum = -1 ;
17127 G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR.tagnum = -1 ;
17128 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17129 G__BesVisLib_rootcintLN_TEvtHeader.tagnum = -1 ;
17130 G__BesVisLib_rootcintLN_TDisTrack.tagnum = -1 ;
17131 G__BesVisLib_rootcintLN_TTrigEvent.tagnum = -1 ;
17132 G__BesVisLib_rootcintLN_BesEvent.tagnum = -1 ;
17133 G__BesVisLib_rootcintLN_Event_t.tagnum = -1 ;
17134 G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR.tagnum = -1 ;
17135 G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR.tagnum = -1 ;
17136 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17137 G__BesVisLib_rootcintLN_TQObject.tagnum = -1 ;
17138 G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR.tagnum = -1 ;
17139 G__BesVisLib_rootcintLN_TGeoMatrix.tagnum = -1 ;
17140 G__BesVisLib_rootcintLN_TGeoVolume.tagnum = -1 ;
17141 G__BesVisLib_rootcintLN_TGeoShape.tagnum = -1 ;
17142 G__BesVisLib_rootcintLN_TGeoNode.tagnum = -1 ;
17143 G__BesVisLib_rootcintLN_TGeoVolumeAssembly.tagnum = -1 ;
17144 G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR.tagnum = -1 ;
17145 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17146 G__BesVisLib_rootcintLN_TGeoPhysicalNode.tagnum = -1 ;
17147 G__BesVisLib_rootcintLN_ProcessingConfigurator.tagnum = -1 ;
17148 G__BesVisLib_rootcintLN_SAXProcessor.tagnum = -1 ;
17149 G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR.tagnum = -1 ;
17150 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR.tagnum = -1 ;
17151 G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR.tagnum = -1 ;
17152 G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17153 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR.tagnum = -1 ;
17154 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR.tagnum = -1 ;
17155 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR.tagnum = -1 ;
17156 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR.tagnum = -1 ;
17157 G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR.tagnum = -1 ;
17158 G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR.tagnum = -1 ;
17159 G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR.tagnum = -1 ;
17160 G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR.tagnum = -1 ;
17161 G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR.tagnum = -1 ;
17162 G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR.tagnum = -1 ;
17163 G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR.tagnum = -1 ;
17164 G__BesVisLib_rootcintLN_SubDetectorROOTGeo.tagnum = -1 ;
17165 G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
17166 G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
17167 G__BesVisLib_rootcintLN_TVectorTlEfloatgR.tagnum = -1 ;
17168 G__BesVisLib_rootcintLN_TVectorTlEdoublegR.tagnum = -1 ;
17169 G__BesVisLib_rootcintLN_TElementActionTlEfloatgR.tagnum = -1 ;
17170 G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
17171 G__BesVisLib_rootcintLN_TMatrixTlEfloatgR.tagnum = -1 ;
17172 G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
17173 G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
17174 G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
17175 G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
17176 G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
17177 G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
17178 G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
17179 G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
17180 G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
17181 G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
17182 G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
17183 G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
17184 G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
17185 G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
17186 G__BesVisLib_rootcintLN_BesPolygon2D.tagnum = -1 ;
17187 G__BesVisLib_rootcintLN_Mdc2DWire.tagnum = -1 ;
17188 G__BesVisLib_rootcintLN_MdcROOTGeo.tagnum = -1 ;
17189 G__BesVisLib_rootcintLN_Tof2DScin.tagnum = -1 ;
17190 G__BesVisLib_rootcintLN_TofROOTGeo.tagnum = -1 ;
17191 G__BesVisLib_rootcintLN_Emc2DCrystal.tagnum = -1 ;
17192 G__BesVisLib_rootcintLN_EmcROOTGeo.tagnum = -1 ;
17193 G__BesVisLib_rootcintLN_Muc2DStrip.tagnum = -1 ;
17194 G__BesVisLib_rootcintLN_MucROOTGeo.tagnum = -1 ;
17195 G__BesVisLib_rootcintLN_BesGeometry.tagnum = -1 ;
17196 G__BesVisLib_rootcintLN_TGObject.tagnum = -1 ;
17197 G__BesVisLib_rootcintLN_TGWindow.tagnum = -1 ;
17198 G__BesVisLib_rootcintLN_TGPicture.tagnum = -1 ;
17199 G__BesVisLib_rootcintLN_TGFrame.tagnum = -1 ;
17200 G__BesVisLib_rootcintLN_TGCompositeFrame.tagnum = -1 ;
17201 G__BesVisLib_rootcintLN_TGLayoutHints.tagnum = -1 ;
17202 G__BesVisLib_rootcintLN_TGHotString.tagnum = -1 ;
17203 G__BesVisLib_rootcintLN_TGHorizontalFrame.tagnum = -1 ;
17204 G__BesVisLib_rootcintLN_TGWidget.tagnum = -1 ;
17205 G__BesVisLib_rootcintLN_TGPopupMenu.tagnum = -1 ;
17206 G__BesVisLib_rootcintLN_TGMenuBar.tagnum = -1 ;
17207 G__BesVisLib_rootcintLN_TGMenuTitle.tagnum = -1 ;
17208 G__BesVisLib_rootcintLN_BesGMenuTitle.tagnum = -1 ;
17209 G__BesVisLib_rootcintLN_BesGMenuBar.tagnum = -1 ;
17210 G__BesVisLib_rootcintLN_TGButton.tagnum = -1 ;
17211 G__BesVisLib_rootcintLN_TGPictureButton.tagnum = -1 ;
17212 G__BesVisLib_rootcintLN_BesGPictureButton.tagnum = -1 ;
17213 G__BesVisLib_rootcintLN_BesHeader.tagnum = -1 ;
17214 G__BesVisLib_rootcintLN_TArc.tagnum = -1 ;
17215 G__BesVisLib_rootcintLN_TImage.tagnum = -1 ;
17216 G__BesVisLib_rootcintLN_BesVisDisplay.tagnum = -1 ;
17217 G__BesVisLib_rootcintLN_EZHelixRangeType.tagnum = -1 ;
17218 G__BesVisLib_rootcintLN_TrackType.tagnum = -1 ;
17219 G__BesVisLib_rootcintLN_ZHelix.tagnum = -1 ;
17220 G__BesVisLib_rootcintLN_vector3.tagnum = -1 ;
17221 }
17222
17223
17224 extern "C" void G__cpp_setup_tagtableBesVisLib_rootcint() {
17225
17226
17227 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TClass);
17228 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TBuffer);
17229 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMemberInspector);
17230 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TObject);
17231 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TNamed);
17232 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TString);
17233 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
17234 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
17235 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_string);
17236 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
17237 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
17238 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TList);
17239 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TObjArray);
17240 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
17241 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
17242 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EBESViewType);
17243 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesStatus),sizeof(BesStatus),-1,292096,"Bes View Status",G__setup_memvarBesStatus,G__setup_memfuncBesStatus);
17244 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttLine);
17245 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TSeqCollection);
17246 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVirtualPad);
17247 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TView);
17248 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesTView),sizeof(BesTView),-1,130816,"3-D View",G__setup_memvarBesTView,G__setup_memfuncBesTView);
17249 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesTViewcLcLdA);
17250 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPaveLabel);
17251 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPad);
17252 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TCanvas);
17253 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Bes2DView),sizeof(Bes2DView),-1,324864,"Bes View",G__setup_memvarBes2DView,G__setup_memfuncBes2DView);
17254 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttFill);
17255 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesCircle2D),sizeof(BesCircle2D),-1,324864,"Circle in 2D",G__setup_memvarBesCircle2D,G__setup_memfuncBesCircle2D);
17256 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EBESCursorType);
17257 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesCursor),sizeof(BesCursor),-1,292096,"BesCursor",G__setup_memvarBesCursor,G__setup_memfuncBesCursor);
17258 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesEventHeader),sizeof(BesEventHeader),-1,292096,"Bes Event Header",G__setup_memvarBesEventHeader,G__setup_memfuncBesEventHeader);
17259 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEintcOallocatorlEintgRsPgR);
17260 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
17261 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TBox);
17262 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPave);
17263 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttText);
17264 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPaveText);
17265 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
17266 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoAtt);
17267 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAttMarker);
17268 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVirtualGeoTrack);
17269 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TAtt3D);
17270 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TPolyLine3D);
17271 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoTrack);
17272 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMarker);
17273 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesView),sizeof(BesView),-1,324864,"BesVis View",G__setup_memvarBesView,G__setup_memfuncBesView);
17274 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesMarker2D),sizeof(BesMarker2D),-1,324864,"Bes 2D marker",G__setup_memvarBesMarker2D,G__setup_memfuncBesMarker2D);
17275 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesPaveText),sizeof(BesPaveText),-1,324352,"BesPaveText",G__setup_memvarBesPaveText,G__setup_memfuncBesPaveText);
17276 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR);
17277 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
17278 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGeoTrack),sizeof(BesGeoTrack),-1,324864,"BesGeoTrack",G__setup_memvarBesGeoTrack,G__setup_memfuncBesGeoTrack);
17279 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMdcDigi);
17280 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TEmcDigi);
17281 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TTofDigi);
17282 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMucDigi);
17283 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TDigiEvent);
17284 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecMdcTrack);
17285 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecTofTrack);
17286 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR);
17287 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecEmcShower);
17288 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
17289 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecMucTrack);
17290 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecMdcDedx);
17291 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
17292 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
17293 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TRecEvTime);
17294 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_pairlEintcOfloatgR);
17295 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR);
17296 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR);
17297 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TEvtHeader);
17298 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TDisTrack);
17299 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TTrigEvent);
17300 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesEvent),sizeof(BesEvent),-1,292096,"BesVis Event",G__setup_memvarBesEvent,G__setup_memfuncBesEvent);
17301 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Event_t);
17302 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_pairlEunsignedsPintcOintgR);
17303 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR);
17304 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR);
17305 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TQObject);
17306 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR);
17307 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoMatrix);
17308 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoVolume);
17309 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoShape);
17310 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoNode);
17311 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoVolumeAssembly);
17312 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR);
17313 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR);
17314 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGeoPhysicalNode);
17315 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_ProcessingConfigurator);
17316 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_SAXProcessor);
17317 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgR);
17318 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentGroupcLcLContentItemcOallocatorlEContentGroupcLcLContentItemgRsPgRcLcLiteratorgR);
17319 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgR);
17320 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_reverse_iteratorlEvectorlEContentChoicemUcOallocatorlEContentChoicemUgRsPgRcLcLiteratorgR);
17321 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLconstantcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLconstantgRsPgRsPgR);
17322 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLquantitycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLquantitygRsPgRsPgR);
17323 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLexpressioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLexpressiongRsPgRsPgR);
17324 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLpositioncOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLpositiongRsPgRsPgR);
17325 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOdefinecLcLrotationcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdefinecLcLrotationgRsPgRsPgR);
17326 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoTranslationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoTranslationmUgRsPgRsPgR);
17327 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoRotationmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoRotationmUgRsPgRsPgR);
17328 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoShapemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoShapemUgRsPgRsPgR);
17329 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumemUgRsPgRsPgR);
17330 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoVolumeAssemblymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoVolumeAssemblymUgRsPgRsPgR);
17331 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_maplEstringcOTGeoNodemUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTGeoNodemUgRsPgRsPgR);
17332 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_SubDetectorROOTGeo),sizeof(SubDetectorROOTGeo),-1,263424,(char*)NULL,G__setup_memvarSubDetectorROOTGeo,G__setup_memfuncSubDetectorROOTGeo);
17333 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTBaselEfloatgR);
17334 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTBaselEdoublegR);
17335 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVectorTlEfloatgR);
17336 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TVectorTlEdoublegR);
17337 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TElementActionTlEfloatgR);
17338 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TElementPosActionTlEfloatgR);
17339 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTlEfloatgR);
17340 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTRow_constlEfloatgR);
17341 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTRowlEfloatgR);
17342 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTDiag_constlEfloatgR);
17343 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTColumn_constlEfloatgR);
17344 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTFlat_constlEfloatgR);
17345 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSub_constlEfloatgR);
17346 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseRow_constlEfloatgR);
17347 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseDiag_constlEfloatgR);
17348 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTColumnlEfloatgR);
17349 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTDiaglEfloatgR);
17350 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTFlatlEfloatgR);
17351 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSublEfloatgR);
17352 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseRowlEfloatgR);
17353 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TMatrixTSparseDiaglEfloatgR);
17354 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesPolygon2D),sizeof(BesPolygon2D),-1,324864,"Polygon in 2D",G__setup_memvarBesPolygon2D,G__setup_memfuncBesPolygon2D);
17355 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Mdc2DWire),sizeof(Mdc2DWire),-1,324864,"Mdc 2D Wire",G__setup_memvarMdc2DWire,G__setup_memfuncMdc2DWire);
17356 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_MdcROOTGeo),sizeof(MdcROOTGeo),-1,263424,(char*)NULL,G__setup_memvarMdcROOTGeo,G__setup_memfuncMdcROOTGeo);
17357 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Tof2DScin),sizeof(Tof2DScin),-1,324864,"Tof 2D Scin",G__setup_memvarTof2DScin,G__setup_memfuncTof2DScin);
17358 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TofROOTGeo),sizeof(TofROOTGeo),-1,263424,(char*)NULL,G__setup_memvarTofROOTGeo,G__setup_memfuncTofROOTGeo);
17359 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Emc2DCrystal),sizeof(Emc2DCrystal),-1,324864,"Emc 2D Crystal",G__setup_memvarEmc2DCrystal,G__setup_memfuncEmc2DCrystal);
17360 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EmcROOTGeo),sizeof(EmcROOTGeo),-1,263424,(char*)NULL,G__setup_memvarEmcROOTGeo,G__setup_memfuncEmcROOTGeo);
17361 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_Muc2DStrip),sizeof(Muc2DStrip),-1,324864,"Muc 2D Strip",G__setup_memvarMuc2DStrip,G__setup_memfuncMuc2DStrip);
17362 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_MucROOTGeo),sizeof(MucROOTGeo),-1,263424,(char*)NULL,G__setup_memvarMucROOTGeo,G__setup_memfuncMucROOTGeo);
17363 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGeometry),sizeof(BesGeometry),-1,292096,"Bes Geometry",G__setup_memvarBesGeometry,G__setup_memfuncBesGeometry);
17364 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGObject);
17365 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGWindow);
17366 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGPicture);
17367 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGFrame);
17368 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGCompositeFrame);
17369 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGLayoutHints);
17370 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGHotString);
17371 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGHorizontalFrame);
17372 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGWidget);
17373 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGPopupMenu);
17374 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGMenuBar);
17375 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGMenuTitle);
17376 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGMenuTitle),sizeof(BesGMenuTitle),-1,323840,"Menu title class",G__setup_memvarBesGMenuTitle,G__setup_memfuncBesGMenuTitle);
17377 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGMenuBar),sizeof(BesGMenuBar),-1,323840,"Menu bar class",G__setup_memvarBesGMenuBar,G__setup_memfuncBesGMenuBar);
17378 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGButton);
17379 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TGPictureButton);
17380 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesGPictureButton),sizeof(BesGPictureButton),-1,323840,"BesGPictureButton",G__setup_memvarBesGPictureButton,G__setup_memfuncBesGPictureButton);
17381 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesHeader),sizeof(BesHeader),-1,324864,"BesVis Header",G__setup_memvarBesHeader,G__setup_memfuncBesHeader);
17382 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TArc);
17383 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TImage);
17384 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_BesVisDisplay),sizeof(BesVisDisplay),-1,296192,"Utility class to display ATLAS outline, tracks, clusters, jets,..",G__setup_memvarBesVisDisplay,G__setup_memfuncBesVisDisplay);
17385 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_EZHelixRangeType);
17386 G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_TrackType);
17387 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_ZHelix),sizeof(ZHelix),-1,324864,"ZeVis Helix",G__setup_memvarZHelix,G__setup_memfuncZHelix);
17388 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__BesVisLib_rootcintLN_vector3),sizeof(vector3),-1,262144,(char*)NULL,G__setup_memvarvector3,G__setup_memfuncvector3);
17389 }
17390 extern "C" void G__cpp_setupBesVisLib_rootcint(void) {
17391 G__check_setup_version(30051515,"G__cpp_setupBesVisLib_rootcint()");
17392 G__set_cpp_environmentBesVisLib_rootcint();
17393 G__cpp_setup_tagtableBesVisLib_rootcint();
17394
17395 G__cpp_setup_inheritanceBesVisLib_rootcint();
17396
17397 G__cpp_setup_typetableBesVisLib_rootcint();
17398
17399 G__cpp_setup_memvarBesVisLib_rootcint();
17400
17401 G__cpp_setup_memfuncBesVisLib_rootcint();
17402 G__cpp_setup_globalBesVisLib_rootcint();
17403 G__cpp_setup_funcBesVisLib_rootcint();
17404
17405 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncBesVisLib_rootcint();
17406 return;
17407 }
17408 class G__cpp_setup_initBesVisLib_rootcint {
17409 public:
17410 G__cpp_setup_initBesVisLib_rootcint() { G__add_setup_func("BesVisLib_rootcint",(G__incsetup)(&G__cpp_setupBesVisLib_rootcint)); G__call_setup_funcs(); }
17411 ~G__cpp_setup_initBesVisLib_rootcint() { G__remove_setup_func("BesVisLib_rootcint"); }
17412 };
17413 G__cpp_setup_initBesVisLib_rootcint G__cpp_setup_initializerBesVisLib_rootcint;
17414
