00001
00002
00003
00004
00005
00006 #include "RConfig.h"
00007 #if !defined(R__ACCESS_IN_SYMBOL)
00008
00009 #define private public
00010 #define protected public
00011 #endif
00012
00013 #include "../inc/BankClassesDict.h"
00014 #include "TClass.h"
00015 #include "TBuffer.h"
00016 #include "TMemberInspector.h"
00017 #include "TError.h"
00018
00019 #ifndef G__ROOT
00020 #define G__ROOT
00021 #endif
00022
00023
00024 namespace std {} using namespace std;
00025
00026 #include "RtypesImp.h"
00027
00028 namespace ROOT {
00029 namespace Shadow {
00030 }
00031 }
00032
00033 namespace ROOT {
00034 void QLIN_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00035 TClass *QLIN_IsA(const void*);
00036 void *new_QLIN(void *p = 0);
00037 void *newArray_QLIN(Long_t size);
00038 void delete_QLIN(void *p);
00039 void deleteArray_QLIN(void *p);
00040 void destruct_QLIN(void *p);
00041
00042
00043 TGenericClassInfo *GenerateInitInstance(const QLIN*)
00044 {
00045 QLIN *ptr = 0;
00046 static ROOT::TGenericClassInfo
00047 instance("QLIN", QLIN::Class_Version(), "BankClasses.h", 23,
00048 typeid(QLIN), DefineBehavior(ptr, ptr),
00049 &::QLIN::Dictionary, &QLIN_IsA, 4);
00050 instance.SetNew(&new_QLIN);
00051 instance.SetNewArray(&newArray_QLIN);
00052 instance.SetDelete(&delete_QLIN);
00053 instance.SetDeleteArray(&deleteArray_QLIN);
00054 instance.SetDestructor(&destruct_QLIN);
00055 return &instance;
00056 }
00057
00058 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QLIN*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00059 }
00060
00061 namespace ROOT {
00062 void QMTL_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00063 TClass *QMTL_IsA(const void*);
00064 void *new_QMTL(void *p = 0);
00065 void *newArray_QMTL(Long_t size);
00066 void delete_QMTL(void *p);
00067 void deleteArray_QMTL(void *p);
00068 void destruct_QMTL(void *p);
00069
00070
00071 TGenericClassInfo *GenerateInitInstance(const QMTL*)
00072 {
00073 QMTL *ptr = 0;
00074 static ROOT::TGenericClassInfo
00075 instance("QMTL", QMTL::Class_Version(), "BankClasses.h", 32,
00076 typeid(QMTL), DefineBehavior(ptr, ptr),
00077 &::QMTL::Dictionary, &QMTL_IsA, 4);
00078 instance.SetNew(&new_QMTL);
00079 instance.SetNewArray(&newArray_QMTL);
00080 instance.SetDelete(&delete_QMTL);
00081 instance.SetDeleteArray(&deleteArray_QMTL);
00082 instance.SetDestructor(&destruct_QMTL);
00083 return &instance;
00084 }
00085
00086 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QMTL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00087 }
00088
00089 namespace ROOT {
00090 void QMTS_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00091 TClass *QMTS_IsA(const void*);
00092 void *new_QMTS(void *p = 0);
00093 void *newArray_QMTS(Long_t size);
00094 void delete_QMTS(void *p);
00095 void deleteArray_QMTS(void *p);
00096 void destruct_QMTS(void *p);
00097
00098
00099 TGenericClassInfo *GenerateInitInstance(const QMTS*)
00100 {
00101 QMTS *ptr = 0;
00102 static ROOT::TGenericClassInfo
00103 instance("QMTS", QMTS::Class_Version(), "BankClasses.h", 41,
00104 typeid(QMTS), DefineBehavior(ptr, ptr),
00105 &::QMTS::Dictionary, &QMTS_IsA, 4);
00106 instance.SetNew(&new_QMTS);
00107 instance.SetNewArray(&newArray_QMTS);
00108 instance.SetDelete(&delete_QMTS);
00109 instance.SetDeleteArray(&deleteArray_QMTS);
00110 instance.SetDestructor(&destruct_QMTS);
00111 return &instance;
00112 }
00113
00114 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QMTS*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00115 }
00116
00117 namespace ROOT {
00118 void FRFT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00119 TClass *FRFT_IsA(const void*);
00120 void *new_FRFT(void *p = 0);
00121 void *newArray_FRFT(Long_t size);
00122 void delete_FRFT(void *p);
00123 void deleteArray_FRFT(void *p);
00124 void destruct_FRFT(void *p);
00125
00126
00127 TGenericClassInfo *GenerateInitInstance(const FRFT*)
00128 {
00129 FRFT *ptr = 0;
00130 static ROOT::TGenericClassInfo
00131 instance("FRFT", FRFT::Class_Version(), "BankClasses.h", 50,
00132 typeid(FRFT), DefineBehavior(ptr, ptr),
00133 &::FRFT::Dictionary, &FRFT_IsA, 4);
00134 instance.SetNew(&new_FRFT);
00135 instance.SetNewArray(&newArray_FRFT);
00136 instance.SetDelete(&delete_FRFT);
00137 instance.SetDeleteArray(&deleteArray_FRFT);
00138 instance.SetDestructor(&destruct_FRFT);
00139 return &instance;
00140 }
00141
00142 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const FRFT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00143 }
00144
00145 namespace ROOT {
00146 void FRTL_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00147 TClass *FRTL_IsA(const void*);
00148 void *new_FRTL(void *p = 0);
00149 void *newArray_FRTL(Long_t size);
00150 void delete_FRTL(void *p);
00151 void deleteArray_FRTL(void *p);
00152 void destruct_FRTL(void *p);
00153
00154
00155 TGenericClassInfo *GenerateInitInstance(const FRTL*)
00156 {
00157 FRTL *ptr = 0;
00158 static ROOT::TGenericClassInfo
00159 instance("FRTL", FRTL::Class_Version(), "BankClasses.h", 69,
00160 typeid(FRTL), DefineBehavior(ptr, ptr),
00161 &::FRTL::Dictionary, &FRTL_IsA, 4);
00162 instance.SetNew(&new_FRTL);
00163 instance.SetNewArray(&newArray_FRTL);
00164 instance.SetDelete(&delete_FRTL);
00165 instance.SetDeleteArray(&deleteArray_FRTL);
00166 instance.SetDestructor(&destruct_FRTL);
00167 return &instance;
00168 }
00169
00170 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const FRTL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00171 }
00172
00173 namespace ROOT {
00174 void TEXS_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00175 TClass *TEXS_IsA(const void*);
00176 void *new_TEXS(void *p = 0);
00177 void *newArray_TEXS(Long_t size);
00178 void delete_TEXS(void *p);
00179 void deleteArray_TEXS(void *p);
00180 void destruct_TEXS(void *p);
00181
00182
00183 TGenericClassInfo *GenerateInitInstance(const TEXS*)
00184 {
00185 TEXS *ptr = 0;
00186 static ROOT::TGenericClassInfo
00187 instance("TEXS", TEXS::Class_Version(), "BankClasses.h", 86,
00188 typeid(TEXS), DefineBehavior(ptr, ptr),
00189 &::TEXS::Dictionary, &TEXS_IsA, 4);
00190 instance.SetNew(&new_TEXS);
00191 instance.SetNewArray(&newArray_TEXS);
00192 instance.SetDelete(&delete_TEXS);
00193 instance.SetDeleteArray(&deleteArray_TEXS);
00194 instance.SetDestructor(&destruct_TEXS);
00195 return &instance;
00196 }
00197
00198 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TEXS*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00199 }
00200
00201 namespace ROOT {
00202 void HMAD_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00203 TClass *HMAD_IsA(const void*);
00204 void *new_HMAD(void *p = 0);
00205 void *newArray_HMAD(Long_t size);
00206 void delete_HMAD(void *p);
00207 void deleteArray_HMAD(void *p);
00208 void destruct_HMAD(void *p);
00209
00210
00211 TGenericClassInfo *GenerateInitInstance(const HMAD*)
00212 {
00213 HMAD *ptr = 0;
00214 static ROOT::TGenericClassInfo
00215 instance("HMAD", HMAD::Class_Version(), "BankClasses.h", 102,
00216 typeid(HMAD), DefineBehavior(ptr, ptr),
00217 &::HMAD::Dictionary, &HMAD_IsA, 4);
00218 instance.SetNew(&new_HMAD);
00219 instance.SetNewArray(&newArray_HMAD);
00220 instance.SetDelete(&delete_HMAD);
00221 instance.SetDeleteArray(&deleteArray_HMAD);
00222 instance.SetDestructor(&destruct_HMAD);
00223 return &instance;
00224 }
00225
00226 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const HMAD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00227 }
00228
00229 namespace ROOT {
00230 void MCAD_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00231 TClass *MCAD_IsA(const void*);
00232 void *new_MCAD(void *p = 0);
00233 void *newArray_MCAD(Long_t size);
00234 void delete_MCAD(void *p);
00235 void deleteArray_MCAD(void *p);
00236 void destruct_MCAD(void *p);
00237
00238
00239 TGenericClassInfo *GenerateInitInstance(const MCAD*)
00240 {
00241 MCAD *ptr = 0;
00242 static ROOT::TGenericClassInfo
00243 instance("MCAD", MCAD::Class_Version(), "BankClasses.h", 123,
00244 typeid(MCAD), DefineBehavior(ptr, ptr),
00245 &::MCAD::Dictionary, &MCAD_IsA, 4);
00246 instance.SetNew(&new_MCAD);
00247 instance.SetNewArray(&newArray_MCAD);
00248 instance.SetDelete(&delete_MCAD);
00249 instance.SetDeleteArray(&deleteArray_MCAD);
00250 instance.SetDestructor(&destruct_MCAD);
00251 return &instance;
00252 }
00253
00254 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MCAD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00255 }
00256
00257 namespace ROOT {
00258 void PECO_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00259 TClass *PECO_IsA(const void*);
00260 void *new_PECO(void *p = 0);
00261 void *newArray_PECO(Long_t size);
00262 void delete_PECO(void *p);
00263 void deleteArray_PECO(void *p);
00264 void destruct_PECO(void *p);
00265
00266
00267 TGenericClassInfo *GenerateInitInstance(const PECO*)
00268 {
00269 PECO *ptr = 0;
00270 static ROOT::TGenericClassInfo
00271 instance("PECO", PECO::Class_Version(), "BankClasses.h", 138,
00272 typeid(PECO), DefineBehavior(ptr, ptr),
00273 &::PECO::Dictionary, &PECO_IsA, 4);
00274 instance.SetNew(&new_PECO);
00275 instance.SetNewArray(&newArray_PECO);
00276 instance.SetDelete(&delete_PECO);
00277 instance.SetDeleteArray(&deleteArray_PECO);
00278 instance.SetDestructor(&destruct_PECO);
00279 return &instance;
00280 }
00281
00282 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PECO*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00283 }
00284
00285 namespace ROOT {
00286 void EIDT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00287 TClass *EIDT_IsA(const void*);
00288 void *new_EIDT(void *p = 0);
00289 void *newArray_EIDT(Long_t size);
00290 void delete_EIDT(void *p);
00291 void deleteArray_EIDT(void *p);
00292 void destruct_EIDT(void *p);
00293
00294
00295 TGenericClassInfo *GenerateInitInstance(const EIDT*)
00296 {
00297 EIDT *ptr = 0;
00298 static ROOT::TGenericClassInfo
00299 instance("EIDT", EIDT::Class_Version(), "BankClasses.h", 157,
00300 typeid(EIDT), DefineBehavior(ptr, ptr),
00301 &::EIDT::Dictionary, &EIDT_IsA, 4);
00302 instance.SetNew(&new_EIDT);
00303 instance.SetNewArray(&newArray_EIDT);
00304 instance.SetDelete(&delete_EIDT);
00305 instance.SetDeleteArray(&deleteArray_EIDT);
00306 instance.SetDestructor(&destruct_EIDT);
00307 return &instance;
00308 }
00309
00310 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const EIDT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00311 }
00312
00313 namespace ROOT {
00314 void PHCO_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00315 TClass *PHCO_IsA(const void*);
00316 void *new_PHCO(void *p = 0);
00317 void *newArray_PHCO(Long_t size);
00318 void delete_PHCO(void *p);
00319 void deleteArray_PHCO(void *p);
00320 void destruct_PHCO(void *p);
00321
00322
00323 TGenericClassInfo *GenerateInitInstance(const PHCO*)
00324 {
00325 PHCO *ptr = 0;
00326 static ROOT::TGenericClassInfo
00327 instance("PHCO", PHCO::Class_Version(), "BankClasses.h", 181,
00328 typeid(PHCO), DefineBehavior(ptr, ptr),
00329 &::PHCO::Dictionary, &PHCO_IsA, 4);
00330 instance.SetNew(&new_PHCO);
00331 instance.SetNewArray(&newArray_PHCO);
00332 instance.SetDelete(&delete_PHCO);
00333 instance.SetDeleteArray(&deleteArray_PHCO);
00334 instance.SetDestructor(&destruct_PHCO);
00335 return &instance;
00336 }
00337
00338 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PHCO*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00339 }
00340
00341 namespace ROOT {
00342 void PEPT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00343 TClass *PEPT_IsA(const void*);
00344 void *new_PEPT(void *p = 0);
00345 void *newArray_PEPT(Long_t size);
00346 void delete_PEPT(void *p);
00347 void deleteArray_PEPT(void *p);
00348 void destruct_PEPT(void *p);
00349
00350
00351 TGenericClassInfo *GenerateInitInstance(const PEPT*)
00352 {
00353 PEPT *ptr = 0;
00354 static ROOT::TGenericClassInfo
00355 instance("PEPT", PEPT::Class_Version(), "BankClasses.h", 199,
00356 typeid(PEPT), DefineBehavior(ptr, ptr),
00357 &::PEPT::Dictionary, &PEPT_IsA, 4);
00358 instance.SetNew(&new_PEPT);
00359 instance.SetNewArray(&newArray_PEPT);
00360 instance.SetDelete(&delete_PEPT);
00361 instance.SetDeleteArray(&deleteArray_PEPT);
00362 instance.SetDestructor(&destruct_PEPT);
00363 return &instance;
00364 }
00365
00366 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PEPT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00367 }
00368
00369 namespace ROOT {
00370 void FRID_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00371 TClass *FRID_IsA(const void*);
00372 void *new_FRID(void *p = 0);
00373 void *newArray_FRID(Long_t size);
00374 void delete_FRID(void *p);
00375 void deleteArray_FRID(void *p);
00376 void destruct_FRID(void *p);
00377
00378
00379 TGenericClassInfo *GenerateInitInstance(const FRID*)
00380 {
00381 FRID *ptr = 0;
00382 static ROOT::TGenericClassInfo
00383 instance("FRID", FRID::Class_Version(), "BankClasses.h", 212,
00384 typeid(FRID), DefineBehavior(ptr, ptr),
00385 &::FRID::Dictionary, &FRID_IsA, 4);
00386 instance.SetNew(&new_FRID);
00387 instance.SetNewArray(&newArray_FRID);
00388 instance.SetDelete(&delete_FRID);
00389 instance.SetDeleteArray(&deleteArray_FRID);
00390 instance.SetDestructor(&destruct_FRID);
00391 return &instance;
00392 }
00393
00394 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const FRID*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00395 }
00396
00397 namespace ROOT {
00398 void EFOL_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00399 TClass *EFOL_IsA(const void*);
00400 void *new_EFOL(void *p = 0);
00401 void *newArray_EFOL(Long_t size);
00402 void delete_EFOL(void *p);
00403 void deleteArray_EFOL(void *p);
00404 void destruct_EFOL(void *p);
00405
00406
00407 TGenericClassInfo *GenerateInitInstance(const EFOL*)
00408 {
00409 EFOL *ptr = 0;
00410 static ROOT::TGenericClassInfo
00411 instance("EFOL", EFOL::Class_Version(), "BankClasses.h", 232,
00412 typeid(EFOL), DefineBehavior(ptr, ptr),
00413 &::EFOL::Dictionary, &EFOL_IsA, 4);
00414 instance.SetNew(&new_EFOL);
00415 instance.SetNewArray(&newArray_EFOL);
00416 instance.SetDelete(&delete_EFOL);
00417 instance.SetDeleteArray(&deleteArray_EFOL);
00418 instance.SetDestructor(&destruct_EFOL);
00419 return &instance;
00420 }
00421
00422 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const EFOL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00423 }
00424
00425 namespace ROOT {
00426 void PCQA_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00427 TClass *PCQA_IsA(const void*);
00428 void *new_PCQA(void *p = 0);
00429 void *newArray_PCQA(Long_t size);
00430 void delete_PCQA(void *p);
00431 void deleteArray_PCQA(void *p);
00432 void destruct_PCQA(void *p);
00433
00434
00435 TGenericClassInfo *GenerateInitInstance(const PCQA*)
00436 {
00437 PCQA *ptr = 0;
00438 static ROOT::TGenericClassInfo
00439 instance("PCQA", PCQA::Class_Version(), "BankClasses.h", 254,
00440 typeid(PCQA), DefineBehavior(ptr, ptr),
00441 &::PCQA::Dictionary, &PCQA_IsA, 4);
00442 instance.SetNew(&new_PCQA);
00443 instance.SetNewArray(&newArray_PCQA);
00444 instance.SetDelete(&delete_PCQA);
00445 instance.SetDeleteArray(&deleteArray_PCQA);
00446 instance.SetDestructor(&destruct_PCQA);
00447 return &instance;
00448 }
00449
00450 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PCQA*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00451 }
00452
00453 namespace ROOT {
00454 void EGPC_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00455 TClass *EGPC_IsA(const void*);
00456 void *new_EGPC(void *p = 0);
00457 void *newArray_EGPC(Long_t size);
00458 void delete_EGPC(void *p);
00459 void deleteArray_EGPC(void *p);
00460 void destruct_EGPC(void *p);
00461
00462
00463 TGenericClassInfo *GenerateInitInstance(const EGPC*)
00464 {
00465 EGPC *ptr = 0;
00466 static ROOT::TGenericClassInfo
00467 instance("EGPC", EGPC::Class_Version(), "BankClasses.h", 268,
00468 typeid(EGPC), DefineBehavior(ptr, ptr),
00469 &::EGPC::Dictionary, &EGPC_IsA, 4);
00470 instance.SetNew(&new_EGPC);
00471 instance.SetNewArray(&newArray_EGPC);
00472 instance.SetDelete(&delete_EGPC);
00473 instance.SetDeleteArray(&deleteArray_EGPC);
00474 instance.SetDestructor(&destruct_EGPC);
00475 return &instance;
00476 }
00477
00478 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const EGPC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00479 }
00480
00481 namespace ROOT {
00482 void MUID_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00483 TClass *MUID_IsA(const void*);
00484 void *new_MUID(void *p = 0);
00485 void *newArray_MUID(Long_t size);
00486 void delete_MUID(void *p);
00487 void deleteArray_MUID(void *p);
00488 void destruct_MUID(void *p);
00489
00490
00491 TGenericClassInfo *GenerateInitInstance(const MUID*)
00492 {
00493 MUID *ptr = 0;
00494 static ROOT::TGenericClassInfo
00495 instance("MUID", MUID::Class_Version(), "BankClasses.h", 287,
00496 typeid(MUID), DefineBehavior(ptr, ptr),
00497 &::MUID::Dictionary, &MUID_IsA, 4);
00498 instance.SetNew(&new_MUID);
00499 instance.SetNewArray(&newArray_MUID);
00500 instance.SetDelete(&delete_MUID);
00501 instance.SetDeleteArray(&deleteArray_MUID);
00502 instance.SetDestructor(&destruct_MUID);
00503 return &instance;
00504 }
00505
00506 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MUID*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00507 }
00508
00509 namespace ROOT {
00510 void PGPC_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00511 TClass *PGPC_IsA(const void*);
00512 void *new_PGPC(void *p = 0);
00513 void *newArray_PGPC(Long_t size);
00514 void delete_PGPC(void *p);
00515 void deleteArray_PGPC(void *p);
00516 void destruct_PGPC(void *p);
00517
00518
00519 TGenericClassInfo *GenerateInitInstance(const PGPC*)
00520 {
00521 PGPC *ptr = 0;
00522 static ROOT::TGenericClassInfo
00523 instance("PGPC", PGPC::Class_Version(), "BankClasses.h", 301,
00524 typeid(PGPC), DefineBehavior(ptr, ptr),
00525 &::PGPC::Dictionary, &PGPC_IsA, 4);
00526 instance.SetNew(&new_PGPC);
00527 instance.SetNewArray(&newArray_PGPC);
00528 instance.SetDelete(&delete_PGPC);
00529 instance.SetDeleteArray(&deleteArray_PGPC);
00530 instance.SetDestructor(&destruct_PGPC);
00531 return &instance;
00532 }
00533
00534 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PGPC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00535 }
00536
00537 namespace ROOT {
00538 void PGAC_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00539 TClass *PGAC_IsA(const void*);
00540 void *new_PGAC(void *p = 0);
00541 void *newArray_PGAC(Long_t size);
00542 void delete_PGAC(void *p);
00543 void deleteArray_PGAC(void *p);
00544 void destruct_PGAC(void *p);
00545
00546
00547 TGenericClassInfo *GenerateInitInstance(const PGAC*)
00548 {
00549 PGAC *ptr = 0;
00550 static ROOT::TGenericClassInfo
00551 instance("PGAC", PGAC::Class_Version(), "BankClasses.h", 328,
00552 typeid(PGAC), DefineBehavior(ptr, ptr),
00553 &::PGAC::Dictionary, &PGAC_IsA, 4);
00554 instance.SetNew(&new_PGAC);
00555 instance.SetNewArray(&newArray_PGAC);
00556 instance.SetDelete(&delete_PGAC);
00557 instance.SetDeleteArray(&deleteArray_PGAC);
00558 instance.SetDestructor(&destruct_PGAC);
00559 return &instance;
00560 }
00561
00562 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PGAC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00563 }
00564
00565 namespace ROOT {
00566 void PDLT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00567 TClass *PDLT_IsA(const void*);
00568 void *new_PDLT(void *p = 0);
00569 void *newArray_PDLT(Long_t size);
00570 void delete_PDLT(void *p);
00571 void deleteArray_PDLT(void *p);
00572 void destruct_PDLT(void *p);
00573
00574
00575 TGenericClassInfo *GenerateInitInstance(const PDLT*)
00576 {
00577 PDLT *ptr = 0;
00578 static ROOT::TGenericClassInfo
00579 instance("PDLT", PDLT::Class_Version(), "BankClasses.h", 362,
00580 typeid(PDLT), DefineBehavior(ptr, ptr),
00581 &::PDLT::Dictionary, &PDLT_IsA, 4);
00582 instance.SetNew(&new_PDLT);
00583 instance.SetNewArray(&newArray_PDLT);
00584 instance.SetDelete(&delete_PDLT);
00585 instance.SetDeleteArray(&deleteArray_PDLT);
00586 instance.SetDestructor(&destruct_PDLT);
00587 return &instance;
00588 }
00589
00590 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PDLT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00591 }
00592
00593 namespace ROOT {
00594 void PMLT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00595 TClass *PMLT_IsA(const void*);
00596 void *new_PMLT(void *p = 0);
00597 void *newArray_PMLT(Long_t size);
00598 void delete_PMLT(void *p);
00599 void deleteArray_PMLT(void *p);
00600 void destruct_PMLT(void *p);
00601
00602
00603 TGenericClassInfo *GenerateInitInstance(const PMLT*)
00604 {
00605 PMLT *ptr = 0;
00606 static ROOT::TGenericClassInfo
00607 instance("PMLT", PMLT::Class_Version(), "BankClasses.h", 377,
00608 typeid(PMLT), DefineBehavior(ptr, ptr),
00609 &::PMLT::Dictionary, &PMLT_IsA, 4);
00610 instance.SetNew(&new_PMLT);
00611 instance.SetNewArray(&newArray_PMLT);
00612 instance.SetDelete(&delete_PMLT);
00613 instance.SetDeleteArray(&deleteArray_PMLT);
00614 instance.SetDestructor(&destruct_PMLT);
00615 return &instance;
00616 }
00617
00618 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const PMLT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00619 }
00620
00621 namespace ROOT {
00622 void QDET_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00623 TClass *QDET_IsA(const void*);
00624 void *new_QDET(void *p = 0);
00625 void *newArray_QDET(Long_t size);
00626 void delete_QDET(void *p);
00627 void deleteArray_QDET(void *p);
00628 void destruct_QDET(void *p);
00629
00630
00631 TGenericClassInfo *GenerateInitInstance(const QDET*)
00632 {
00633 QDET *ptr = 0;
00634 static ROOT::TGenericClassInfo
00635 instance("QDET", QDET::Class_Version(), "BankClasses.h", 394,
00636 typeid(QDET), DefineBehavior(ptr, ptr),
00637 &::QDET::Dictionary, &QDET_IsA, 4);
00638 instance.SetNew(&new_QDET);
00639 instance.SetNewArray(&newArray_QDET);
00640 instance.SetDelete(&delete_QDET);
00641 instance.SetDeleteArray(&deleteArray_QDET);
00642 instance.SetDestructor(&destruct_QDET);
00643 return &instance;
00644 }
00645
00646 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QDET*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00647 }
00648
00649 namespace ROOT {
00650 void QVEC_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00651 TClass *QVEC_IsA(const void*);
00652 void *new_QVEC(void *p = 0);
00653 void *newArray_QVEC(Long_t size);
00654 void delete_QVEC(void *p);
00655 void deleteArray_QVEC(void *p);
00656 void destruct_QVEC(void *p);
00657
00658
00659 TGenericClassInfo *GenerateInitInstance(const QVEC*)
00660 {
00661 QVEC *ptr = 0;
00662 static ROOT::TGenericClassInfo
00663 instance("QVEC", QVEC::Class_Version(), "BankClasses.h", 431,
00664 typeid(QVEC), DefineBehavior(ptr, ptr),
00665 &::QVEC::Dictionary, &QVEC_IsA, 4);
00666 instance.SetNew(&new_QVEC);
00667 instance.SetNewArray(&newArray_QVEC);
00668 instance.SetDelete(&delete_QVEC);
00669 instance.SetDeleteArray(&deleteArray_QVEC);
00670 instance.SetDestructor(&destruct_QVEC);
00671 return &instance;
00672 }
00673
00674 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QVEC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00675 }
00676
00677 namespace ROOT {
00678 void YV0V_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00679 TClass *YV0V_IsA(const void*);
00680 void *new_YV0V(void *p = 0);
00681 void *newArray_YV0V(Long_t size);
00682 void delete_YV0V(void *p);
00683 void deleteArray_YV0V(void *p);
00684 void destruct_YV0V(void *p);
00685
00686
00687 TGenericClassInfo *GenerateInitInstance(const YV0V*)
00688 {
00689 YV0V *ptr = 0;
00690 static ROOT::TGenericClassInfo
00691 instance("YV0V", YV0V::Class_Version(), "BankClasses.h", 476,
00692 typeid(YV0V), DefineBehavior(ptr, ptr),
00693 &::YV0V::Dictionary, &YV0V_IsA, 4);
00694 instance.SetNew(&new_YV0V);
00695 instance.SetNewArray(&newArray_YV0V);
00696 instance.SetDelete(&delete_YV0V);
00697 instance.SetDeleteArray(&deleteArray_YV0V);
00698 instance.SetDestructor(&destruct_YV0V);
00699 return &instance;
00700 }
00701
00702 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const YV0V*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00703 }
00704
00705 namespace ROOT {
00706 void FKIN_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00707 TClass *FKIN_IsA(const void*);
00708 void *new_FKIN(void *p = 0);
00709 void *newArray_FKIN(Long_t size);
00710 void delete_FKIN(void *p);
00711 void deleteArray_FKIN(void *p);
00712 void destruct_FKIN(void *p);
00713
00714
00715 TGenericClassInfo *GenerateInitInstance(const FKIN*)
00716 {
00717 FKIN *ptr = 0;
00718 static ROOT::TGenericClassInfo
00719 instance("FKIN", FKIN::Class_Version(), "BankClasses.h", 506,
00720 typeid(FKIN), DefineBehavior(ptr, ptr),
00721 &::FKIN::Dictionary, &FKIN_IsA, 4);
00722 instance.SetNew(&new_FKIN);
00723 instance.SetNewArray(&newArray_FKIN);
00724 instance.SetDelete(&delete_FKIN);
00725 instance.SetDeleteArray(&deleteArray_FKIN);
00726 instance.SetDestructor(&destruct_FKIN);
00727 return &instance;
00728 }
00729
00730 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const FKIN*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00731 }
00732
00733 namespace ROOT {
00734 void FVER_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00735 TClass *FVER_IsA(const void*);
00736 void *new_FVER(void *p = 0);
00737 void *newArray_FVER(Long_t size);
00738 void delete_FVER(void *p);
00739 void deleteArray_FVER(void *p);
00740 void destruct_FVER(void *p);
00741
00742
00743 TGenericClassInfo *GenerateInitInstance(const FVER*)
00744 {
00745 FVER *ptr = 0;
00746 static ROOT::TGenericClassInfo
00747 instance("FVER", FVER::Class_Version(), "BankClasses.h", 523,
00748 typeid(FVER), DefineBehavior(ptr, ptr),
00749 &::FVER::Dictionary, &FVER_IsA, 4);
00750 instance.SetNew(&new_FVER);
00751 instance.SetNewArray(&newArray_FVER);
00752 instance.SetDelete(&delete_FVER);
00753 instance.SetDeleteArray(&deleteArray_FVER);
00754 instance.SetDestructor(&destruct_FVER);
00755 return &instance;
00756 }
00757
00758 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const FVER*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00759 }
00760
00761 namespace ROOT {
00762 void QVRT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00763 TClass *QVRT_IsA(const void*);
00764 void *new_QVRT(void *p = 0);
00765 void *newArray_QVRT(Long_t size);
00766 void delete_QVRT(void *p);
00767 void deleteArray_QVRT(void *p);
00768 void destruct_QVRT(void *p);
00769
00770
00771 TGenericClassInfo *GenerateInitInstance(const QVRT*)
00772 {
00773 QVRT *ptr = 0;
00774 static ROOT::TGenericClassInfo
00775 instance("QVRT", QVRT::Class_Version(), "BankClasses.h", 541,
00776 typeid(QVRT), DefineBehavior(ptr, ptr),
00777 &::QVRT::Dictionary, &QVRT_IsA, 4);
00778 instance.SetNew(&new_QVRT);
00779 instance.SetNewArray(&newArray_QVRT);
00780 instance.SetDelete(&delete_QVRT);
00781 instance.SetDeleteArray(&deleteArray_QVRT);
00782 instance.SetDestructor(&destruct_QVRT);
00783 return &instance;
00784 }
00785
00786 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QVRT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00787 }
00788
00789 namespace ROOT {
00790 void ALPB_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00791 TClass *ALPB_IsA(const void*);
00792 void *new_ALPB(void *p = 0);
00793 void *newArray_ALPB(Long_t size);
00794 void delete_ALPB(void *p);
00795 void deleteArray_ALPB(void *p);
00796 void destruct_ALPB(void *p);
00797
00798
00799 TGenericClassInfo *GenerateInitInstance(const ALPB*)
00800 {
00801 ALPB *ptr = 0;
00802 static ROOT::TGenericClassInfo
00803 instance("ALPB", ALPB::Class_Version(), "BankClasses.h", 568,
00804 typeid(ALPB), DefineBehavior(ptr, ptr),
00805 &::ALPB::Dictionary, &ALPB_IsA, 4);
00806 instance.SetNew(&new_ALPB);
00807 instance.SetNewArray(&newArray_ALPB);
00808 instance.SetDelete(&delete_ALPB);
00809 instance.SetDeleteArray(&deleteArray_ALPB);
00810 instance.SetDestructor(&destruct_ALPB);
00811 return &instance;
00812 }
00813
00814 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ALPB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00815 }
00816
00817 namespace ROOT {
00818 void ALRP_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00819 TClass *ALRP_IsA(const void*);
00820 void *new_ALRP(void *p = 0);
00821 void *newArray_ALRP(Long_t size);
00822 void delete_ALRP(void *p);
00823 void deleteArray_ALRP(void *p);
00824 void destruct_ALRP(void *p);
00825
00826
00827 TGenericClassInfo *GenerateInitInstance(const ALRP*)
00828 {
00829 ALRP *ptr = 0;
00830 static ROOT::TGenericClassInfo
00831 instance("ALRP", ALRP::Class_Version(), "BankClasses.h", 582,
00832 typeid(ALRP), DefineBehavior(ptr, ptr),
00833 &::ALRP::Dictionary, &ALRP_IsA, 4);
00834 instance.SetNew(&new_ALRP);
00835 instance.SetNewArray(&newArray_ALRP);
00836 instance.SetDelete(&delete_ALRP);
00837 instance.SetDeleteArray(&deleteArray_ALRP);
00838 instance.SetDestructor(&destruct_ALRP);
00839 return &instance;
00840 }
00841
00842 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ALRP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00843 }
00844
00845 namespace ROOT {
00846 void RNL2_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00847 TClass *RNL2_IsA(const void*);
00848 void *new_RNL2(void *p = 0);
00849 void *newArray_RNL2(Long_t size);
00850 void delete_RNL2(void *p);
00851 void deleteArray_RNL2(void *p);
00852 void destruct_RNL2(void *p);
00853
00854
00855 TGenericClassInfo *GenerateInitInstance(const RNL2*)
00856 {
00857 RNL2 *ptr = 0;
00858 static ROOT::TGenericClassInfo
00859 instance("RNL2", RNL2::Class_Version(), "BankClasses.h", 604,
00860 typeid(RNL2), DefineBehavior(ptr, ptr),
00861 &::RNL2::Dictionary, &RNL2_IsA, 4);
00862 instance.SetNew(&new_RNL2);
00863 instance.SetNewArray(&newArray_RNL2);
00864 instance.SetDelete(&delete_RNL2);
00865 instance.SetDeleteArray(&deleteArray_RNL2);
00866 instance.SetDestructor(&destruct_RNL2);
00867 return &instance;
00868 }
00869
00870 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const RNL2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00871 }
00872
00873 namespace ROOT {
00874 void RNF2_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00875 TClass *RNF2_IsA(const void*);
00876 void *new_RNF2(void *p = 0);
00877 void *newArray_RNF2(Long_t size);
00878 void delete_RNF2(void *p);
00879 void deleteArray_RNF2(void *p);
00880 void destruct_RNF2(void *p);
00881
00882
00883 TGenericClassInfo *GenerateInitInstance(const RNF2*)
00884 {
00885 RNF2 *ptr = 0;
00886 static ROOT::TGenericClassInfo
00887 instance("RNF2", RNF2::Class_Version(), "BankClasses.h", 616,
00888 typeid(RNF2), DefineBehavior(ptr, ptr),
00889 &::RNF2::Dictionary, &RNF2_IsA, 4);
00890 instance.SetNew(&new_RNF2);
00891 instance.SetNewArray(&newArray_RNF2);
00892 instance.SetDelete(&delete_RNF2);
00893 instance.SetDeleteArray(&deleteArray_RNF2);
00894 instance.SetDestructor(&destruct_RNF2);
00895 return &instance;
00896 }
00897
00898 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const RNF2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00899 }
00900
00901 namespace ROOT {
00902 void RNR2_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00903 TClass *RNR2_IsA(const void*);
00904 void *new_RNR2(void *p = 0);
00905 void *newArray_RNR2(Long_t size);
00906 void delete_RNR2(void *p);
00907 void deleteArray_RNR2(void *p);
00908 void destruct_RNR2(void *p);
00909
00910
00911 TGenericClassInfo *GenerateInitInstance(const RNR2*)
00912 {
00913 RNR2 *ptr = 0;
00914 static ROOT::TGenericClassInfo
00915 instance("RNR2", RNR2::Class_Version(), "BankClasses.h", 632,
00916 typeid(RNR2), DefineBehavior(ptr, ptr),
00917 &::RNR2::Dictionary, &RNR2_IsA, 4);
00918 instance.SetNew(&new_RNR2);
00919 instance.SetNewArray(&newArray_RNR2);
00920 instance.SetDelete(&delete_RNR2);
00921 instance.SetDeleteArray(&deleteArray_RNR2);
00922 instance.SetDestructor(&destruct_RNR2);
00923 return &instance;
00924 }
00925
00926 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const RNR2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00927 }
00928
00929 namespace ROOT {
00930 void RLEP_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00931 TClass *RLEP_IsA(const void*);
00932 void *new_RLEP(void *p = 0);
00933 void *newArray_RLEP(Long_t size);
00934 void delete_RLEP(void *p);
00935 void deleteArray_RLEP(void *p);
00936 void destruct_RLEP(void *p);
00937
00938
00939 TGenericClassInfo *GenerateInitInstance(const RLEP*)
00940 {
00941 RLEP *ptr = 0;
00942 static ROOT::TGenericClassInfo
00943 instance("RLEP", RLEP::Class_Version(), "BankClasses.h", 643,
00944 typeid(RLEP), DefineBehavior(ptr, ptr),
00945 &::RLEP::Dictionary, &RLEP_IsA, 4);
00946 instance.SetNew(&new_RLEP);
00947 instance.SetNewArray(&newArray_RLEP);
00948 instance.SetDelete(&delete_RLEP);
00949 instance.SetDeleteArray(&deleteArray_RLEP);
00950 instance.SetDestructor(&destruct_RLEP);
00951 return &instance;
00952 }
00953
00954 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const RLEP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00955 }
00956
00957 namespace ROOT {
00958 void LFIL_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00959 TClass *LFIL_IsA(const void*);
00960 void *new_LFIL(void *p = 0);
00961 void *newArray_LFIL(Long_t size);
00962 void delete_LFIL(void *p);
00963 void deleteArray_LFIL(void *p);
00964 void destruct_LFIL(void *p);
00965
00966
00967 TGenericClassInfo *GenerateInitInstance(const LFIL*)
00968 {
00969 LFIL *ptr = 0;
00970 static ROOT::TGenericClassInfo
00971 instance("LFIL", LFIL::Class_Version(), "BankClasses.h", 657,
00972 typeid(LFIL), DefineBehavior(ptr, ptr),
00973 &::LFIL::Dictionary, &LFIL_IsA, 4);
00974 instance.SetNew(&new_LFIL);
00975 instance.SetNewArray(&newArray_LFIL);
00976 instance.SetDelete(&delete_LFIL);
00977 instance.SetDeleteArray(&deleteArray_LFIL);
00978 instance.SetDestructor(&destruct_LFIL);
00979 return &instance;
00980 }
00981
00982 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const LFIL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00983 }
00984
00985 namespace ROOT {
00986 void EVEH_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
00987 TClass *EVEH_IsA(const void*);
00988 void *new_EVEH(void *p = 0);
00989 void *newArray_EVEH(Long_t size);
00990 void delete_EVEH(void *p);
00991 void deleteArray_EVEH(void *p);
00992 void destruct_EVEH(void *p);
00993
00994
00995 TGenericClassInfo *GenerateInitInstance(const EVEH*)
00996 {
00997 EVEH *ptr = 0;
00998 static ROOT::TGenericClassInfo
00999 instance("EVEH", EVEH::Class_Version(), "BankClasses.h", 678,
01000 typeid(EVEH), DefineBehavior(ptr, ptr),
01001 &::EVEH::Dictionary, &EVEH_IsA, 4);
01002 instance.SetNew(&new_EVEH);
01003 instance.SetNewArray(&newArray_EVEH);
01004 instance.SetDelete(&delete_EVEH);
01005 instance.SetDeleteArray(&deleteArray_EVEH);
01006 instance.SetDestructor(&destruct_EVEH);
01007 return &instance;
01008 }
01009
01010 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const EVEH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01011 }
01012
01013 namespace ROOT {
01014 void KEVH_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01015 TClass *KEVH_IsA(const void*);
01016 void *new_KEVH(void *p = 0);
01017 void *newArray_KEVH(Long_t size);
01018 void delete_KEVH(void *p);
01019 void deleteArray_KEVH(void *p);
01020 void destruct_KEVH(void *p);
01021
01022
01023 TGenericClassInfo *GenerateInitInstance(const KEVH*)
01024 {
01025 KEVH *ptr = 0;
01026 static ROOT::TGenericClassInfo
01027 instance("KEVH", KEVH::Class_Version(), "BankClasses.h", 700,
01028 typeid(KEVH), DefineBehavior(ptr, ptr),
01029 &::KEVH::Dictionary, &KEVH_IsA, 4);
01030 instance.SetNew(&new_KEVH);
01031 instance.SetNewArray(&newArray_KEVH);
01032 instance.SetDelete(&delete_KEVH);
01033 instance.SetDeleteArray(&deleteArray_KEVH);
01034 instance.SetDestructor(&destruct_KEVH);
01035 return &instance;
01036 }
01037
01038 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const KEVH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01039 }
01040
01041 namespace ROOT {
01042 void REVH_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01043 TClass *REVH_IsA(const void*);
01044 void *new_REVH(void *p = 0);
01045 void *newArray_REVH(Long_t size);
01046 void delete_REVH(void *p);
01047 void deleteArray_REVH(void *p);
01048 void destruct_REVH(void *p);
01049
01050
01051 TGenericClassInfo *GenerateInitInstance(const REVH*)
01052 {
01053 REVH *ptr = 0;
01054 static ROOT::TGenericClassInfo
01055 instance("REVH", REVH::Class_Version(), "BankClasses.h", 716,
01056 typeid(REVH), DefineBehavior(ptr, ptr),
01057 &::REVH::Dictionary, &REVH_IsA, 4);
01058 instance.SetNew(&new_REVH);
01059 instance.SetNewArray(&newArray_REVH);
01060 instance.SetDelete(&delete_REVH);
01061 instance.SetDeleteArray(&deleteArray_REVH);
01062 instance.SetDestructor(&destruct_REVH);
01063 return &instance;
01064 }
01065
01066 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const REVH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01067 }
01068
01069 namespace ROOT {
01070 void LOLE_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01071 TClass *LOLE_IsA(const void*);
01072 void *new_LOLE(void *p = 0);
01073 void *newArray_LOLE(Long_t size);
01074 void delete_LOLE(void *p);
01075 void deleteArray_LOLE(void *p);
01076 void destruct_LOLE(void *p);
01077
01078
01079 TGenericClassInfo *GenerateInitInstance(const LOLE*)
01080 {
01081 LOLE *ptr = 0;
01082 static ROOT::TGenericClassInfo
01083 instance("LOLE", LOLE::Class_Version(), "BankClasses.h", 732,
01084 typeid(LOLE), DefineBehavior(ptr, ptr),
01085 &::LOLE::Dictionary, &LOLE_IsA, 4);
01086 instance.SetNew(&new_LOLE);
01087 instance.SetNewArray(&newArray_LOLE);
01088 instance.SetDelete(&delete_LOLE);
01089 instance.SetDeleteArray(&deleteArray_LOLE);
01090 instance.SetDestructor(&destruct_LOLE);
01091 return &instance;
01092 }
01093
01094 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const LOLE*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01095 }
01096
01097 namespace ROOT {
01098 void X1RG_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01099 TClass *X1RG_IsA(const void*);
01100 void *new_X1RG(void *p = 0);
01101 void *newArray_X1RG(Long_t size);
01102 void delete_X1RG(void *p);
01103 void deleteArray_X1RG(void *p);
01104 void destruct_X1RG(void *p);
01105
01106
01107 TGenericClassInfo *GenerateInitInstance(const X1RG*)
01108 {
01109 X1RG *ptr = 0;
01110 static ROOT::TGenericClassInfo
01111 instance("X1RG", X1RG::Class_Version(), "BankClasses.h", 747,
01112 typeid(X1RG), DefineBehavior(ptr, ptr),
01113 &::X1RG::Dictionary, &X1RG_IsA, 4);
01114 instance.SetNew(&new_X1RG);
01115 instance.SetNewArray(&newArray_X1RG);
01116 instance.SetDelete(&delete_X1RG);
01117 instance.SetDeleteArray(&deleteArray_X1RG);
01118 instance.SetDestructor(&destruct_X1RG);
01119 return &instance;
01120 }
01121
01122 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const X1RG*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01123 }
01124
01125 namespace ROOT {
01126 void BOMB_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01127 TClass *BOMB_IsA(const void*);
01128 void *new_BOMB(void *p = 0);
01129 void *newArray_BOMB(Long_t size);
01130 void delete_BOMB(void *p);
01131 void deleteArray_BOMB(void *p);
01132 void destruct_BOMB(void *p);
01133
01134
01135 TGenericClassInfo *GenerateInitInstance(const BOMB*)
01136 {
01137 BOMB *ptr = 0;
01138 static ROOT::TGenericClassInfo
01139 instance("BOMB", BOMB::Class_Version(), "BankClasses.h", 758,
01140 typeid(BOMB), DefineBehavior(ptr, ptr),
01141 &::BOMB::Dictionary, &BOMB_IsA, 4);
01142 instance.SetNew(&new_BOMB);
01143 instance.SetNewArray(&newArray_BOMB);
01144 instance.SetDelete(&delete_BOMB);
01145 instance.SetDeleteArray(&deleteArray_BOMB);
01146 instance.SetDestructor(&destruct_BOMB);
01147 return &instance;
01148 }
01149
01150 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const BOMB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01151 }
01152
01153 namespace ROOT {
01154 void RUNH_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01155 TClass *RUNH_IsA(const void*);
01156 void *new_RUNH(void *p = 0);
01157 void *newArray_RUNH(Long_t size);
01158 void delete_RUNH(void *p);
01159 void deleteArray_RUNH(void *p);
01160 void destruct_RUNH(void *p);
01161
01162
01163 TGenericClassInfo *GenerateInitInstance(const RUNH*)
01164 {
01165 RUNH *ptr = 0;
01166 static ROOT::TGenericClassInfo
01167 instance("RUNH", RUNH::Class_Version(), "BankClasses.h", 770,
01168 typeid(RUNH), DefineBehavior(ptr, ptr),
01169 &::RUNH::Dictionary, &RUNH_IsA, 4);
01170 instance.SetNew(&new_RUNH);
01171 instance.SetNewArray(&newArray_RUNH);
01172 instance.SetDelete(&delete_RUNH);
01173 instance.SetDeleteArray(&deleteArray_RUNH);
01174 instance.SetDestructor(&destruct_RUNH);
01175 return &instance;
01176 }
01177
01178 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const RUNH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01179 }
01180
01181 namespace ROOT {
01182 void ASIM_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01183 TClass *ASIM_IsA(const void*);
01184 void *new_ASIM(void *p = 0);
01185 void *newArray_ASIM(Long_t size);
01186 void delete_ASIM(void *p);
01187 void deleteArray_ASIM(void *p);
01188 void destruct_ASIM(void *p);
01189
01190
01191 TGenericClassInfo *GenerateInitInstance(const ASIM*)
01192 {
01193 ASIM *ptr = 0;
01194 static ROOT::TGenericClassInfo
01195 instance("ASIM", ASIM::Class_Version(), "BankClasses.h", 786,
01196 typeid(ASIM), DefineBehavior(ptr, ptr),
01197 &::ASIM::Dictionary, &ASIM_IsA, 4);
01198 instance.SetNew(&new_ASIM);
01199 instance.SetNewArray(&newArray_ASIM);
01200 instance.SetDelete(&delete_ASIM);
01201 instance.SetDeleteArray(&deleteArray_ASIM);
01202 instance.SetDestructor(&destruct_ASIM);
01203 return &instance;
01204 }
01205
01206 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ASIM*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01207 }
01208
01209 namespace ROOT {
01210 void ADBR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01211 TClass *ADBR_IsA(const void*);
01212 void *new_ADBR(void *p = 0);
01213 void *newArray_ADBR(Long_t size);
01214 void delete_ADBR(void *p);
01215 void deleteArray_ADBR(void *p);
01216 void destruct_ADBR(void *p);
01217
01218
01219 TGenericClassInfo *GenerateInitInstance(const ADBR*)
01220 {
01221 ADBR *ptr = 0;
01222 static ROOT::TGenericClassInfo
01223 instance("ADBR", ADBR::Class_Version(), "BankClasses.h", 796,
01224 typeid(ADBR), DefineBehavior(ptr, ptr),
01225 &::ADBR::Dictionary, &ADBR_IsA, 4);
01226 instance.SetNew(&new_ADBR);
01227 instance.SetNewArray(&newArray_ADBR);
01228 instance.SetDelete(&delete_ADBR);
01229 instance.SetDeleteArray(&deleteArray_ADBR);
01230 instance.SetDestructor(&destruct_ADBR);
01231 return &instance;
01232 }
01233
01234 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ADBR*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01235 }
01236
01237 namespace ROOT {
01238 void XTBN_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01239 TClass *XTBN_IsA(const void*);
01240 void *new_XTBN(void *p = 0);
01241 void *newArray_XTBN(Long_t size);
01242 void delete_XTBN(void *p);
01243 void deleteArray_XTBN(void *p);
01244 void destruct_XTBN(void *p);
01245
01246
01247 TGenericClassInfo *GenerateInitInstance(const XTBN*)
01248 {
01249 XTBN *ptr = 0;
01250 static ROOT::TGenericClassInfo
01251 instance("XTBN", XTBN::Class_Version(), "BankClasses.h", 821,
01252 typeid(XTBN), DefineBehavior(ptr, ptr),
01253 &::XTBN::Dictionary, &XTBN_IsA, 4);
01254 instance.SetNew(&new_XTBN);
01255 instance.SetNewArray(&newArray_XTBN);
01256 instance.SetDelete(&delete_XTBN);
01257 instance.SetDeleteArray(&deleteArray_XTBN);
01258 instance.SetDestructor(&destruct_XTBN);
01259 return &instance;
01260 }
01261
01262 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const XTBN*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01263 }
01264
01265 namespace ROOT {
01266 void XTCN_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01267 TClass *XTCN_IsA(const void*);
01268 void *new_XTCN(void *p = 0);
01269 void *newArray_XTCN(Long_t size);
01270 void delete_XTCN(void *p);
01271 void deleteArray_XTCN(void *p);
01272 void destruct_XTCN(void *p);
01273
01274
01275 TGenericClassInfo *GenerateInitInstance(const XTCN*)
01276 {
01277 XTCN *ptr = 0;
01278 static ROOT::TGenericClassInfo
01279 instance("XTCN", XTCN::Class_Version(), "BankClasses.h", 839,
01280 typeid(XTCN), DefineBehavior(ptr, ptr),
01281 &::XTCN::Dictionary, &XTCN_IsA, 4);
01282 instance.SetNew(&new_XTCN);
01283 instance.SetNewArray(&newArray_XTCN);
01284 instance.SetDelete(&delete_XTCN);
01285 instance.SetDeleteArray(&deleteArray_XTCN);
01286 instance.SetDestructor(&destruct_XTCN);
01287 return &instance;
01288 }
01289
01290 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const XTCN*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01291 }
01292
01293 namespace ROOT {
01294 void XTOP_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01295 TClass *XTOP_IsA(const void*);
01296 void *new_XTOP(void *p = 0);
01297 void *newArray_XTOP(Long_t size);
01298 void delete_XTOP(void *p);
01299 void deleteArray_XTOP(void *p);
01300 void destruct_XTOP(void *p);
01301
01302
01303 TGenericClassInfo *GenerateInitInstance(const XTOP*)
01304 {
01305 XTOP *ptr = 0;
01306 static ROOT::TGenericClassInfo
01307 instance("XTOP", XTOP::Class_Version(), "BankClasses.h", 854,
01308 typeid(XTOP), DefineBehavior(ptr, ptr),
01309 &::XTOP::Dictionary, &XTOP_IsA, 4);
01310 instance.SetNew(&new_XTOP);
01311 instance.SetNewArray(&newArray_XTOP);
01312 instance.SetDelete(&delete_XTOP);
01313 instance.SetDeleteArray(&deleteArray_XTOP);
01314 instance.SetDestructor(&destruct_XTOP);
01315 return &instance;
01316 }
01317
01318 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const XTOP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01319 }
01320
01321 namespace ROOT {
01322 void LUPA_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01323 TClass *LUPA_IsA(const void*);
01324 void *new_LUPA(void *p = 0);
01325 void *newArray_LUPA(Long_t size);
01326 void delete_LUPA(void *p);
01327 void deleteArray_LUPA(void *p);
01328 void destruct_LUPA(void *p);
01329
01330
01331 TGenericClassInfo *GenerateInitInstance(const LUPA*)
01332 {
01333 LUPA *ptr = 0;
01334 static ROOT::TGenericClassInfo
01335 instance("LUPA", LUPA::Class_Version(), "BankClasses.h", 870,
01336 typeid(LUPA), DefineBehavior(ptr, ptr),
01337 &::LUPA::Dictionary, &LUPA_IsA, 4);
01338 instance.SetNew(&new_LUPA);
01339 instance.SetNewArray(&newArray_LUPA);
01340 instance.SetDelete(&delete_LUPA);
01341 instance.SetDeleteArray(&deleteArray_LUPA);
01342 instance.SetDestructor(&destruct_LUPA);
01343 return &instance;
01344 }
01345
01346 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const LUPA*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01347 }
01348
01349 namespace ROOT {
01350 void SILH_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01351 TClass *SILH_IsA(const void*);
01352 void *new_SILH(void *p = 0);
01353 void *newArray_SILH(Long_t size);
01354 void delete_SILH(void *p);
01355 void deleteArray_SILH(void *p);
01356 void destruct_SILH(void *p);
01357
01358
01359 TGenericClassInfo *GenerateInitInstance(const SILH*)
01360 {
01361 SILH *ptr = 0;
01362 static ROOT::TGenericClassInfo
01363 instance("SILH", SILH::Class_Version(), "BankClasses.h", 919,
01364 typeid(SILH), DefineBehavior(ptr, ptr),
01365 &::SILH::Dictionary, &SILH_IsA, 4);
01366 instance.SetNew(&new_SILH);
01367 instance.SetNewArray(&newArray_SILH);
01368 instance.SetDelete(&delete_SILH);
01369 instance.SetDeleteArray(&deleteArray_SILH);
01370 instance.SetDestructor(&destruct_SILH);
01371 return &instance;
01372 }
01373
01374 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const SILH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01375 }
01376
01377 namespace ROOT {
01378 void XHVB_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01379 TClass *XHVB_IsA(const void*);
01380 void *new_XHVB(void *p = 0);
01381 void *newArray_XHVB(Long_t size);
01382 void delete_XHVB(void *p);
01383 void deleteArray_XHVB(void *p);
01384 void destruct_XHVB(void *p);
01385
01386
01387 TGenericClassInfo *GenerateInitInstance(const XHVB*)
01388 {
01389 XHVB *ptr = 0;
01390 static ROOT::TGenericClassInfo
01391 instance("XHVB", XHVB::Class_Version(), "BankClasses.h", 939,
01392 typeid(XHVB), DefineBehavior(ptr, ptr),
01393 &::XHVB::Dictionary, &XHVB_IsA, 4);
01394 instance.SetNew(&new_XHVB);
01395 instance.SetNewArray(&newArray_XHVB);
01396 instance.SetDelete(&delete_XHVB);
01397 instance.SetDeleteArray(&deleteArray_XHVB);
01398 instance.SetDestructor(&destruct_XHVB);
01399 return &instance;
01400 }
01401
01402 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const XHVB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01403 }
01404
01405 namespace ROOT {
01406 void XTEB_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01407 TClass *XTEB_IsA(const void*);
01408 void *new_XTEB(void *p = 0);
01409 void *newArray_XTEB(Long_t size);
01410 void delete_XTEB(void *p);
01411 void deleteArray_XTEB(void *p);
01412 void destruct_XTEB(void *p);
01413
01414
01415 TGenericClassInfo *GenerateInitInstance(const XTEB*)
01416 {
01417 XTEB *ptr = 0;
01418 static ROOT::TGenericClassInfo
01419 instance("XTEB", XTEB::Class_Version(), "BankClasses.h", 953,
01420 typeid(XTEB), DefineBehavior(ptr, ptr),
01421 &::XTEB::Dictionary, &XTEB_IsA, 4);
01422 instance.SetNew(&new_XTEB);
01423 instance.SetNewArray(&newArray_XTEB);
01424 instance.SetDelete(&delete_XTEB);
01425 instance.SetDeleteArray(&deleteArray_XTEB);
01426 instance.SetDestructor(&destruct_XTEB);
01427 return &instance;
01428 }
01429
01430 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const XTEB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01431 }
01432
01433 namespace ROOT {
01434 void XTRB_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01435 TClass *XTRB_IsA(const void*);
01436 void *new_XTRB(void *p = 0);
01437 void *newArray_XTRB(Long_t size);
01438 void delete_XTRB(void *p);
01439 void deleteArray_XTRB(void *p);
01440 void destruct_XTRB(void *p);
01441
01442
01443 TGenericClassInfo *GenerateInitInstance(const XTRB*)
01444 {
01445 XTRB *ptr = 0;
01446 static ROOT::TGenericClassInfo
01447 instance("XTRB", XTRB::Class_Version(), "BankClasses.h", 973,
01448 typeid(XTRB), DefineBehavior(ptr, ptr),
01449 &::XTRB::Dictionary, &XTRB_IsA, 4);
01450 instance.SetNew(&new_XTRB);
01451 instance.SetNewArray(&newArray_XTRB);
01452 instance.SetDelete(&delete_XTRB);
01453 instance.SetDeleteArray(&deleteArray_XTRB);
01454 instance.SetDestructor(&destruct_XTRB);
01455 return &instance;
01456 }
01457
01458 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const XTRB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01459 }
01460
01461 namespace ROOT {
01462 void DTBP_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01463 TClass *DTBP_IsA(const void*);
01464 void *new_DTBP(void *p = 0);
01465 void *newArray_DTBP(Long_t size);
01466 void delete_DTBP(void *p);
01467 void deleteArray_DTBP(void *p);
01468 void destruct_DTBP(void *p);
01469
01470
01471 TGenericClassInfo *GenerateInitInstance(const DTBP*)
01472 {
01473 DTBP *ptr = 0;
01474 static ROOT::TGenericClassInfo
01475 instance("DTBP", DTBP::Class_Version(), "BankClasses.h", 984,
01476 typeid(DTBP), DefineBehavior(ptr, ptr),
01477 &::DTBP::Dictionary, &DTBP_IsA, 4);
01478 instance.SetNew(&new_DTBP);
01479 instance.SetNewArray(&newArray_DTBP);
01480 instance.SetDelete(&delete_DTBP);
01481 instance.SetDeleteArray(&deleteArray_DTBP);
01482 instance.SetDestructor(&destruct_DTBP);
01483 return &instance;
01484 }
01485
01486 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const DTBP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01487 }
01488
01489 namespace ROOT {
01490 void VHBV_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01491 TClass *VHBV_IsA(const void*);
01492 void *new_VHBV(void *p = 0);
01493 void *newArray_VHBV(Long_t size);
01494 void delete_VHBV(void *p);
01495 void deleteArray_VHBV(void *p);
01496 void destruct_VHBV(void *p);
01497
01498
01499 TGenericClassInfo *GenerateInitInstance(const VHBV*)
01500 {
01501 VHBV *ptr = 0;
01502 static ROOT::TGenericClassInfo
01503 instance("VHBV", VHBV::Class_Version(), "BankClasses.h", 996,
01504 typeid(VHBV), DefineBehavior(ptr, ptr),
01505 &::VHBV::Dictionary, &VHBV_IsA, 4);
01506 instance.SetNew(&new_VHBV);
01507 instance.SetNewArray(&newArray_VHBV);
01508 instance.SetDelete(&delete_VHBV);
01509 instance.SetDeleteArray(&deleteArray_VHBV);
01510 instance.SetDestructor(&destruct_VHBV);
01511 return &instance;
01512 }
01513
01514 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const VHBV*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01515 }
01516
01517 namespace ROOT {
01518 void VHPV_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01519 TClass *VHPV_IsA(const void*);
01520 void *new_VHPV(void *p = 0);
01521 void *newArray_VHPV(Long_t size);
01522 void delete_VHPV(void *p);
01523 void deleteArray_VHPV(void *p);
01524 void destruct_VHPV(void *p);
01525
01526
01527 TGenericClassInfo *GenerateInitInstance(const VHPV*)
01528 {
01529 VHPV *ptr = 0;
01530 static ROOT::TGenericClassInfo
01531 instance("VHPV", VHPV::Class_Version(), "BankClasses.h", 1008,
01532 typeid(VHPV), DefineBehavior(ptr, ptr),
01533 &::VHPV::Dictionary, &VHPV_IsA, 4);
01534 instance.SetNew(&new_VHPV);
01535 instance.SetNewArray(&newArray_VHPV);
01536 instance.SetDelete(&delete_VHPV);
01537 instance.SetDeleteArray(&deleteArray_VHPV);
01538 instance.SetDestructor(&destruct_VHPV);
01539 return &instance;
01540 }
01541
01542 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const VHPV*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01543 }
01544
01545 namespace ROOT {
01546 void EAUX_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01547 TClass *EAUX_IsA(const void*);
01548 void *new_EAUX(void *p = 0);
01549 void *newArray_EAUX(Long_t size);
01550 void delete_EAUX(void *p);
01551 void deleteArray_EAUX(void *p);
01552 void destruct_EAUX(void *p);
01553
01554
01555 TGenericClassInfo *GenerateInitInstance(const EAUX*)
01556 {
01557 EAUX *ptr = 0;
01558 static ROOT::TGenericClassInfo
01559 instance("EAUX", EAUX::Class_Version(), "BankClasses.h", 1019,
01560 typeid(EAUX), DefineBehavior(ptr, ptr),
01561 &::EAUX::Dictionary, &EAUX_IsA, 4);
01562 instance.SetNew(&new_EAUX);
01563 instance.SetNewArray(&newArray_EAUX);
01564 instance.SetDelete(&delete_EAUX);
01565 instance.SetDeleteArray(&deleteArray_EAUX);
01566 instance.SetDestructor(&destruct_EAUX);
01567 return &instance;
01568 }
01569
01570 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const EAUX*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01571 }
01572
01573 namespace ROOT {
01574 void SIX2_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01575 TClass *SIX2_IsA(const void*);
01576 void *new_SIX2(void *p = 0);
01577 void *newArray_SIX2(Long_t size);
01578 void delete_SIX2(void *p);
01579 void deleteArray_SIX2(void *p);
01580 void destruct_SIX2(void *p);
01581
01582
01583 TGenericClassInfo *GenerateInitInstance(const SIX2*)
01584 {
01585 SIX2 *ptr = 0;
01586 static ROOT::TGenericClassInfo
01587 instance("SIX2", SIX2::Class_Version(), "BankClasses.h", 1034,
01588 typeid(SIX2), DefineBehavior(ptr, ptr),
01589 &::SIX2::Dictionary, &SIX2_IsA, 4);
01590 instance.SetNew(&new_SIX2);
01591 instance.SetNewArray(&newArray_SIX2);
01592 instance.SetDelete(&delete_SIX2);
01593 instance.SetDeleteArray(&deleteArray_SIX2);
01594 instance.SetDestructor(&destruct_SIX2);
01595 return &instance;
01596 }
01597
01598 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const SIX2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01599 }
01600
01601 namespace ROOT {
01602 void X1TV_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01603 TClass *X1TV_IsA(const void*);
01604 void *new_X1TV(void *p = 0);
01605 void *newArray_X1TV(Long_t size);
01606 void delete_X1TV(void *p);
01607 void deleteArray_X1TV(void *p);
01608 void destruct_X1TV(void *p);
01609
01610
01611 TGenericClassInfo *GenerateInitInstance(const X1TV*)
01612 {
01613 X1TV *ptr = 0;
01614 static ROOT::TGenericClassInfo
01615 instance("X1TV", X1TV::Class_Version(), "BankClasses.h", 1044,
01616 typeid(X1TV), DefineBehavior(ptr, ptr),
01617 &::X1TV::Dictionary, &X1TV_IsA, 4);
01618 instance.SetNew(&new_X1TV);
01619 instance.SetNewArray(&newArray_X1TV);
01620 instance.SetDelete(&delete_X1TV);
01621 instance.SetDeleteArray(&deleteArray_X1TV);
01622 instance.SetDestructor(&destruct_X1TV);
01623 return &instance;
01624 }
01625
01626 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const X1TV*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01627 }
01628
01629 namespace ROOT {
01630 void KWGT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01631 TClass *KWGT_IsA(const void*);
01632 void *new_KWGT(void *p = 0);
01633 void *newArray_KWGT(Long_t size);
01634 void delete_KWGT(void *p);
01635 void deleteArray_KWGT(void *p);
01636 void destruct_KWGT(void *p);
01637
01638
01639 TGenericClassInfo *GenerateInitInstance(const KWGT*)
01640 {
01641 KWGT *ptr = 0;
01642 static ROOT::TGenericClassInfo
01643 instance("KWGT", KWGT::Class_Version(), "BankClasses.h", 1055,
01644 typeid(KWGT), DefineBehavior(ptr, ptr),
01645 &::KWGT::Dictionary, &KWGT_IsA, 4);
01646 instance.SetNew(&new_KWGT);
01647 instance.SetNewArray(&newArray_KWGT);
01648 instance.SetDelete(&delete_KWGT);
01649 instance.SetDeleteArray(&deleteArray_KWGT);
01650 instance.SetDestructor(&destruct_KWGT);
01651 return &instance;
01652 }
01653
01654 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const KWGT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01655 }
01656
01657 namespace ROOT {
01658 void X1IP_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01659 TClass *X1IP_IsA(const void*);
01660 void *new_X1IP(void *p = 0);
01661 void *newArray_X1IP(Long_t size);
01662 void delete_X1IP(void *p);
01663 void deleteArray_X1IP(void *p);
01664 void destruct_X1IP(void *p);
01665
01666
01667 TGenericClassInfo *GenerateInitInstance(const X1IP*)
01668 {
01669 X1IP *ptr = 0;
01670 static ROOT::TGenericClassInfo
01671 instance("X1IP", X1IP::Class_Version(), "BankClasses.h", 1067,
01672 typeid(X1IP), DefineBehavior(ptr, ptr),
01673 &::X1IP::Dictionary, &X1IP_IsA, 4);
01674 instance.SetNew(&new_X1IP);
01675 instance.SetNewArray(&newArray_X1IP);
01676 instance.SetDelete(&delete_X1IP);
01677 instance.SetDeleteArray(&deleteArray_X1IP);
01678 instance.SetDestructor(&destruct_X1IP);
01679 return &instance;
01680 }
01681
01682 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const X1IP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01683 }
01684
01685 namespace ROOT {
01686 void SIXA_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01687 TClass *SIXA_IsA(const void*);
01688 void *new_SIXA(void *p = 0);
01689 void *newArray_SIXA(Long_t size);
01690 void delete_SIXA(void *p);
01691 void deleteArray_SIXA(void *p);
01692 void destruct_SIXA(void *p);
01693
01694
01695 TGenericClassInfo *GenerateInitInstance(const SIXA*)
01696 {
01697 SIXA *ptr = 0;
01698 static ROOT::TGenericClassInfo
01699 instance("SIXA", SIXA::Class_Version(), "BankClasses.h", 1078,
01700 typeid(SIXA), DefineBehavior(ptr, ptr),
01701 &::SIXA::Dictionary, &SIXA_IsA, 4);
01702 instance.SetNew(&new_SIXA);
01703 instance.SetNewArray(&newArray_SIXA);
01704 instance.SetDelete(&delete_SIXA);
01705 instance.SetDeleteArray(&deleteArray_SIXA);
01706 instance.SetDestructor(&destruct_SIXA);
01707 return &instance;
01708 }
01709
01710 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const SIXA*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01711 }
01712
01713 namespace ROOT {
01714 void SITC_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01715 TClass *SITC_IsA(const void*);
01716 void *new_SITC(void *p = 0);
01717 void *newArray_SITC(Long_t size);
01718 void delete_SITC(void *p);
01719 void deleteArray_SITC(void *p);
01720 void destruct_SITC(void *p);
01721
01722
01723 TGenericClassInfo *GenerateInitInstance(const SITC*)
01724 {
01725 SITC *ptr = 0;
01726 static ROOT::TGenericClassInfo
01727 instance("SITC", SITC::Class_Version(), "BankClasses.h", 1089,
01728 typeid(SITC), DefineBehavior(ptr, ptr),
01729 &::SITC::Dictionary, &SITC_IsA, 4);
01730 instance.SetNew(&new_SITC);
01731 instance.SetNewArray(&newArray_SITC);
01732 instance.SetDelete(&delete_SITC);
01733 instance.SetDeleteArray(&deleteArray_SITC);
01734 instance.SetDestructor(&destruct_SITC);
01735 return &instance;
01736 }
01737
01738 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const SITC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01739 }
01740
01741 namespace ROOT {
01742 void SRCO_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01743 TClass *SRCO_IsA(const void*);
01744 void *new_SRCO(void *p = 0);
01745 void *newArray_SRCO(Long_t size);
01746 void delete_SRCO(void *p);
01747 void deleteArray_SRCO(void *p);
01748 void destruct_SRCO(void *p);
01749
01750
01751 TGenericClassInfo *GenerateInitInstance(const SRCO*)
01752 {
01753 SRCO *ptr = 0;
01754 static ROOT::TGenericClassInfo
01755 instance("SRCO", SRCO::Class_Version(), "BankClasses.h", 1101,
01756 typeid(SRCO), DefineBehavior(ptr, ptr),
01757 &::SRCO::Dictionary, &SRCO_IsA, 4);
01758 instance.SetNew(&new_SRCO);
01759 instance.SetNewArray(&newArray_SRCO);
01760 instance.SetDelete(&delete_SRCO);
01761 instance.SetDeleteArray(&deleteArray_SRCO);
01762 instance.SetDestructor(&destruct_SRCO);
01763 return &instance;
01764 }
01765
01766 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const SRCO*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01767 }
01768
01769 namespace ROOT {
01770 void X1TH_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01771 TClass *X1TH_IsA(const void*);
01772 void *new_X1TH(void *p = 0);
01773 void *newArray_X1TH(Long_t size);
01774 void delete_X1TH(void *p);
01775 void deleteArray_X1TH(void *p);
01776 void destruct_X1TH(void *p);
01777
01778
01779 TGenericClassInfo *GenerateInitInstance(const X1TH*)
01780 {
01781 X1TH *ptr = 0;
01782 static ROOT::TGenericClassInfo
01783 instance("X1TH", X1TH::Class_Version(), "BankClasses.h", 1112,
01784 typeid(X1TH), DefineBehavior(ptr, ptr),
01785 &::X1TH::Dictionary, &X1TH_IsA, 4);
01786 instance.SetNew(&new_X1TH);
01787 instance.SetNewArray(&newArray_X1TH);
01788 instance.SetDelete(&delete_X1TH);
01789 instance.SetDeleteArray(&deleteArray_X1TH);
01790 instance.SetDestructor(&destruct_X1TH);
01791 return &instance;
01792 }
01793
01794 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const X1TH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01795 }
01796
01797 namespace ROOT {
01798 void X1AD_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01799 TClass *X1AD_IsA(const void*);
01800 void *new_X1AD(void *p = 0);
01801 void *newArray_X1AD(Long_t size);
01802 void delete_X1AD(void *p);
01803 void deleteArray_X1AD(void *p);
01804 void destruct_X1AD(void *p);
01805
01806
01807 TGenericClassInfo *GenerateInitInstance(const X1AD*)
01808 {
01809 X1AD *ptr = 0;
01810 static ROOT::TGenericClassInfo
01811 instance("X1AD", X1AD::Class_Version(), "BankClasses.h", 1125,
01812 typeid(X1AD), DefineBehavior(ptr, ptr),
01813 &::X1AD::Dictionary, &X1AD_IsA, 4);
01814 instance.SetNew(&new_X1AD);
01815 instance.SetNewArray(&newArray_X1AD);
01816 instance.SetDelete(&delete_X1AD);
01817 instance.SetDeleteArray(&deleteArray_X1AD);
01818 instance.SetDestructor(&destruct_X1AD);
01819 return &instance;
01820 }
01821
01822 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const X1AD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01823 }
01824
01825 namespace ROOT {
01826 void QEXT_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01827 TClass *QEXT_IsA(const void*);
01828 void *new_QEXT(void *p = 0);
01829 void *newArray_QEXT(Long_t size);
01830 void delete_QEXT(void *p);
01831 void deleteArray_QEXT(void *p);
01832 void destruct_QEXT(void *p);
01833
01834
01835 TGenericClassInfo *GenerateInitInstance(const QEXT*)
01836 {
01837 QEXT *ptr = 0;
01838 static ROOT::TGenericClassInfo
01839 instance("QEXT", QEXT::Class_Version(), "BankClasses.h", 1136,
01840 typeid(QEXT), DefineBehavior(ptr, ptr),
01841 &::QEXT::Dictionary, &QEXT_IsA, 4);
01842 instance.SetNew(&new_QEXT);
01843 instance.SetNewArray(&newArray_QEXT);
01844 instance.SetDelete(&delete_QEXT);
01845 instance.SetDeleteArray(&deleteArray_QEXT);
01846 instance.SetDestructor(&destruct_QEXT);
01847 return &instance;
01848 }
01849
01850 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QEXT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01851 }
01852
01853 namespace ROOT {
01854 void QHAC_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
01855 TClass *QHAC_IsA(const void*);
01856 void *new_QHAC(void *p = 0);
01857 void *newArray_QHAC(Long_t size);
01858 void delete_QHAC(void *p);
01859 void deleteArray_QHAC(void *p);
01860 void destruct_QHAC(void *p);
01861
01862
01863 TGenericClassInfo *GenerateInitInstance(const QHAC*)
01864 {
01865 QHAC *ptr = 0;
01866 static ROOT::TGenericClassInfo
01867 instance("QHAC", QHAC::Class_Version(), "BankClasses.h", 1157,
01868 typeid(QHAC), DefineBehavior(ptr, ptr),
01869 &::QHAC::Dictionary, &QHAC_IsA, 4);
01870 instance.SetNew(&new_QHAC);
01871 instance.SetNewArray(&newArray_QHAC);
01872 instance.SetDelete(&delete_QHAC);
01873 instance.SetDeleteArray(&deleteArray_QHAC);
01874 instance.SetDestructor(&destruct_QHAC);
01875 return &instance;
01876 }
01877
01878 static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const QHAC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01879 }
01880
01881
01882 TClass *QLIN::fgIsA = 0;
01883
01884
01885 const char *QLIN::Class_Name()
01886 {
01887 return "QLIN";
01888 }
01889
01890
01891 const char *QLIN::ImplFileName()
01892 {
01893 return ROOT::GenerateInitInstance((const QLIN*)0x0)->GetImplFileName();
01894 }
01895
01896
01897 int QLIN::ImplFileLine()
01898 {
01899 return ROOT::GenerateInitInstance((const QLIN*)0x0)->GetImplFileLine();
01900 }
01901
01902
01903 void QLIN::Dictionary()
01904 {
01905 fgIsA = ROOT::GenerateInitInstance((const QLIN*)0x0)->GetClass();
01906 }
01907
01908
01909 TClass *QLIN::Class()
01910 {
01911 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QLIN*)0x0)->GetClass();
01912 return fgIsA;
01913 }
01914
01915
01916 TClass *QMTL::fgIsA = 0;
01917
01918
01919 const char *QMTL::Class_Name()
01920 {
01921 return "QMTL";
01922 }
01923
01924
01925 const char *QMTL::ImplFileName()
01926 {
01927 return ROOT::GenerateInitInstance((const QMTL*)0x0)->GetImplFileName();
01928 }
01929
01930
01931 int QMTL::ImplFileLine()
01932 {
01933 return ROOT::GenerateInitInstance((const QMTL*)0x0)->GetImplFileLine();
01934 }
01935
01936
01937 void QMTL::Dictionary()
01938 {
01939 fgIsA = ROOT::GenerateInitInstance((const QMTL*)0x0)->GetClass();
01940 }
01941
01942
01943 TClass *QMTL::Class()
01944 {
01945 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QMTL*)0x0)->GetClass();
01946 return fgIsA;
01947 }
01948
01949
01950 TClass *QMTS::fgIsA = 0;
01951
01952
01953 const char *QMTS::Class_Name()
01954 {
01955 return "QMTS";
01956 }
01957
01958
01959 const char *QMTS::ImplFileName()
01960 {
01961 return ROOT::GenerateInitInstance((const QMTS*)0x0)->GetImplFileName();
01962 }
01963
01964
01965 int QMTS::ImplFileLine()
01966 {
01967 return ROOT::GenerateInitInstance((const QMTS*)0x0)->GetImplFileLine();
01968 }
01969
01970
01971 void QMTS::Dictionary()
01972 {
01973 fgIsA = ROOT::GenerateInitInstance((const QMTS*)0x0)->GetClass();
01974 }
01975
01976
01977 TClass *QMTS::Class()
01978 {
01979 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QMTS*)0x0)->GetClass();
01980 return fgIsA;
01981 }
01982
01983
01984 TClass *FRFT::fgIsA = 0;
01985
01986
01987 const char *FRFT::Class_Name()
01988 {
01989 return "FRFT";
01990 }
01991
01992
01993 const char *FRFT::ImplFileName()
01994 {
01995 return ROOT::GenerateInitInstance((const FRFT*)0x0)->GetImplFileName();
01996 }
01997
01998
01999 int FRFT::ImplFileLine()
02000 {
02001 return ROOT::GenerateInitInstance((const FRFT*)0x0)->GetImplFileLine();
02002 }
02003
02004
02005 void FRFT::Dictionary()
02006 {
02007 fgIsA = ROOT::GenerateInitInstance((const FRFT*)0x0)->GetClass();
02008 }
02009
02010
02011 TClass *FRFT::Class()
02012 {
02013 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const FRFT*)0x0)->GetClass();
02014 return fgIsA;
02015 }
02016
02017
02018 TClass *FRTL::fgIsA = 0;
02019
02020
02021 const char *FRTL::Class_Name()
02022 {
02023 return "FRTL";
02024 }
02025
02026
02027 const char *FRTL::ImplFileName()
02028 {
02029 return ROOT::GenerateInitInstance((const FRTL*)0x0)->GetImplFileName();
02030 }
02031
02032
02033 int FRTL::ImplFileLine()
02034 {
02035 return ROOT::GenerateInitInstance((const FRTL*)0x0)->GetImplFileLine();
02036 }
02037
02038
02039 void FRTL::Dictionary()
02040 {
02041 fgIsA = ROOT::GenerateInitInstance((const FRTL*)0x0)->GetClass();
02042 }
02043
02044
02045 TClass *FRTL::Class()
02046 {
02047 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const FRTL*)0x0)->GetClass();
02048 return fgIsA;
02049 }
02050
02051
02052 TClass *TEXS::fgIsA = 0;
02053
02054
02055 const char *TEXS::Class_Name()
02056 {
02057 return "TEXS";
02058 }
02059
02060
02061 const char *TEXS::ImplFileName()
02062 {
02063 return ROOT::GenerateInitInstance((const TEXS*)0x0)->GetImplFileName();
02064 }
02065
02066
02067 int TEXS::ImplFileLine()
02068 {
02069 return ROOT::GenerateInitInstance((const TEXS*)0x0)->GetImplFileLine();
02070 }
02071
02072
02073 void TEXS::Dictionary()
02074 {
02075 fgIsA = ROOT::GenerateInitInstance((const TEXS*)0x0)->GetClass();
02076 }
02077
02078
02079 TClass *TEXS::Class()
02080 {
02081 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const TEXS*)0x0)->GetClass();
02082 return fgIsA;
02083 }
02084
02085
02086 TClass *HMAD::fgIsA = 0;
02087
02088
02089 const char *HMAD::Class_Name()
02090 {
02091 return "HMAD";
02092 }
02093
02094
02095 const char *HMAD::ImplFileName()
02096 {
02097 return ROOT::GenerateInitInstance((const HMAD*)0x0)->GetImplFileName();
02098 }
02099
02100
02101 int HMAD::ImplFileLine()
02102 {
02103 return ROOT::GenerateInitInstance((const HMAD*)0x0)->GetImplFileLine();
02104 }
02105
02106
02107 void HMAD::Dictionary()
02108 {
02109 fgIsA = ROOT::GenerateInitInstance((const HMAD*)0x0)->GetClass();
02110 }
02111
02112
02113 TClass *HMAD::Class()
02114 {
02115 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const HMAD*)0x0)->GetClass();
02116 return fgIsA;
02117 }
02118
02119
02120 TClass *MCAD::fgIsA = 0;
02121
02122
02123 const char *MCAD::Class_Name()
02124 {
02125 return "MCAD";
02126 }
02127
02128
02129 const char *MCAD::ImplFileName()
02130 {
02131 return ROOT::GenerateInitInstance((const MCAD*)0x0)->GetImplFileName();
02132 }
02133
02134
02135 int MCAD::ImplFileLine()
02136 {
02137 return ROOT::GenerateInitInstance((const MCAD*)0x0)->GetImplFileLine();
02138 }
02139
02140
02141 void MCAD::Dictionary()
02142 {
02143 fgIsA = ROOT::GenerateInitInstance((const MCAD*)0x0)->GetClass();
02144 }
02145
02146
02147 TClass *MCAD::Class()
02148 {
02149 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MCAD*)0x0)->GetClass();
02150 return fgIsA;
02151 }
02152
02153
02154 TClass *PECO::fgIsA = 0;
02155
02156
02157 const char *PECO::Class_Name()
02158 {
02159 return "PECO";
02160 }
02161
02162
02163 const char *PECO::ImplFileName()
02164 {
02165 return ROOT::GenerateInitInstance((const PECO*)0x0)->GetImplFileName();
02166 }
02167
02168
02169 int PECO::ImplFileLine()
02170 {
02171 return ROOT::GenerateInitInstance((const PECO*)0x0)->GetImplFileLine();
02172 }
02173
02174
02175 void PECO::Dictionary()
02176 {
02177 fgIsA = ROOT::GenerateInitInstance((const PECO*)0x0)->GetClass();
02178 }
02179
02180
02181 TClass *PECO::Class()
02182 {
02183 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PECO*)0x0)->GetClass();
02184 return fgIsA;
02185 }
02186
02187
02188 TClass *EIDT::fgIsA = 0;
02189
02190
02191 const char *EIDT::Class_Name()
02192 {
02193 return "EIDT";
02194 }
02195
02196
02197 const char *EIDT::ImplFileName()
02198 {
02199 return ROOT::GenerateInitInstance((const EIDT*)0x0)->GetImplFileName();
02200 }
02201
02202
02203 int EIDT::ImplFileLine()
02204 {
02205 return ROOT::GenerateInitInstance((const EIDT*)0x0)->GetImplFileLine();
02206 }
02207
02208
02209 void EIDT::Dictionary()
02210 {
02211 fgIsA = ROOT::GenerateInitInstance((const EIDT*)0x0)->GetClass();
02212 }
02213
02214
02215 TClass *EIDT::Class()
02216 {
02217 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const EIDT*)0x0)->GetClass();
02218 return fgIsA;
02219 }
02220
02221
02222 TClass *PHCO::fgIsA = 0;
02223
02224
02225 const char *PHCO::Class_Name()
02226 {
02227 return "PHCO";
02228 }
02229
02230
02231 const char *PHCO::ImplFileName()
02232 {
02233 return ROOT::GenerateInitInstance((const PHCO*)0x0)->GetImplFileName();
02234 }
02235
02236
02237 int PHCO::ImplFileLine()
02238 {
02239 return ROOT::GenerateInitInstance((const PHCO*)0x0)->GetImplFileLine();
02240 }
02241
02242
02243 void PHCO::Dictionary()
02244 {
02245 fgIsA = ROOT::GenerateInitInstance((const PHCO*)0x0)->GetClass();
02246 }
02247
02248
02249 TClass *PHCO::Class()
02250 {
02251 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PHCO*)0x0)->GetClass();
02252 return fgIsA;
02253 }
02254
02255
02256 TClass *PEPT::fgIsA = 0;
02257
02258
02259 const char *PEPT::Class_Name()
02260 {
02261 return "PEPT";
02262 }
02263
02264
02265 const char *PEPT::ImplFileName()
02266 {
02267 return ROOT::GenerateInitInstance((const PEPT*)0x0)->GetImplFileName();
02268 }
02269
02270
02271 int PEPT::ImplFileLine()
02272 {
02273 return ROOT::GenerateInitInstance((const PEPT*)0x0)->GetImplFileLine();
02274 }
02275
02276
02277 void PEPT::Dictionary()
02278 {
02279 fgIsA = ROOT::GenerateInitInstance((const PEPT*)0x0)->GetClass();
02280 }
02281
02282
02283 TClass *PEPT::Class()
02284 {
02285 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PEPT*)0x0)->GetClass();
02286 return fgIsA;
02287 }
02288
02289
02290 TClass *FRID::fgIsA = 0;
02291
02292
02293 const char *FRID::Class_Name()
02294 {
02295 return "FRID";
02296 }
02297
02298
02299 const char *FRID::ImplFileName()
02300 {
02301 return ROOT::GenerateInitInstance((const FRID*)0x0)->GetImplFileName();
02302 }
02303
02304
02305 int FRID::ImplFileLine()
02306 {
02307 return ROOT::GenerateInitInstance((const FRID*)0x0)->GetImplFileLine();
02308 }
02309
02310
02311 void FRID::Dictionary()
02312 {
02313 fgIsA = ROOT::GenerateInitInstance((const FRID*)0x0)->GetClass();
02314 }
02315
02316
02317 TClass *FRID::Class()
02318 {
02319 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const FRID*)0x0)->GetClass();
02320 return fgIsA;
02321 }
02322
02323
02324 TClass *EFOL::fgIsA = 0;
02325
02326
02327 const char *EFOL::Class_Name()
02328 {
02329 return "EFOL";
02330 }
02331
02332
02333 const char *EFOL::ImplFileName()
02334 {
02335 return ROOT::GenerateInitInstance((const EFOL*)0x0)->GetImplFileName();
02336 }
02337
02338
02339 int EFOL::ImplFileLine()
02340 {
02341 return ROOT::GenerateInitInstance((const EFOL*)0x0)->GetImplFileLine();
02342 }
02343
02344
02345 void EFOL::Dictionary()
02346 {
02347 fgIsA = ROOT::GenerateInitInstance((const EFOL*)0x0)->GetClass();
02348 }
02349
02350
02351 TClass *EFOL::Class()
02352 {
02353 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const EFOL*)0x0)->GetClass();
02354 return fgIsA;
02355 }
02356
02357
02358 TClass *PCQA::fgIsA = 0;
02359
02360
02361 const char *PCQA::Class_Name()
02362 {
02363 return "PCQA";
02364 }
02365
02366
02367 const char *PCQA::ImplFileName()
02368 {
02369 return ROOT::GenerateInitInstance((const PCQA*)0x0)->GetImplFileName();
02370 }
02371
02372
02373 int PCQA::ImplFileLine()
02374 {
02375 return ROOT::GenerateInitInstance((const PCQA*)0x0)->GetImplFileLine();
02376 }
02377
02378
02379 void PCQA::Dictionary()
02380 {
02381 fgIsA = ROOT::GenerateInitInstance((const PCQA*)0x0)->GetClass();
02382 }
02383
02384
02385 TClass *PCQA::Class()
02386 {
02387 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PCQA*)0x0)->GetClass();
02388 return fgIsA;
02389 }
02390
02391
02392 TClass *EGPC::fgIsA = 0;
02393
02394
02395 const char *EGPC::Class_Name()
02396 {
02397 return "EGPC";
02398 }
02399
02400
02401 const char *EGPC::ImplFileName()
02402 {
02403 return ROOT::GenerateInitInstance((const EGPC*)0x0)->GetImplFileName();
02404 }
02405
02406
02407 int EGPC::ImplFileLine()
02408 {
02409 return ROOT::GenerateInitInstance((const EGPC*)0x0)->GetImplFileLine();
02410 }
02411
02412
02413 void EGPC::Dictionary()
02414 {
02415 fgIsA = ROOT::GenerateInitInstance((const EGPC*)0x0)->GetClass();
02416 }
02417
02418
02419 TClass *EGPC::Class()
02420 {
02421 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const EGPC*)0x0)->GetClass();
02422 return fgIsA;
02423 }
02424
02425
02426 TClass *MUID::fgIsA = 0;
02427
02428
02429 const char *MUID::Class_Name()
02430 {
02431 return "MUID";
02432 }
02433
02434
02435 const char *MUID::ImplFileName()
02436 {
02437 return ROOT::GenerateInitInstance((const MUID*)0x0)->GetImplFileName();
02438 }
02439
02440
02441 int MUID::ImplFileLine()
02442 {
02443 return ROOT::GenerateInitInstance((const MUID*)0x0)->GetImplFileLine();
02444 }
02445
02446
02447 void MUID::Dictionary()
02448 {
02449 fgIsA = ROOT::GenerateInitInstance((const MUID*)0x0)->GetClass();
02450 }
02451
02452
02453 TClass *MUID::Class()
02454 {
02455 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MUID*)0x0)->GetClass();
02456 return fgIsA;
02457 }
02458
02459
02460 TClass *PGPC::fgIsA = 0;
02461
02462
02463 const char *PGPC::Class_Name()
02464 {
02465 return "PGPC";
02466 }
02467
02468
02469 const char *PGPC::ImplFileName()
02470 {
02471 return ROOT::GenerateInitInstance((const PGPC*)0x0)->GetImplFileName();
02472 }
02473
02474
02475 int PGPC::ImplFileLine()
02476 {
02477 return ROOT::GenerateInitInstance((const PGPC*)0x0)->GetImplFileLine();
02478 }
02479
02480
02481 void PGPC::Dictionary()
02482 {
02483 fgIsA = ROOT::GenerateInitInstance((const PGPC*)0x0)->GetClass();
02484 }
02485
02486
02487 TClass *PGPC::Class()
02488 {
02489 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PGPC*)0x0)->GetClass();
02490 return fgIsA;
02491 }
02492
02493
02494 TClass *PGAC::fgIsA = 0;
02495
02496
02497 const char *PGAC::Class_Name()
02498 {
02499 return "PGAC";
02500 }
02501
02502
02503 const char *PGAC::ImplFileName()
02504 {
02505 return ROOT::GenerateInitInstance((const PGAC*)0x0)->GetImplFileName();
02506 }
02507
02508
02509 int PGAC::ImplFileLine()
02510 {
02511 return ROOT::GenerateInitInstance((const PGAC*)0x0)->GetImplFileLine();
02512 }
02513
02514
02515 void PGAC::Dictionary()
02516 {
02517 fgIsA = ROOT::GenerateInitInstance((const PGAC*)0x0)->GetClass();
02518 }
02519
02520
02521 TClass *PGAC::Class()
02522 {
02523 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PGAC*)0x0)->GetClass();
02524 return fgIsA;
02525 }
02526
02527
02528 TClass *PDLT::fgIsA = 0;
02529
02530
02531 const char *PDLT::Class_Name()
02532 {
02533 return "PDLT";
02534 }
02535
02536
02537 const char *PDLT::ImplFileName()
02538 {
02539 return ROOT::GenerateInitInstance((const PDLT*)0x0)->GetImplFileName();
02540 }
02541
02542
02543 int PDLT::ImplFileLine()
02544 {
02545 return ROOT::GenerateInitInstance((const PDLT*)0x0)->GetImplFileLine();
02546 }
02547
02548
02549 void PDLT::Dictionary()
02550 {
02551 fgIsA = ROOT::GenerateInitInstance((const PDLT*)0x0)->GetClass();
02552 }
02553
02554
02555 TClass *PDLT::Class()
02556 {
02557 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PDLT*)0x0)->GetClass();
02558 return fgIsA;
02559 }
02560
02561
02562 TClass *PMLT::fgIsA = 0;
02563
02564
02565 const char *PMLT::Class_Name()
02566 {
02567 return "PMLT";
02568 }
02569
02570
02571 const char *PMLT::ImplFileName()
02572 {
02573 return ROOT::GenerateInitInstance((const PMLT*)0x0)->GetImplFileName();
02574 }
02575
02576
02577 int PMLT::ImplFileLine()
02578 {
02579 return ROOT::GenerateInitInstance((const PMLT*)0x0)->GetImplFileLine();
02580 }
02581
02582
02583 void PMLT::Dictionary()
02584 {
02585 fgIsA = ROOT::GenerateInitInstance((const PMLT*)0x0)->GetClass();
02586 }
02587
02588
02589 TClass *PMLT::Class()
02590 {
02591 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const PMLT*)0x0)->GetClass();
02592 return fgIsA;
02593 }
02594
02595
02596 TClass *QDET::fgIsA = 0;
02597
02598
02599 const char *QDET::Class_Name()
02600 {
02601 return "QDET";
02602 }
02603
02604
02605 const char *QDET::ImplFileName()
02606 {
02607 return ROOT::GenerateInitInstance((const QDET*)0x0)->GetImplFileName();
02608 }
02609
02610
02611 int QDET::ImplFileLine()
02612 {
02613 return ROOT::GenerateInitInstance((const QDET*)0x0)->GetImplFileLine();
02614 }
02615
02616
02617 void QDET::Dictionary()
02618 {
02619 fgIsA = ROOT::GenerateInitInstance((const QDET*)0x0)->GetClass();
02620 }
02621
02622
02623 TClass *QDET::Class()
02624 {
02625 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QDET*)0x0)->GetClass();
02626 return fgIsA;
02627 }
02628
02629
02630 TClass *QVEC::fgIsA = 0;
02631
02632
02633 const char *QVEC::Class_Name()
02634 {
02635 return "QVEC";
02636 }
02637
02638
02639 const char *QVEC::ImplFileName()
02640 {
02641 return ROOT::GenerateInitInstance((const QVEC*)0x0)->GetImplFileName();
02642 }
02643
02644
02645 int QVEC::ImplFileLine()
02646 {
02647 return ROOT::GenerateInitInstance((const QVEC*)0x0)->GetImplFileLine();
02648 }
02649
02650
02651 void QVEC::Dictionary()
02652 {
02653 fgIsA = ROOT::GenerateInitInstance((const QVEC*)0x0)->GetClass();
02654 }
02655
02656
02657 TClass *QVEC::Class()
02658 {
02659 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QVEC*)0x0)->GetClass();
02660 return fgIsA;
02661 }
02662
02663
02664 TClass *YV0V::fgIsA = 0;
02665
02666
02667 const char *YV0V::Class_Name()
02668 {
02669 return "YV0V";
02670 }
02671
02672
02673 const char *YV0V::ImplFileName()
02674 {
02675 return ROOT::GenerateInitInstance((const YV0V*)0x0)->GetImplFileName();
02676 }
02677
02678
02679 int YV0V::ImplFileLine()
02680 {
02681 return ROOT::GenerateInitInstance((const YV0V*)0x0)->GetImplFileLine();
02682 }
02683
02684
02685 void YV0V::Dictionary()
02686 {
02687 fgIsA = ROOT::GenerateInitInstance((const YV0V*)0x0)->GetClass();
02688 }
02689
02690
02691 TClass *YV0V::Class()
02692 {
02693 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const YV0V*)0x0)->GetClass();
02694 return fgIsA;
02695 }
02696
02697
02698 TClass *FKIN::fgIsA = 0;
02699
02700
02701 const char *FKIN::Class_Name()
02702 {
02703 return "FKIN";
02704 }
02705
02706
02707 const char *FKIN::ImplFileName()
02708 {
02709 return ROOT::GenerateInitInstance((const FKIN*)0x0)->GetImplFileName();
02710 }
02711
02712
02713 int FKIN::ImplFileLine()
02714 {
02715 return ROOT::GenerateInitInstance((const FKIN*)0x0)->GetImplFileLine();
02716 }
02717
02718
02719 void FKIN::Dictionary()
02720 {
02721 fgIsA = ROOT::GenerateInitInstance((const FKIN*)0x0)->GetClass();
02722 }
02723
02724
02725 TClass *FKIN::Class()
02726 {
02727 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const FKIN*)0x0)->GetClass();
02728 return fgIsA;
02729 }
02730
02731
02732 TClass *FVER::fgIsA = 0;
02733
02734
02735 const char *FVER::Class_Name()
02736 {
02737 return "FVER";
02738 }
02739
02740
02741 const char *FVER::ImplFileName()
02742 {
02743 return ROOT::GenerateInitInstance((const FVER*)0x0)->GetImplFileName();
02744 }
02745
02746
02747 int FVER::ImplFileLine()
02748 {
02749 return ROOT::GenerateInitInstance((const FVER*)0x0)->GetImplFileLine();
02750 }
02751
02752
02753 void FVER::Dictionary()
02754 {
02755 fgIsA = ROOT::GenerateInitInstance((const FVER*)0x0)->GetClass();
02756 }
02757
02758
02759 TClass *FVER::Class()
02760 {
02761 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const FVER*)0x0)->GetClass();
02762 return fgIsA;
02763 }
02764
02765
02766 TClass *QVRT::fgIsA = 0;
02767
02768
02769 const char *QVRT::Class_Name()
02770 {
02771 return "QVRT";
02772 }
02773
02774
02775 const char *QVRT::ImplFileName()
02776 {
02777 return ROOT::GenerateInitInstance((const QVRT*)0x0)->GetImplFileName();
02778 }
02779
02780
02781 int QVRT::ImplFileLine()
02782 {
02783 return ROOT::GenerateInitInstance((const QVRT*)0x0)->GetImplFileLine();
02784 }
02785
02786
02787 void QVRT::Dictionary()
02788 {
02789 fgIsA = ROOT::GenerateInitInstance((const QVRT*)0x0)->GetClass();
02790 }
02791
02792
02793 TClass *QVRT::Class()
02794 {
02795 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QVRT*)0x0)->GetClass();
02796 return fgIsA;
02797 }
02798
02799
02800 TClass *ALPB::fgIsA = 0;
02801
02802
02803 const char *ALPB::Class_Name()
02804 {
02805 return "ALPB";
02806 }
02807
02808
02809 const char *ALPB::ImplFileName()
02810 {
02811 return ROOT::GenerateInitInstance((const ALPB*)0x0)->GetImplFileName();
02812 }
02813
02814
02815 int ALPB::ImplFileLine()
02816 {
02817 return ROOT::GenerateInitInstance((const ALPB*)0x0)->GetImplFileLine();
02818 }
02819
02820
02821 void ALPB::Dictionary()
02822 {
02823 fgIsA = ROOT::GenerateInitInstance((const ALPB*)0x0)->GetClass();
02824 }
02825
02826
02827 TClass *ALPB::Class()
02828 {
02829 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const ALPB*)0x0)->GetClass();
02830 return fgIsA;
02831 }
02832
02833
02834 TClass *ALRP::fgIsA = 0;
02835
02836
02837 const char *ALRP::Class_Name()
02838 {
02839 return "ALRP";
02840 }
02841
02842
02843 const char *ALRP::ImplFileName()
02844 {
02845 return ROOT::GenerateInitInstance((const ALRP*)0x0)->GetImplFileName();
02846 }
02847
02848
02849 int ALRP::ImplFileLine()
02850 {
02851 return ROOT::GenerateInitInstance((const ALRP*)0x0)->GetImplFileLine();
02852 }
02853
02854
02855 void ALRP::Dictionary()
02856 {
02857 fgIsA = ROOT::GenerateInitInstance((const ALRP*)0x0)->GetClass();
02858 }
02859
02860
02861 TClass *ALRP::Class()
02862 {
02863 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const ALRP*)0x0)->GetClass();
02864 return fgIsA;
02865 }
02866
02867
02868 TClass *RNL2::fgIsA = 0;
02869
02870
02871 const char *RNL2::Class_Name()
02872 {
02873 return "RNL2";
02874 }
02875
02876
02877 const char *RNL2::ImplFileName()
02878 {
02879 return ROOT::GenerateInitInstance((const RNL2*)0x0)->GetImplFileName();
02880 }
02881
02882
02883 int RNL2::ImplFileLine()
02884 {
02885 return ROOT::GenerateInitInstance((const RNL2*)0x0)->GetImplFileLine();
02886 }
02887
02888
02889 void RNL2::Dictionary()
02890 {
02891 fgIsA = ROOT::GenerateInitInstance((const RNL2*)0x0)->GetClass();
02892 }
02893
02894
02895 TClass *RNL2::Class()
02896 {
02897 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const RNL2*)0x0)->GetClass();
02898 return fgIsA;
02899 }
02900
02901
02902 TClass *RNF2::fgIsA = 0;
02903
02904
02905 const char *RNF2::Class_Name()
02906 {
02907 return "RNF2";
02908 }
02909
02910
02911 const char *RNF2::ImplFileName()
02912 {
02913 return ROOT::GenerateInitInstance((const RNF2*)0x0)->GetImplFileName();
02914 }
02915
02916
02917 int RNF2::ImplFileLine()
02918 {
02919 return ROOT::GenerateInitInstance((const RNF2*)0x0)->GetImplFileLine();
02920 }
02921
02922
02923 void RNF2::Dictionary()
02924 {
02925 fgIsA = ROOT::GenerateInitInstance((const RNF2*)0x0)->GetClass();
02926 }
02927
02928
02929 TClass *RNF2::Class()
02930 {
02931 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const RNF2*)0x0)->GetClass();
02932 return fgIsA;
02933 }
02934
02935
02936 TClass *RNR2::fgIsA = 0;
02937
02938
02939 const char *RNR2::Class_Name()
02940 {
02941 return "RNR2";
02942 }
02943
02944
02945 const char *RNR2::ImplFileName()
02946 {
02947 return ROOT::GenerateInitInstance((const RNR2*)0x0)->GetImplFileName();
02948 }
02949
02950
02951 int RNR2::ImplFileLine()
02952 {
02953 return ROOT::GenerateInitInstance((const RNR2*)0x0)->GetImplFileLine();
02954 }
02955
02956
02957 void RNR2::Dictionary()
02958 {
02959 fgIsA = ROOT::GenerateInitInstance((const RNR2*)0x0)->GetClass();
02960 }
02961
02962
02963 TClass *RNR2::Class()
02964 {
02965 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const RNR2*)0x0)->GetClass();
02966 return fgIsA;
02967 }
02968
02969
02970 TClass *RLEP::fgIsA = 0;
02971
02972
02973 const char *RLEP::Class_Name()
02974 {
02975 return "RLEP";
02976 }
02977
02978
02979 const char *RLEP::ImplFileName()
02980 {
02981 return ROOT::GenerateInitInstance((const RLEP*)0x0)->GetImplFileName();
02982 }
02983
02984
02985 int RLEP::ImplFileLine()
02986 {
02987 return ROOT::GenerateInitInstance((const RLEP*)0x0)->GetImplFileLine();
02988 }
02989
02990
02991 void RLEP::Dictionary()
02992 {
02993 fgIsA = ROOT::GenerateInitInstance((const RLEP*)0x0)->GetClass();
02994 }
02995
02996
02997 TClass *RLEP::Class()
02998 {
02999 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const RLEP*)0x0)->GetClass();
03000 return fgIsA;
03001 }
03002
03003
03004 TClass *LFIL::fgIsA = 0;
03005
03006
03007 const char *LFIL::Class_Name()
03008 {
03009 return "LFIL";
03010 }
03011
03012
03013 const char *LFIL::ImplFileName()
03014 {
03015 return ROOT::GenerateInitInstance((const LFIL*)0x0)->GetImplFileName();
03016 }
03017
03018
03019 int LFIL::ImplFileLine()
03020 {
03021 return ROOT::GenerateInitInstance((const LFIL*)0x0)->GetImplFileLine();
03022 }
03023
03024
03025 void LFIL::Dictionary()
03026 {
03027 fgIsA = ROOT::GenerateInitInstance((const LFIL*)0x0)->GetClass();
03028 }
03029
03030
03031 TClass *LFIL::Class()
03032 {
03033 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const LFIL*)0x0)->GetClass();
03034 return fgIsA;
03035 }
03036
03037
03038 TClass *EVEH::fgIsA = 0;
03039
03040
03041 const char *EVEH::Class_Name()
03042 {
03043 return "EVEH";
03044 }
03045
03046
03047 const char *EVEH::ImplFileName()
03048 {
03049 return ROOT::GenerateInitInstance((const EVEH*)0x0)->GetImplFileName();
03050 }
03051
03052
03053 int EVEH::ImplFileLine()
03054 {
03055 return ROOT::GenerateInitInstance((const EVEH*)0x0)->GetImplFileLine();
03056 }
03057
03058
03059 void EVEH::Dictionary()
03060 {
03061 fgIsA = ROOT::GenerateInitInstance((const EVEH*)0x0)->GetClass();
03062 }
03063
03064
03065 TClass *EVEH::Class()
03066 {
03067 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const EVEH*)0x0)->GetClass();
03068 return fgIsA;
03069 }
03070
03071
03072 TClass *KEVH::fgIsA = 0;
03073
03074
03075 const char *KEVH::Class_Name()
03076 {
03077 return "KEVH";
03078 }
03079
03080
03081 const char *KEVH::ImplFileName()
03082 {
03083 return ROOT::GenerateInitInstance((const KEVH*)0x0)->GetImplFileName();
03084 }
03085
03086
03087 int KEVH::ImplFileLine()
03088 {
03089 return ROOT::GenerateInitInstance((const KEVH*)0x0)->GetImplFileLine();
03090 }
03091
03092
03093 void KEVH::Dictionary()
03094 {
03095 fgIsA = ROOT::GenerateInitInstance((const KEVH*)0x0)->GetClass();
03096 }
03097
03098
03099 TClass *KEVH::Class()
03100 {
03101 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const KEVH*)0x0)->GetClass();
03102 return fgIsA;
03103 }
03104
03105
03106 TClass *REVH::fgIsA = 0;
03107
03108
03109 const char *REVH::Class_Name()
03110 {
03111 return "REVH";
03112 }
03113
03114
03115 const char *REVH::ImplFileName()
03116 {
03117 return ROOT::GenerateInitInstance((const REVH*)0x0)->GetImplFileName();
03118 }
03119
03120
03121 int REVH::ImplFileLine()
03122 {
03123 return ROOT::GenerateInitInstance((const REVH*)0x0)->GetImplFileLine();
03124 }
03125
03126
03127 void REVH::Dictionary()
03128 {
03129 fgIsA = ROOT::GenerateInitInstance((const REVH*)0x0)->GetClass();
03130 }
03131
03132
03133 TClass *REVH::Class()
03134 {
03135 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const REVH*)0x0)->GetClass();
03136 return fgIsA;
03137 }
03138
03139
03140 TClass *LOLE::fgIsA = 0;
03141
03142
03143 const char *LOLE::Class_Name()
03144 {
03145 return "LOLE";
03146 }
03147
03148
03149 const char *LOLE::ImplFileName()
03150 {
03151 return ROOT::GenerateInitInstance((const LOLE*)0x0)->GetImplFileName();
03152 }
03153
03154
03155 int LOLE::ImplFileLine()
03156 {
03157 return ROOT::GenerateInitInstance((const LOLE*)0x0)->GetImplFileLine();
03158 }
03159
03160
03161 void LOLE::Dictionary()
03162 {
03163 fgIsA = ROOT::GenerateInitInstance((const LOLE*)0x0)->GetClass();
03164 }
03165
03166
03167 TClass *LOLE::Class()
03168 {
03169 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const LOLE*)0x0)->GetClass();
03170 return fgIsA;
03171 }
03172
03173
03174 TClass *X1RG::fgIsA = 0;
03175
03176
03177 const char *X1RG::Class_Name()
03178 {
03179 return "X1RG";
03180 }
03181
03182
03183 const char *X1RG::ImplFileName()
03184 {
03185 return ROOT::GenerateInitInstance((const X1RG*)0x0)->GetImplFileName();
03186 }
03187
03188
03189 int X1RG::ImplFileLine()
03190 {
03191 return ROOT::GenerateInitInstance((const X1RG*)0x0)->GetImplFileLine();
03192 }
03193
03194
03195 void X1RG::Dictionary()
03196 {
03197 fgIsA = ROOT::GenerateInitInstance((const X1RG*)0x0)->GetClass();
03198 }
03199
03200
03201 TClass *X1RG::Class()
03202 {
03203 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const X1RG*)0x0)->GetClass();
03204 return fgIsA;
03205 }
03206
03207
03208 TClass *BOMB::fgIsA = 0;
03209
03210
03211 const char *BOMB::Class_Name()
03212 {
03213 return "BOMB";
03214 }
03215
03216
03217 const char *BOMB::ImplFileName()
03218 {
03219 return ROOT::GenerateInitInstance((const BOMB*)0x0)->GetImplFileName();
03220 }
03221
03222
03223 int BOMB::ImplFileLine()
03224 {
03225 return ROOT::GenerateInitInstance((const BOMB*)0x0)->GetImplFileLine();
03226 }
03227
03228
03229 void BOMB::Dictionary()
03230 {
03231 fgIsA = ROOT::GenerateInitInstance((const BOMB*)0x0)->GetClass();
03232 }
03233
03234
03235 TClass *BOMB::Class()
03236 {
03237 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const BOMB*)0x0)->GetClass();
03238 return fgIsA;
03239 }
03240
03241
03242 TClass *RUNH::fgIsA = 0;
03243
03244
03245 const char *RUNH::Class_Name()
03246 {
03247 return "RUNH";
03248 }
03249
03250
03251 const char *RUNH::ImplFileName()
03252 {
03253 return ROOT::GenerateInitInstance((const RUNH*)0x0)->GetImplFileName();
03254 }
03255
03256
03257 int RUNH::ImplFileLine()
03258 {
03259 return ROOT::GenerateInitInstance((const RUNH*)0x0)->GetImplFileLine();
03260 }
03261
03262
03263 void RUNH::Dictionary()
03264 {
03265 fgIsA = ROOT::GenerateInitInstance((const RUNH*)0x0)->GetClass();
03266 }
03267
03268
03269 TClass *RUNH::Class()
03270 {
03271 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const RUNH*)0x0)->GetClass();
03272 return fgIsA;
03273 }
03274
03275
03276 TClass *ASIM::fgIsA = 0;
03277
03278
03279 const char *ASIM::Class_Name()
03280 {
03281 return "ASIM";
03282 }
03283
03284
03285 const char *ASIM::ImplFileName()
03286 {
03287 return ROOT::GenerateInitInstance((const ASIM*)0x0)->GetImplFileName();
03288 }
03289
03290
03291 int ASIM::ImplFileLine()
03292 {
03293 return ROOT::GenerateInitInstance((const ASIM*)0x0)->GetImplFileLine();
03294 }
03295
03296
03297 void ASIM::Dictionary()
03298 {
03299 fgIsA = ROOT::GenerateInitInstance((const ASIM*)0x0)->GetClass();
03300 }
03301
03302
03303 TClass *ASIM::Class()
03304 {
03305 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const ASIM*)0x0)->GetClass();
03306 return fgIsA;
03307 }
03308
03309
03310 TClass *ADBR::fgIsA = 0;
03311
03312
03313 const char *ADBR::Class_Name()
03314 {
03315 return "ADBR";
03316 }
03317
03318
03319 const char *ADBR::ImplFileName()
03320 {
03321 return ROOT::GenerateInitInstance((const ADBR*)0x0)->GetImplFileName();
03322 }
03323
03324
03325 int ADBR::ImplFileLine()
03326 {
03327 return ROOT::GenerateInitInstance((const ADBR*)0x0)->GetImplFileLine();
03328 }
03329
03330
03331 void ADBR::Dictionary()
03332 {
03333 fgIsA = ROOT::GenerateInitInstance((const ADBR*)0x0)->GetClass();
03334 }
03335
03336
03337 TClass *ADBR::Class()
03338 {
03339 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const ADBR*)0x0)->GetClass();
03340 return fgIsA;
03341 }
03342
03343
03344 TClass *XTBN::fgIsA = 0;
03345
03346
03347 const char *XTBN::Class_Name()
03348 {
03349 return "XTBN";
03350 }
03351
03352
03353 const char *XTBN::ImplFileName()
03354 {
03355 return ROOT::GenerateInitInstance((const XTBN*)0x0)->GetImplFileName();
03356 }
03357
03358
03359 int XTBN::ImplFileLine()
03360 {
03361 return ROOT::GenerateInitInstance((const XTBN*)0x0)->GetImplFileLine();
03362 }
03363
03364
03365 void XTBN::Dictionary()
03366 {
03367 fgIsA = ROOT::GenerateInitInstance((const XTBN*)0x0)->GetClass();
03368 }
03369
03370
03371 TClass *XTBN::Class()
03372 {
03373 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const XTBN*)0x0)->GetClass();
03374 return fgIsA;
03375 }
03376
03377
03378 TClass *XTCN::fgIsA = 0;
03379
03380
03381 const char *XTCN::Class_Name()
03382 {
03383 return "XTCN";
03384 }
03385
03386
03387 const char *XTCN::ImplFileName()
03388 {
03389 return ROOT::GenerateInitInstance((const XTCN*)0x0)->GetImplFileName();
03390 }
03391
03392
03393 int XTCN::ImplFileLine()
03394 {
03395 return ROOT::GenerateInitInstance((const XTCN*)0x0)->GetImplFileLine();
03396 }
03397
03398
03399 void XTCN::Dictionary()
03400 {
03401 fgIsA = ROOT::GenerateInitInstance((const XTCN*)0x0)->GetClass();
03402 }
03403
03404
03405 TClass *XTCN::Class()
03406 {
03407 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const XTCN*)0x0)->GetClass();
03408 return fgIsA;
03409 }
03410
03411
03412 TClass *XTOP::fgIsA = 0;
03413
03414
03415 const char *XTOP::Class_Name()
03416 {
03417 return "XTOP";
03418 }
03419
03420
03421 const char *XTOP::ImplFileName()
03422 {
03423 return ROOT::GenerateInitInstance((const XTOP*)0x0)->GetImplFileName();
03424 }
03425
03426
03427 int XTOP::ImplFileLine()
03428 {
03429 return ROOT::GenerateInitInstance((const XTOP*)0x0)->GetImplFileLine();
03430 }
03431
03432
03433 void XTOP::Dictionary()
03434 {
03435 fgIsA = ROOT::GenerateInitInstance((const XTOP*)0x0)->GetClass();
03436 }
03437
03438
03439 TClass *XTOP::Class()
03440 {
03441 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const XTOP*)0x0)->GetClass();
03442 return fgIsA;
03443 }
03444
03445
03446 TClass *LUPA::fgIsA = 0;
03447
03448
03449 const char *LUPA::Class_Name()
03450 {
03451 return "LUPA";
03452 }
03453
03454
03455 const char *LUPA::ImplFileName()
03456 {
03457 return ROOT::GenerateInitInstance((const LUPA*)0x0)->GetImplFileName();
03458 }
03459
03460
03461 int LUPA::ImplFileLine()
03462 {
03463 return ROOT::GenerateInitInstance((const LUPA*)0x0)->GetImplFileLine();
03464 }
03465
03466
03467 void LUPA::Dictionary()
03468 {
03469 fgIsA = ROOT::GenerateInitInstance((const LUPA*)0x0)->GetClass();
03470 }
03471
03472
03473 TClass *LUPA::Class()
03474 {
03475 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const LUPA*)0x0)->GetClass();
03476 return fgIsA;
03477 }
03478
03479
03480 TClass *SILH::fgIsA = 0;
03481
03482
03483 const char *SILH::Class_Name()
03484 {
03485 return "SILH";
03486 }
03487
03488
03489 const char *SILH::ImplFileName()
03490 {
03491 return ROOT::GenerateInitInstance((const SILH*)0x0)->GetImplFileName();
03492 }
03493
03494
03495 int SILH::ImplFileLine()
03496 {
03497 return ROOT::GenerateInitInstance((const SILH*)0x0)->GetImplFileLine();
03498 }
03499
03500
03501 void SILH::Dictionary()
03502 {
03503 fgIsA = ROOT::GenerateInitInstance((const SILH*)0x0)->GetClass();
03504 }
03505
03506
03507 TClass *SILH::Class()
03508 {
03509 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const SILH*)0x0)->GetClass();
03510 return fgIsA;
03511 }
03512
03513
03514 TClass *XHVB::fgIsA = 0;
03515
03516
03517 const char *XHVB::Class_Name()
03518 {
03519 return "XHVB";
03520 }
03521
03522
03523 const char *XHVB::ImplFileName()
03524 {
03525 return ROOT::GenerateInitInstance((const XHVB*)0x0)->GetImplFileName();
03526 }
03527
03528
03529 int XHVB::ImplFileLine()
03530 {
03531 return ROOT::GenerateInitInstance((const XHVB*)0x0)->GetImplFileLine();
03532 }
03533
03534
03535 void XHVB::Dictionary()
03536 {
03537 fgIsA = ROOT::GenerateInitInstance((const XHVB*)0x0)->GetClass();
03538 }
03539
03540
03541 TClass *XHVB::Class()
03542 {
03543 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const XHVB*)0x0)->GetClass();
03544 return fgIsA;
03545 }
03546
03547
03548 TClass *XTEB::fgIsA = 0;
03549
03550
03551 const char *XTEB::Class_Name()
03552 {
03553 return "XTEB";
03554 }
03555
03556
03557 const char *XTEB::ImplFileName()
03558 {
03559 return ROOT::GenerateInitInstance((const XTEB*)0x0)->GetImplFileName();
03560 }
03561
03562
03563 int XTEB::ImplFileLine()
03564 {
03565 return ROOT::GenerateInitInstance((const XTEB*)0x0)->GetImplFileLine();
03566 }
03567
03568
03569 void XTEB::Dictionary()
03570 {
03571 fgIsA = ROOT::GenerateInitInstance((const XTEB*)0x0)->GetClass();
03572 }
03573
03574
03575 TClass *XTEB::Class()
03576 {
03577 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const XTEB*)0x0)->GetClass();
03578 return fgIsA;
03579 }
03580
03581
03582 TClass *XTRB::fgIsA = 0;
03583
03584
03585 const char *XTRB::Class_Name()
03586 {
03587 return "XTRB";
03588 }
03589
03590
03591 const char *XTRB::ImplFileName()
03592 {
03593 return ROOT::GenerateInitInstance((const XTRB*)0x0)->GetImplFileName();
03594 }
03595
03596
03597 int XTRB::ImplFileLine()
03598 {
03599 return ROOT::GenerateInitInstance((const XTRB*)0x0)->GetImplFileLine();
03600 }
03601
03602
03603 void XTRB::Dictionary()
03604 {
03605 fgIsA = ROOT::GenerateInitInstance((const XTRB*)0x0)->GetClass();
03606 }
03607
03608
03609 TClass *XTRB::Class()
03610 {
03611 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const XTRB*)0x0)->GetClass();
03612 return fgIsA;
03613 }
03614
03615
03616 TClass *DTBP::fgIsA = 0;
03617
03618
03619 const char *DTBP::Class_Name()
03620 {
03621 return "DTBP";
03622 }
03623
03624
03625 const char *DTBP::ImplFileName()
03626 {
03627 return ROOT::GenerateInitInstance((const DTBP*)0x0)->GetImplFileName();
03628 }
03629
03630
03631 int DTBP::ImplFileLine()
03632 {
03633 return ROOT::GenerateInitInstance((const DTBP*)0x0)->GetImplFileLine();
03634 }
03635
03636
03637 void DTBP::Dictionary()
03638 {
03639 fgIsA = ROOT::GenerateInitInstance((const DTBP*)0x0)->GetClass();
03640 }
03641
03642
03643 TClass *DTBP::Class()
03644 {
03645 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const DTBP*)0x0)->GetClass();
03646 return fgIsA;
03647 }
03648
03649
03650 TClass *VHBV::fgIsA = 0;
03651
03652
03653 const char *VHBV::Class_Name()
03654 {
03655 return "VHBV";
03656 }
03657
03658
03659 const char *VHBV::ImplFileName()
03660 {
03661 return ROOT::GenerateInitInstance((const VHBV*)0x0)->GetImplFileName();
03662 }
03663
03664
03665 int VHBV::ImplFileLine()
03666 {
03667 return ROOT::GenerateInitInstance((const VHBV*)0x0)->GetImplFileLine();
03668 }
03669
03670
03671 void VHBV::Dictionary()
03672 {
03673 fgIsA = ROOT::GenerateInitInstance((const VHBV*)0x0)->GetClass();
03674 }
03675
03676
03677 TClass *VHBV::Class()
03678 {
03679 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const VHBV*)0x0)->GetClass();
03680 return fgIsA;
03681 }
03682
03683
03684 TClass *VHPV::fgIsA = 0;
03685
03686
03687 const char *VHPV::Class_Name()
03688 {
03689 return "VHPV";
03690 }
03691
03692
03693 const char *VHPV::ImplFileName()
03694 {
03695 return ROOT::GenerateInitInstance((const VHPV*)0x0)->GetImplFileName();
03696 }
03697
03698
03699 int VHPV::ImplFileLine()
03700 {
03701 return ROOT::GenerateInitInstance((const VHPV*)0x0)->GetImplFileLine();
03702 }
03703
03704
03705 void VHPV::Dictionary()
03706 {
03707 fgIsA = ROOT::GenerateInitInstance((const VHPV*)0x0)->GetClass();
03708 }
03709
03710
03711 TClass *VHPV::Class()
03712 {
03713 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const VHPV*)0x0)->GetClass();
03714 return fgIsA;
03715 }
03716
03717
03718 TClass *EAUX::fgIsA = 0;
03719
03720
03721 const char *EAUX::Class_Name()
03722 {
03723 return "EAUX";
03724 }
03725
03726
03727 const char *EAUX::ImplFileName()
03728 {
03729 return ROOT::GenerateInitInstance((const EAUX*)0x0)->GetImplFileName();
03730 }
03731
03732
03733 int EAUX::ImplFileLine()
03734 {
03735 return ROOT::GenerateInitInstance((const EAUX*)0x0)->GetImplFileLine();
03736 }
03737
03738
03739 void EAUX::Dictionary()
03740 {
03741 fgIsA = ROOT::GenerateInitInstance((const EAUX*)0x0)->GetClass();
03742 }
03743
03744
03745 TClass *EAUX::Class()
03746 {
03747 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const EAUX*)0x0)->GetClass();
03748 return fgIsA;
03749 }
03750
03751
03752 TClass *SIX2::fgIsA = 0;
03753
03754
03755 const char *SIX2::Class_Name()
03756 {
03757 return "SIX2";
03758 }
03759
03760
03761 const char *SIX2::ImplFileName()
03762 {
03763 return ROOT::GenerateInitInstance((const SIX2*)0x0)->GetImplFileName();
03764 }
03765
03766
03767 int SIX2::ImplFileLine()
03768 {
03769 return ROOT::GenerateInitInstance((const SIX2*)0x0)->GetImplFileLine();
03770 }
03771
03772
03773 void SIX2::Dictionary()
03774 {
03775 fgIsA = ROOT::GenerateInitInstance((const SIX2*)0x0)->GetClass();
03776 }
03777
03778
03779 TClass *SIX2::Class()
03780 {
03781 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const SIX2*)0x0)->GetClass();
03782 return fgIsA;
03783 }
03784
03785
03786 TClass *X1TV::fgIsA = 0;
03787
03788
03789 const char *X1TV::Class_Name()
03790 {
03791 return "X1TV";
03792 }
03793
03794
03795 const char *X1TV::ImplFileName()
03796 {
03797 return ROOT::GenerateInitInstance((const X1TV*)0x0)->GetImplFileName();
03798 }
03799
03800
03801 int X1TV::ImplFileLine()
03802 {
03803 return ROOT::GenerateInitInstance((const X1TV*)0x0)->GetImplFileLine();
03804 }
03805
03806
03807 void X1TV::Dictionary()
03808 {
03809 fgIsA = ROOT::GenerateInitInstance((const X1TV*)0x0)->GetClass();
03810 }
03811
03812
03813 TClass *X1TV::Class()
03814 {
03815 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const X1TV*)0x0)->GetClass();
03816 return fgIsA;
03817 }
03818
03819
03820 TClass *KWGT::fgIsA = 0;
03821
03822
03823 const char *KWGT::Class_Name()
03824 {
03825 return "KWGT";
03826 }
03827
03828
03829 const char *KWGT::ImplFileName()
03830 {
03831 return ROOT::GenerateInitInstance((const KWGT*)0x0)->GetImplFileName();
03832 }
03833
03834
03835 int KWGT::ImplFileLine()
03836 {
03837 return ROOT::GenerateInitInstance((const KWGT*)0x0)->GetImplFileLine();
03838 }
03839
03840
03841 void KWGT::Dictionary()
03842 {
03843 fgIsA = ROOT::GenerateInitInstance((const KWGT*)0x0)->GetClass();
03844 }
03845
03846
03847 TClass *KWGT::Class()
03848 {
03849 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const KWGT*)0x0)->GetClass();
03850 return fgIsA;
03851 }
03852
03853
03854 TClass *X1IP::fgIsA = 0;
03855
03856
03857 const char *X1IP::Class_Name()
03858 {
03859 return "X1IP";
03860 }
03861
03862
03863 const char *X1IP::ImplFileName()
03864 {
03865 return ROOT::GenerateInitInstance((const X1IP*)0x0)->GetImplFileName();
03866 }
03867
03868
03869 int X1IP::ImplFileLine()
03870 {
03871 return ROOT::GenerateInitInstance((const X1IP*)0x0)->GetImplFileLine();
03872 }
03873
03874
03875 void X1IP::Dictionary()
03876 {
03877 fgIsA = ROOT::GenerateInitInstance((const X1IP*)0x0)->GetClass();
03878 }
03879
03880
03881 TClass *X1IP::Class()
03882 {
03883 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const X1IP*)0x0)->GetClass();
03884 return fgIsA;
03885 }
03886
03887
03888 TClass *SIXA::fgIsA = 0;
03889
03890
03891 const char *SIXA::Class_Name()
03892 {
03893 return "SIXA";
03894 }
03895
03896
03897 const char *SIXA::ImplFileName()
03898 {
03899 return ROOT::GenerateInitInstance((const SIXA*)0x0)->GetImplFileName();
03900 }
03901
03902
03903 int SIXA::ImplFileLine()
03904 {
03905 return ROOT::GenerateInitInstance((const SIXA*)0x0)->GetImplFileLine();
03906 }
03907
03908
03909 void SIXA::Dictionary()
03910 {
03911 fgIsA = ROOT::GenerateInitInstance((const SIXA*)0x0)->GetClass();
03912 }
03913
03914
03915 TClass *SIXA::Class()
03916 {
03917 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const SIXA*)0x0)->GetClass();
03918 return fgIsA;
03919 }
03920
03921
03922 TClass *SITC::fgIsA = 0;
03923
03924
03925 const char *SITC::Class_Name()
03926 {
03927 return "SITC";
03928 }
03929
03930
03931 const char *SITC::ImplFileName()
03932 {
03933 return ROOT::GenerateInitInstance((const SITC*)0x0)->GetImplFileName();
03934 }
03935
03936
03937 int SITC::ImplFileLine()
03938 {
03939 return ROOT::GenerateInitInstance((const SITC*)0x0)->GetImplFileLine();
03940 }
03941
03942
03943 void SITC::Dictionary()
03944 {
03945 fgIsA = ROOT::GenerateInitInstance((const SITC*)0x0)->GetClass();
03946 }
03947
03948
03949 TClass *SITC::Class()
03950 {
03951 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const SITC*)0x0)->GetClass();
03952 return fgIsA;
03953 }
03954
03955
03956 TClass *SRCO::fgIsA = 0;
03957
03958
03959 const char *SRCO::Class_Name()
03960 {
03961 return "SRCO";
03962 }
03963
03964
03965 const char *SRCO::ImplFileName()
03966 {
03967 return ROOT::GenerateInitInstance((const SRCO*)0x0)->GetImplFileName();
03968 }
03969
03970
03971 int SRCO::ImplFileLine()
03972 {
03973 return ROOT::GenerateInitInstance((const SRCO*)0x0)->GetImplFileLine();
03974 }
03975
03976
03977 void SRCO::Dictionary()
03978 {
03979 fgIsA = ROOT::GenerateInitInstance((const SRCO*)0x0)->GetClass();
03980 }
03981
03982
03983 TClass *SRCO::Class()
03984 {
03985 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const SRCO*)0x0)->GetClass();
03986 return fgIsA;
03987 }
03988
03989
03990 TClass *X1TH::fgIsA = 0;
03991
03992
03993 const char *X1TH::Class_Name()
03994 {
03995 return "X1TH";
03996 }
03997
03998
03999 const char *X1TH::ImplFileName()
04000 {
04001 return ROOT::GenerateInitInstance((const X1TH*)0x0)->GetImplFileName();
04002 }
04003
04004
04005 int X1TH::ImplFileLine()
04006 {
04007 return ROOT::GenerateInitInstance((const X1TH*)0x0)->GetImplFileLine();
04008 }
04009
04010
04011 void X1TH::Dictionary()
04012 {
04013 fgIsA = ROOT::GenerateInitInstance((const X1TH*)0x0)->GetClass();
04014 }
04015
04016
04017 TClass *X1TH::Class()
04018 {
04019 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const X1TH*)0x0)->GetClass();
04020 return fgIsA;
04021 }
04022
04023
04024 TClass *X1AD::fgIsA = 0;
04025
04026
04027 const char *X1AD::Class_Name()
04028 {
04029 return "X1AD";
04030 }
04031
04032
04033 const char *X1AD::ImplFileName()
04034 {
04035 return ROOT::GenerateInitInstance((const X1AD*)0x0)->GetImplFileName();
04036 }
04037
04038
04039 int X1AD::ImplFileLine()
04040 {
04041 return ROOT::GenerateInitInstance((const X1AD*)0x0)->GetImplFileLine();
04042 }
04043
04044
04045 void X1AD::Dictionary()
04046 {
04047 fgIsA = ROOT::GenerateInitInstance((const X1AD*)0x0)->GetClass();
04048 }
04049
04050
04051 TClass *X1AD::Class()
04052 {
04053 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const X1AD*)0x0)->GetClass();
04054 return fgIsA;
04055 }
04056
04057
04058 TClass *QEXT::fgIsA = 0;
04059
04060
04061 const char *QEXT::Class_Name()
04062 {
04063 return "QEXT";
04064 }
04065
04066
04067 const char *QEXT::ImplFileName()
04068 {
04069 return ROOT::GenerateInitInstance((const QEXT*)0x0)->GetImplFileName();
04070 }
04071
04072
04073 int QEXT::ImplFileLine()
04074 {
04075 return ROOT::GenerateInitInstance((const QEXT*)0x0)->GetImplFileLine();
04076 }
04077
04078
04079 void QEXT::Dictionary()
04080 {
04081 fgIsA = ROOT::GenerateInitInstance((const QEXT*)0x0)->GetClass();
04082 }
04083
04084
04085 TClass *QEXT::Class()
04086 {
04087 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QEXT*)0x0)->GetClass();
04088 return fgIsA;
04089 }
04090
04091
04092 TClass *QHAC::fgIsA = 0;
04093
04094
04095 const char *QHAC::Class_Name()
04096 {
04097 return "QHAC";
04098 }
04099
04100
04101 const char *QHAC::ImplFileName()
04102 {
04103 return ROOT::GenerateInitInstance((const QHAC*)0x0)->GetImplFileName();
04104 }
04105
04106
04107 int QHAC::ImplFileLine()
04108 {
04109 return ROOT::GenerateInitInstance((const QHAC*)0x0)->GetImplFileLine();
04110 }
04111
04112
04113 void QHAC::Dictionary()
04114 {
04115 fgIsA = ROOT::GenerateInitInstance((const QHAC*)0x0)->GetClass();
04116 }
04117
04118
04119 TClass *QHAC::Class()
04120 {
04121 if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const QHAC*)0x0)->GetClass();
04122 return fgIsA;
04123 }
04124
04125
04126 void QLIN::Streamer(TBuffer &R__b)
04127 {
04128
04129
04130 if (R__b.IsReading()) {
04131 QLIN::Class()->ReadBuffer(R__b, this);
04132 } else {
04133 QLIN::Class()->WriteBuffer(R__b, this);
04134 }
04135 }
04136
04137
04138 void QLIN::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04139 {
04140
04141
04142 TClass *R__cl = QLIN::IsA();
04143 Int_t R__ncp = strlen(R__parent);
04144 if (R__ncp || R__cl || R__insp.IsA()) { }
04145 R__insp.Inspect(R__cl, R__parent, "I", &I);
04146 TObject::ShowMembers(R__insp, R__parent);
04147 }
04148
04149 namespace ROOT {
04150
04151 TClass *QLIN_IsA(const void *obj) {
04152 return ((::QLIN*)obj)->IsA();
04153 }
04154
04155 void *new_QLIN(void *p) {
04156 return p ? new(p) ::QLIN : new ::QLIN;
04157 }
04158 void *newArray_QLIN(Long_t size) {
04159 return new ::QLIN[size];
04160 }
04161
04162 void delete_QLIN(void *p) {
04163 delete ((::QLIN*)p);
04164 }
04165 void deleteArray_QLIN(void *p) {
04166 delete [] ((::QLIN*)p);
04167 }
04168 void destruct_QLIN(void *p) {
04169 typedef ::QLIN current_t;
04170 ((current_t*)p)->~current_t();
04171 }
04172 }
04173
04174
04175 void QMTL::Streamer(TBuffer &R__b)
04176 {
04177
04178
04179 if (R__b.IsReading()) {
04180 QMTL::Class()->ReadBuffer(R__b, this);
04181 } else {
04182 QMTL::Class()->WriteBuffer(R__b, this);
04183 }
04184 }
04185
04186
04187 void QMTL::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04188 {
04189
04190
04191 TClass *R__cl = QMTL::IsA();
04192 Int_t R__ncp = strlen(R__parent);
04193 if (R__ncp || R__cl || R__insp.IsA()) { }
04194 R__insp.Inspect(R__cl, R__parent, "I", &I);
04195 TObject::ShowMembers(R__insp, R__parent);
04196 }
04197
04198 namespace ROOT {
04199
04200 TClass *QMTL_IsA(const void *obj) {
04201 return ((::QMTL*)obj)->IsA();
04202 }
04203
04204 void *new_QMTL(void *p) {
04205 return p ? new(p) ::QMTL : new ::QMTL;
04206 }
04207 void *newArray_QMTL(Long_t size) {
04208 return new ::QMTL[size];
04209 }
04210
04211 void delete_QMTL(void *p) {
04212 delete ((::QMTL*)p);
04213 }
04214 void deleteArray_QMTL(void *p) {
04215 delete [] ((::QMTL*)p);
04216 }
04217 void destruct_QMTL(void *p) {
04218 typedef ::QMTL current_t;
04219 ((current_t*)p)->~current_t();
04220 }
04221 }
04222
04223
04224 void QMTS::Streamer(TBuffer &R__b)
04225 {
04226
04227
04228 if (R__b.IsReading()) {
04229 QMTS::Class()->ReadBuffer(R__b, this);
04230 } else {
04231 QMTS::Class()->WriteBuffer(R__b, this);
04232 }
04233 }
04234
04235
04236 void QMTS::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04237 {
04238
04239
04240 TClass *R__cl = QMTS::IsA();
04241 Int_t R__ncp = strlen(R__parent);
04242 if (R__ncp || R__cl || R__insp.IsA()) { }
04243 R__insp.Inspect(R__cl, R__parent, "I", &I);
04244 TObject::ShowMembers(R__insp, R__parent);
04245 }
04246
04247 namespace ROOT {
04248
04249 TClass *QMTS_IsA(const void *obj) {
04250 return ((::QMTS*)obj)->IsA();
04251 }
04252
04253 void *new_QMTS(void *p) {
04254 return p ? new(p) ::QMTS : new ::QMTS;
04255 }
04256 void *newArray_QMTS(Long_t size) {
04257 return new ::QMTS[size];
04258 }
04259
04260 void delete_QMTS(void *p) {
04261 delete ((::QMTS*)p);
04262 }
04263 void deleteArray_QMTS(void *p) {
04264 delete [] ((::QMTS*)p);
04265 }
04266 void destruct_QMTS(void *p) {
04267 typedef ::QMTS current_t;
04268 ((current_t*)p)->~current_t();
04269 }
04270 }
04271
04272
04273 void FRFT::Streamer(TBuffer &R__b)
04274 {
04275
04276
04277 if (R__b.IsReading()) {
04278 FRFT::Class()->ReadBuffer(R__b, this);
04279 } else {
04280 FRFT::Class()->WriteBuffer(R__b, this);
04281 }
04282 }
04283
04284
04285 void FRFT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04286 {
04287
04288
04289 TClass *R__cl = FRFT::IsA();
04290 Int_t R__ncp = strlen(R__parent);
04291 if (R__ncp || R__cl || R__insp.IsA()) { }
04292 R__insp.Inspect(R__cl, R__parent, "IR", &IR);
04293 R__insp.Inspect(R__cl, R__parent, "TL", &TL);
04294 R__insp.Inspect(R__cl, R__parent, "P0", &P0);
04295 R__insp.Inspect(R__cl, R__parent, "D0", &D0);
04296 R__insp.Inspect(R__cl, R__parent, "Z0", &Z0);
04297 R__insp.Inspect(R__cl, R__parent, "AL", &AL);
04298 R__insp.Inspect(R__cl, R__parent, "EM[20]", EM);
04299 R__insp.Inspect(R__cl, R__parent, "C2", &C2);
04300 R__insp.Inspect(R__cl, R__parent, "DF", &DF);
04301 R__insp.Inspect(R__cl, R__parent, "NO", &NO);
04302 TObject::ShowMembers(R__insp, R__parent);
04303 }
04304
04305 namespace ROOT {
04306
04307 TClass *FRFT_IsA(const void *obj) {
04308 return ((::FRFT*)obj)->IsA();
04309 }
04310
04311 void *new_FRFT(void *p) {
04312 return p ? new(p) ::FRFT : new ::FRFT;
04313 }
04314 void *newArray_FRFT(Long_t size) {
04315 return new ::FRFT[size];
04316 }
04317
04318 void delete_FRFT(void *p) {
04319 delete ((::FRFT*)p);
04320 }
04321 void deleteArray_FRFT(void *p) {
04322 delete [] ((::FRFT*)p);
04323 }
04324 void destruct_FRFT(void *p) {
04325 typedef ::FRFT current_t;
04326 ((current_t*)p)->~current_t();
04327 }
04328 }
04329
04330
04331 void FRTL::Streamer(TBuffer &R__b)
04332 {
04333
04334
04335 if (R__b.IsReading()) {
04336 FRTL::Class()->ReadBuffer(R__b, this);
04337 } else {
04338 FRTL::Class()->WriteBuffer(R__b, this);
04339 }
04340 }
04341
04342
04343 void FRTL::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04344 {
04345
04346
04347 TClass *R__cl = FRTL::IsA();
04348 Int_t R__ncp = strlen(R__parent);
04349 if (R__ncp || R__cl || R__insp.IsA()) { }
04350 R__insp.Inspect(R__cl, R__parent, "IV", &IV);
04351 R__insp.Inspect(R__cl, R__parent, "NV", &NV);
04352 R__insp.Inspect(R__cl, R__parent, "II", &II);
04353 R__insp.Inspect(R__cl, R__parent, "NI", &NI);
04354 R__insp.Inspect(R__cl, R__parent, "NE", &NE);
04355 R__insp.Inspect(R__cl, R__parent, "IT", &IT);
04356 R__insp.Inspect(R__cl, R__parent, "NT", &NT);
04357 R__insp.Inspect(R__cl, R__parent, "NR", &NR);
04358 TObject::ShowMembers(R__insp, R__parent);
04359 }
04360
04361 namespace ROOT {
04362
04363 TClass *FRTL_IsA(const void *obj) {
04364 return ((::FRTL*)obj)->IsA();
04365 }
04366
04367 void *new_FRTL(void *p) {
04368 return p ? new(p) ::FRTL : new ::FRTL;
04369 }
04370 void *newArray_FRTL(Long_t size) {
04371 return new ::FRTL[size];
04372 }
04373
04374 void delete_FRTL(void *p) {
04375 delete ((::FRTL*)p);
04376 }
04377 void deleteArray_FRTL(void *p) {
04378 delete [] ((::FRTL*)p);
04379 }
04380 void destruct_FRTL(void *p) {
04381 typedef ::FRTL current_t;
04382 ((current_t*)p)->~current_t();
04383 }
04384 }
04385
04386
04387 void TEXS::Streamer(TBuffer &R__b)
04388 {
04389
04390
04391 if (R__b.IsReading()) {
04392 TEXS::Class()->ReadBuffer(R__b, this);
04393 } else {
04394 TEXS::Class()->WriteBuffer(R__b, this);
04395 }
04396 }
04397
04398
04399 void TEXS::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04400 {
04401
04402
04403 TClass *R__cl = TEXS::IsA();
04404 Int_t R__ncp = strlen(R__parent);
04405 if (R__ncp || R__cl || R__insp.IsA()) { }
04406 R__insp.Inspect(R__cl, R__parent, "SI", &SI);
04407 R__insp.Inspect(R__cl, R__parent, "TM", &TM);
04408 R__insp.Inspect(R__cl, R__parent, "TL", &TL);
04409 R__insp.Inspect(R__cl, R__parent, "NS", &NS);
04410 R__insp.Inspect(R__cl, R__parent, "AD", &AD);
04411 R__insp.Inspect(R__cl, R__parent, "TN", &TN);
04412 R__insp.Inspect(R__cl, R__parent, "SF", &SF);
04413 TObject::ShowMembers(R__insp, R__parent);
04414 }
04415
04416 namespace ROOT {
04417
04418 TClass *TEXS_IsA(const void *obj) {
04419 return ((::TEXS*)obj)->IsA();
04420 }
04421
04422 void *new_TEXS(void *p) {
04423 return p ? new(p) ::TEXS : new ::TEXS;
04424 }
04425 void *newArray_TEXS(Long_t size) {
04426 return new ::TEXS[size];
04427 }
04428
04429 void delete_TEXS(void *p) {
04430 delete ((::TEXS*)p);
04431 }
04432 void deleteArray_TEXS(void *p) {
04433 delete [] ((::TEXS*)p);
04434 }
04435 void destruct_TEXS(void *p) {
04436 typedef ::TEXS current_t;
04437 ((current_t*)p)->~current_t();
04438 }
04439 }
04440
04441
04442 void HMAD::Streamer(TBuffer &R__b)
04443 {
04444
04445
04446 if (R__b.IsReading()) {
04447 HMAD::Class()->ReadBuffer(R__b, this);
04448 } else {
04449 HMAD::Class()->WriteBuffer(R__b, this);
04450 }
04451 }
04452
04453
04454 void HMAD::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04455 {
04456
04457
04458 TClass *R__cl = HMAD::IsA();
04459 Int_t R__ncp = strlen(R__parent);
04460 if (R__ncp || R__cl || R__insp.IsA()) { }
04461 R__insp.Inspect(R__cl, R__parent, "NplaFired", &NplaFired);
04462 R__insp.Inspect(R__cl, R__parent, "NplaExp", &NplaExp);
04463 R__insp.Inspect(R__cl, R__parent, "NplaLast", &NplaLast);
04464 R__insp.Inspect(R__cl, R__parent, "MultHits", &MultHits);
04465 R__insp.Inspect(R__cl, R__parent, "IGeomflag", &IGeomflag);
04466 R__insp.Inspect(R__cl, R__parent, "EnerDep", &EnerDep);
04467 R__insp.Inspect(R__cl, R__parent, "ChiSquare", &ChiSquare);
04468 R__insp.Inspect(R__cl, R__parent, "NumbDeg", &NumbDeg);
04469 R__insp.Inspect(R__cl, R__parent, "IExpbmap", &IExpbmap);
04470 R__insp.Inspect(R__cl, R__parent, "ITruebmap", &ITruebmap);
04471 R__insp.Inspect(R__cl, R__parent, "IdenFlag", &IdenFlag);
04472 R__insp.Inspect(R__cl, R__parent, "TrackNo", &TrackNo);
04473 TObject::ShowMembers(R__insp, R__parent);
04474 }
04475
04476 namespace ROOT {
04477
04478 TClass *HMAD_IsA(const void *obj) {
04479 return ((::HMAD*)obj)->IsA();
04480 }
04481
04482 void *new_HMAD(void *p) {
04483 return p ? new(p) ::HMAD : new ::HMAD;
04484 }
04485 void *newArray_HMAD(Long_t size) {
04486 return new ::HMAD[size];
04487 }
04488
04489 void delete_HMAD(void *p) {
04490 delete ((::HMAD*)p);
04491 }
04492 void deleteArray_HMAD(void *p) {
04493 delete [] ((::HMAD*)p);
04494 }
04495 void destruct_HMAD(void *p) {
04496 typedef ::HMAD current_t;
04497 ((current_t*)p)->~current_t();
04498 }
04499 }
04500
04501
04502 void MCAD::Streamer(TBuffer &R__b)
04503 {
04504
04505
04506 if (R__b.IsReading()) {
04507 MCAD::Class()->ReadBuffer(R__b, this);
04508 } else {
04509 MCAD::Class()->WriteBuffer(R__b, this);
04510 }
04511 }
04512
04513
04514 void MCAD::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04515 {
04516
04517
04518 TClass *R__cl = MCAD::IsA();
04519 Int_t R__ncp = strlen(R__parent);
04520 if (R__ncp || R__cl || R__insp.IsA()) { }
04521 R__insp.Inspect(R__cl, R__parent, "NH[2]", NH);
04522 R__insp.Inspect(R__cl, R__parent, "DH[2]", DH);
04523 R__insp.Inspect(R__cl, R__parent, "DC[2]", DC);
04524 R__insp.Inspect(R__cl, R__parent, "AM", &AM);
04525 R__insp.Inspect(R__cl, R__parent, "AC", &AC);
04526 R__insp.Inspect(R__cl, R__parent, "TN", &TN);
04527 TObject::ShowMembers(R__insp, R__parent);
04528 }
04529
04530 namespace ROOT {
04531
04532 TClass *MCAD_IsA(const void *obj) {
04533 return ((::MCAD*)obj)->IsA();
04534 }
04535
04536 void *new_MCAD(void *p) {
04537 return p ? new(p) ::MCAD : new ::MCAD;
04538 }
04539 void *newArray_MCAD(Long_t size) {
04540 return new ::MCAD[size];
04541 }
04542
04543 void delete_MCAD(void *p) {
04544 delete ((::MCAD*)p);
04545 }
04546 void deleteArray_MCAD(void *p) {
04547 delete [] ((::MCAD*)p);
04548 }
04549 void destruct_MCAD(void *p) {
04550 typedef ::MCAD current_t;
04551 ((current_t*)p)->~current_t();
04552 }
04553 }
04554
04555
04556 void PECO::Streamer(TBuffer &R__b)
04557 {
04558
04559
04560 if (R__b.IsReading()) {
04561 PECO::Class()->ReadBuffer(R__b, this);
04562 } else {
04563 PECO::Class()->WriteBuffer(R__b, this);
04564 }
04565 }
04566
04567
04568 void PECO::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04569 {
04570
04571
04572 TClass *R__cl = PECO::IsA();
04573 Int_t R__ncp = strlen(R__parent);
04574 if (R__ncp || R__cl || R__insp.IsA()) { }
04575 R__insp.Inspect(R__cl, R__parent, "ER", &ER);
04576 R__insp.Inspect(R__cl, R__parent, "E1", &E1);
04577 R__insp.Inspect(R__cl, R__parent, "E2", &E2);
04578 R__insp.Inspect(R__cl, R__parent, "TH", &TH);
04579 R__insp.Inspect(R__cl, R__parent, "PH", &PH);
04580 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
04581 R__insp.Inspect(R__cl, R__parent, "KD", &KD);
04582 R__insp.Inspect(R__cl, R__parent, "CC", &CC);
04583 R__insp.Inspect(R__cl, R__parent, "RB", &RB);
04584 R__insp.Inspect(R__cl, R__parent, "PC", &PC);
04585 TObject::ShowMembers(R__insp, R__parent);
04586 }
04587
04588 namespace ROOT {
04589
04590 TClass *PECO_IsA(const void *obj) {
04591 return ((::PECO*)obj)->IsA();
04592 }
04593
04594 void *new_PECO(void *p) {
04595 return p ? new(p) ::PECO : new ::PECO;
04596 }
04597 void *newArray_PECO(Long_t size) {
04598 return new ::PECO[size];
04599 }
04600
04601 void delete_PECO(void *p) {
04602 delete ((::PECO*)p);
04603 }
04604 void deleteArray_PECO(void *p) {
04605 delete [] ((::PECO*)p);
04606 }
04607 void destruct_PECO(void *p) {
04608 typedef ::PECO current_t;
04609 ((current_t*)p)->~current_t();
04610 }
04611 }
04612
04613
04614 void EIDT::Streamer(TBuffer &R__b)
04615 {
04616
04617
04618 if (R__b.IsReading()) {
04619 EIDT::Class()->ReadBuffer(R__b, this);
04620 } else {
04621 EIDT::Class()->WriteBuffer(R__b, this);
04622 }
04623 }
04624
04625
04626 void EIDT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04627 {
04628
04629
04630 TClass *R__cl = EIDT::IsA();
04631 Int_t R__ncp = strlen(R__parent);
04632 if (R__ncp || R__cl || R__insp.IsA()) { }
04633 R__insp.Inspect(R__cl, R__parent, "IF", &IF);
04634 R__insp.Inspect(R__cl, R__parent, "R1", &R1);
04635 R__insp.Inspect(R__cl, R__parent, "R2", &R2);
04636 R__insp.Inspect(R__cl, R__parent, "R3", &R3);
04637 R__insp.Inspect(R__cl, R__parent, "R4", &R4);
04638 R__insp.Inspect(R__cl, R__parent, "R5", &R5);
04639 R__insp.Inspect(R__cl, R__parent, "R6", &R6);
04640 R__insp.Inspect(R__cl, R__parent, "R7", &R7);
04641 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
04642 R__insp.Inspect(R__cl, R__parent, "IP", &IP);
04643 R__insp.Inspect(R__cl, R__parent, "E1", &E1);
04644 R__insp.Inspect(R__cl, R__parent, "E2", &E2);
04645 R__insp.Inspect(R__cl, R__parent, "E3", &E3);
04646 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
04647 R__insp.Inspect(R__cl, R__parent, "PE", &PE);
04648 TObject::ShowMembers(R__insp, R__parent);
04649 }
04650
04651 namespace ROOT {
04652
04653 TClass *EIDT_IsA(const void *obj) {
04654 return ((::EIDT*)obj)->IsA();
04655 }
04656
04657 void *new_EIDT(void *p) {
04658 return p ? new(p) ::EIDT : new ::EIDT;
04659 }
04660 void *newArray_EIDT(Long_t size) {
04661 return new ::EIDT[size];
04662 }
04663
04664 void delete_EIDT(void *p) {
04665 delete ((::EIDT*)p);
04666 }
04667 void deleteArray_EIDT(void *p) {
04668 delete [] ((::EIDT*)p);
04669 }
04670 void destruct_EIDT(void *p) {
04671 typedef ::EIDT current_t;
04672 ((current_t*)p)->~current_t();
04673 }
04674 }
04675
04676
04677 void PHCO::Streamer(TBuffer &R__b)
04678 {
04679
04680
04681 if (R__b.IsReading()) {
04682 PHCO::Class()->ReadBuffer(R__b, this);
04683 } else {
04684 PHCO::Class()->WriteBuffer(R__b, this);
04685 }
04686 }
04687
04688
04689 void PHCO::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04690 {
04691
04692
04693 TClass *R__cl = PHCO::IsA();
04694 Int_t R__ncp = strlen(R__parent);
04695 if (R__ncp || R__cl || R__insp.IsA()) { }
04696 R__insp.Inspect(R__cl, R__parent, "ER", &ER);
04697 R__insp.Inspect(R__cl, R__parent, "TH", &TH);
04698 R__insp.Inspect(R__cl, R__parent, "PH", &PH);
04699 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
04700 R__insp.Inspect(R__cl, R__parent, "KD", &KD);
04701 R__insp.Inspect(R__cl, R__parent, "CC", &CC);
04702 R__insp.Inspect(R__cl, R__parent, "RB", &RB);
04703 R__insp.Inspect(R__cl, R__parent, "NF", &NF);
04704 R__insp.Inspect(R__cl, R__parent, "PC", &PC);
04705 TObject::ShowMembers(R__insp, R__parent);
04706 }
04707
04708 namespace ROOT {
04709
04710 TClass *PHCO_IsA(const void *obj) {
04711 return ((::PHCO*)obj)->IsA();
04712 }
04713
04714 void *new_PHCO(void *p) {
04715 return p ? new(p) ::PHCO : new ::PHCO;
04716 }
04717 void *newArray_PHCO(Long_t size) {
04718 return new ::PHCO[size];
04719 }
04720
04721 void delete_PHCO(void *p) {
04722 delete ((::PHCO*)p);
04723 }
04724 void deleteArray_PHCO(void *p) {
04725 delete [] ((::PHCO*)p);
04726 }
04727 void destruct_PHCO(void *p) {
04728 typedef ::PHCO current_t;
04729 ((current_t*)p)->~current_t();
04730 }
04731 }
04732
04733
04734 void PEPT::Streamer(TBuffer &R__b)
04735 {
04736
04737
04738 if (R__b.IsReading()) {
04739 PEPT::Class()->ReadBuffer(R__b, this);
04740 } else {
04741 PEPT::Class()->WriteBuffer(R__b, this);
04742 }
04743 }
04744
04745
04746 void PEPT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04747 {
04748
04749
04750 TClass *R__cl = PEPT::IsA();
04751 Int_t R__ncp = strlen(R__parent);
04752 if (R__ncp || R__cl || R__insp.IsA()) { }
04753 R__insp.Inspect(R__cl, R__parent, "T1", &T1);
04754 R__insp.Inspect(R__cl, R__parent, "P1", &P1);
04755 R__insp.Inspect(R__cl, R__parent, "T3", &T3);
04756 R__insp.Inspect(R__cl, R__parent, "P3", &P3);
04757 TObject::ShowMembers(R__insp, R__parent);
04758 }
04759
04760 namespace ROOT {
04761
04762 TClass *PEPT_IsA(const void *obj) {
04763 return ((::PEPT*)obj)->IsA();
04764 }
04765
04766 void *new_PEPT(void *p) {
04767 return p ? new(p) ::PEPT : new ::PEPT;
04768 }
04769 void *newArray_PEPT(Long_t size) {
04770 return new ::PEPT[size];
04771 }
04772
04773 void delete_PEPT(void *p) {
04774 delete ((::PEPT*)p);
04775 }
04776 void deleteArray_PEPT(void *p) {
04777 delete [] ((::PEPT*)p);
04778 }
04779 void destruct_PEPT(void *p) {
04780 typedef ::PEPT current_t;
04781 ((current_t*)p)->~current_t();
04782 }
04783 }
04784
04785
04786 void FRID::Streamer(TBuffer &R__b)
04787 {
04788
04789
04790 if (R__b.IsReading()) {
04791 FRID::Class()->ReadBuffer(R__b, this);
04792 } else {
04793 FRID::Class()->WriteBuffer(R__b, this);
04794 }
04795 }
04796
04797
04798 void FRID::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04799 {
04800
04801
04802 TClass *R__cl = FRID::IsA();
04803 Int_t R__ncp = strlen(R__parent);
04804 if (R__ncp || R__cl || R__insp.IsA()) { }
04805 R__insp.Inspect(R__cl, R__parent, "BP", &BP);
04806 R__insp.Inspect(R__cl, R__parent, "DZ", &DZ);
04807 R__insp.Inspect(R__cl, R__parent, "BC", &BC);
04808 R__insp.Inspect(R__cl, R__parent, "DC", &DC);
04809 R__insp.Inspect(R__cl, R__parent, "PE", &PE);
04810 R__insp.Inspect(R__cl, R__parent, "PM", &PM);
04811 R__insp.Inspect(R__cl, R__parent, "PI", &PI);
04812 R__insp.Inspect(R__cl, R__parent, "PK", &PK);
04813 R__insp.Inspect(R__cl, R__parent, "PP", &PP);
04814 R__insp.Inspect(R__cl, R__parent, "NK", &NK);
04815 R__insp.Inspect(R__cl, R__parent, "QF", &QF);
04816 TObject::ShowMembers(R__insp, R__parent);
04817 }
04818
04819 namespace ROOT {
04820
04821 TClass *FRID_IsA(const void *obj) {
04822 return ((::FRID*)obj)->IsA();
04823 }
04824
04825 void *new_FRID(void *p) {
04826 return p ? new(p) ::FRID : new ::FRID;
04827 }
04828 void *newArray_FRID(Long_t size) {
04829 return new ::FRID[size];
04830 }
04831
04832 void delete_FRID(void *p) {
04833 delete ((::FRID*)p);
04834 }
04835 void deleteArray_FRID(void *p) {
04836 delete [] ((::FRID*)p);
04837 }
04838 void destruct_FRID(void *p) {
04839 typedef ::FRID current_t;
04840 ((current_t*)p)->~current_t();
04841 }
04842 }
04843
04844
04845 void EFOL::Streamer(TBuffer &R__b)
04846 {
04847
04848
04849 if (R__b.IsReading()) {
04850 EFOL::Class()->ReadBuffer(R__b, this);
04851 } else {
04852 EFOL::Class()->WriteBuffer(R__b, this);
04853 }
04854 }
04855
04856
04857 void EFOL::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04858 {
04859
04860
04861 TClass *R__cl = EFOL::IsA();
04862 Int_t R__ncp = strlen(R__parent);
04863 if (R__ncp || R__cl || R__insp.IsA()) { }
04864 R__insp.Inspect(R__cl, R__parent, "PX", &PX);
04865 R__insp.Inspect(R__cl, R__parent, "PY", &PY);
04866 R__insp.Inspect(R__cl, R__parent, "PZ", &PZ);
04867 R__insp.Inspect(R__cl, R__parent, "EW", &EW);
04868 R__insp.Inspect(R__cl, R__parent, "WE", &WE);
04869 R__insp.Inspect(R__cl, R__parent, "TY", &TY);
04870 R__insp.Inspect(R__cl, R__parent, "LE", &LE);
04871 R__insp.Inspect(R__cl, R__parent, "LT", <);
04872 R__insp.Inspect(R__cl, R__parent, "LH", &LH);
04873 R__insp.Inspect(R__cl, R__parent, "LC", &LC);
04874 R__insp.Inspect(R__cl, R__parent, "LJ", &LJ);
04875 TObject::ShowMembers(R__insp, R__parent);
04876 }
04877
04878 namespace ROOT {
04879
04880 TClass *EFOL_IsA(const void *obj) {
04881 return ((::EFOL*)obj)->IsA();
04882 }
04883
04884 void *new_EFOL(void *p) {
04885 return p ? new(p) ::EFOL : new ::EFOL;
04886 }
04887 void *newArray_EFOL(Long_t size) {
04888 return new ::EFOL[size];
04889 }
04890
04891 void delete_EFOL(void *p) {
04892 delete ((::EFOL*)p);
04893 }
04894 void deleteArray_EFOL(void *p) {
04895 delete [] ((::EFOL*)p);
04896 }
04897 void destruct_EFOL(void *p) {
04898 typedef ::EFOL current_t;
04899 ((current_t*)p)->~current_t();
04900 }
04901 }
04902
04903
04904 void PCQA::Streamer(TBuffer &R__b)
04905 {
04906
04907
04908 if (R__b.IsReading()) {
04909 PCQA::Class()->ReadBuffer(R__b, this);
04910 } else {
04911 PCQA::Class()->WriteBuffer(R__b, this);
04912 }
04913 }
04914
04915
04916 void PCQA::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04917 {
04918
04919
04920 TClass *R__cl = PCQA::IsA();
04921 Int_t R__ncp = strlen(R__parent);
04922 if (R__ncp || R__cl || R__insp.IsA()) { }
04923 R__insp.Inspect(R__cl, R__parent, "NA", &NA);
04924 R__insp.Inspect(R__cl, R__parent, "PX", &PX);
04925 R__insp.Inspect(R__cl, R__parent, "PY", &PY);
04926 R__insp.Inspect(R__cl, R__parent, "PZ", &PZ);
04927 R__insp.Inspect(R__cl, R__parent, "EN", &EN);
04928 TObject::ShowMembers(R__insp, R__parent);
04929 }
04930
04931 namespace ROOT {
04932
04933 TClass *PCQA_IsA(const void *obj) {
04934 return ((::PCQA*)obj)->IsA();
04935 }
04936
04937 void *new_PCQA(void *p) {
04938 return p ? new(p) ::PCQA : new ::PCQA;
04939 }
04940 void *newArray_PCQA(Long_t size) {
04941 return new ::PCQA[size];
04942 }
04943
04944 void delete_PCQA(void *p) {
04945 delete ((::PCQA*)p);
04946 }
04947 void deleteArray_PCQA(void *p) {
04948 delete [] ((::PCQA*)p);
04949 }
04950 void destruct_PCQA(void *p) {
04951 typedef ::PCQA current_t;
04952 ((current_t*)p)->~current_t();
04953 }
04954 }
04955
04956
04957 void EGPC::Streamer(TBuffer &R__b)
04958 {
04959
04960
04961 if (R__b.IsReading()) {
04962 EGPC::Class()->ReadBuffer(R__b, this);
04963 } else {
04964 EGPC::Class()->WriteBuffer(R__b, this);
04965 }
04966 }
04967
04968
04969 void EGPC::ShowMembers(TMemberInspector &R__insp, char *R__parent)
04970 {
04971
04972
04973 TClass *R__cl = EGPC::IsA();
04974 Int_t R__ncp = strlen(R__parent);
04975 if (R__ncp || R__cl || R__insp.IsA()) { }
04976 R__insp.Inspect(R__cl, R__parent, "PX", &PX);
04977 R__insp.Inspect(R__cl, R__parent, "PY", &PY);
04978 R__insp.Inspect(R__cl, R__parent, "PZ", &PZ);
04979 R__insp.Inspect(R__cl, R__parent, "R1", &R1);
04980 R__insp.Inspect(R__cl, R__parent, "R2", &R2);
04981 R__insp.Inspect(R__cl, R__parent, "F4", &F4);
04982 R__insp.Inspect(R__cl, R__parent, "DM", &DM);
04983 R__insp.Inspect(R__cl, R__parent, "ST", &ST);
04984 R__insp.Inspect(R__cl, R__parent, "QU", &QU);
04985 R__insp.Inspect(R__cl, R__parent, "PE", &PE);
04986 TObject::ShowMembers(R__insp, R__parent);
04987 }
04988
04989 namespace ROOT {
04990
04991 TClass *EGPC_IsA(const void *obj) {
04992 return ((::EGPC*)obj)->IsA();
04993 }
04994
04995 void *new_EGPC(void *p) {
04996 return p ? new(p) ::EGPC : new ::EGPC;
04997 }
04998 void *newArray_EGPC(Long_t size) {
04999 return new ::EGPC[size];
05000 }
05001
05002 void delete_EGPC(void *p) {
05003 delete ((::EGPC*)p);
05004 }
05005 void deleteArray_EGPC(void *p) {
05006 delete [] ((::EGPC*)p);
05007 }
05008 void destruct_EGPC(void *p) {
05009 typedef ::EGPC current_t;
05010 ((current_t*)p)->~current_t();
05011 }
05012 }
05013
05014
05015 void MUID::Streamer(TBuffer &R__b)
05016 {
05017
05018
05019 if (R__b.IsReading()) {
05020 MUID::Class()->ReadBuffer(R__b, this);
05021 } else {
05022 MUID::Class()->WriteBuffer(R__b, this);
05023 }
05024 }
05025
05026
05027 void MUID::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05028 {
05029
05030
05031 TClass *R__cl = MUID::IsA();
05032 Int_t R__ncp = strlen(R__parent);
05033 if (R__ncp || R__cl || R__insp.IsA()) { }
05034 R__insp.Inspect(R__cl, R__parent, "IF", &IF);
05035 R__insp.Inspect(R__cl, R__parent, "SR", &SR);
05036 R__insp.Inspect(R__cl, R__parent, "DM", &DM);
05037 R__insp.Inspect(R__cl, R__parent, "ST", &ST);
05038 R__insp.Inspect(R__cl, R__parent, "TN", &TN);
05039 TObject::ShowMembers(R__insp, R__parent);
05040 }
05041
05042 namespace ROOT {
05043
05044 TClass *MUID_IsA(const void *obj) {
05045 return ((::MUID*)obj)->IsA();
05046 }
05047
05048 void *new_MUID(void *p) {
05049 return p ? new(p) ::MUID : new ::MUID;
05050 }
05051 void *newArray_MUID(Long_t size) {
05052 return new ::MUID[size];
05053 }
05054
05055 void delete_MUID(void *p) {
05056 delete ((::MUID*)p);
05057 }
05058 void deleteArray_MUID(void *p) {
05059 delete [] ((::MUID*)p);
05060 }
05061 void destruct_MUID(void *p) {
05062 typedef ::MUID current_t;
05063 ((current_t*)p)->~current_t();
05064 }
05065 }
05066
05067
05068 void PGPC::Streamer(TBuffer &R__b)
05069 {
05070
05071
05072 if (R__b.IsReading()) {
05073 PGPC::Class()->ReadBuffer(R__b, this);
05074 } else {
05075 PGPC::Class()->WriteBuffer(R__b, this);
05076 }
05077 }
05078
05079
05080 void PGPC::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05081 {
05082
05083
05084 TClass *R__cl = PGPC::IsA();
05085 Int_t R__ncp = strlen(R__parent);
05086 if (R__ncp || R__cl || R__insp.IsA()) { }
05087 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
05088 R__insp.Inspect(R__cl, R__parent, "TC", &TC);
05089 R__insp.Inspect(R__cl, R__parent, "PC", &PC);
05090 R__insp.Inspect(R__cl, R__parent, "R1", &R1);
05091 R__insp.Inspect(R__cl, R__parent, "R2", &R2);
05092 R__insp.Inspect(R__cl, R__parent, "F4", &F4);
05093 R__insp.Inspect(R__cl, R__parent, "DM", &DM);
05094 R__insp.Inspect(R__cl, R__parent, "ST", &ST);
05095 R__insp.Inspect(R__cl, R__parent, "QU", &QU);
05096 R__insp.Inspect(R__cl, R__parent, "Q1", &Q1);
05097 R__insp.Inspect(R__cl, R__parent, "Q2", &Q2);
05098 R__insp.Inspect(R__cl, R__parent, "M1", &M1);
05099 R__insp.Inspect(R__cl, R__parent, "M2", &M2);
05100 R__insp.Inspect(R__cl, R__parent, "MA", &MA);
05101 R__insp.Inspect(R__cl, R__parent, "ER", &ER);
05102 R__insp.Inspect(R__cl, R__parent, "TR", &TR);
05103 R__insp.Inspect(R__cl, R__parent, "PR", &PR);
05104 R__insp.Inspect(R__cl, R__parent, "PE", &PE);
05105 TObject::ShowMembers(R__insp, R__parent);
05106 }
05107
05108 namespace ROOT {
05109
05110 TClass *PGPC_IsA(const void *obj) {
05111 return ((::PGPC*)obj)->IsA();
05112 }
05113
05114 void *new_PGPC(void *p) {
05115 return p ? new(p) ::PGPC : new ::PGPC;
05116 }
05117 void *newArray_PGPC(Long_t size) {
05118 return new ::PGPC[size];
05119 }
05120
05121 void delete_PGPC(void *p) {
05122 delete ((::PGPC*)p);
05123 }
05124 void deleteArray_PGPC(void *p) {
05125 delete [] ((::PGPC*)p);
05126 }
05127 void destruct_PGPC(void *p) {
05128 typedef ::PGPC current_t;
05129 ((current_t*)p)->~current_t();
05130 }
05131 }
05132
05133
05134 void PGAC::Streamer(TBuffer &R__b)
05135 {
05136
05137
05138 if (R__b.IsReading()) {
05139 PGAC::Class()->ReadBuffer(R__b, this);
05140 } else {
05141 PGAC::Class()->WriteBuffer(R__b, this);
05142 }
05143 }
05144
05145
05146 void PGAC::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05147 {
05148
05149
05150 TClass *R__cl = PGAC::IsA();
05151 Int_t R__ncp = strlen(R__parent);
05152 if (R__ncp || R__cl || R__insp.IsA()) { }
05153 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
05154 R__insp.Inspect(R__cl, R__parent, "TC", &TC);
05155 R__insp.Inspect(R__cl, R__parent, "PC", &PC);
05156 R__insp.Inspect(R__cl, R__parent, "R1", &R1);
05157 R__insp.Inspect(R__cl, R__parent, "R2", &R2);
05158 R__insp.Inspect(R__cl, R__parent, "F4", &F4);
05159 R__insp.Inspect(R__cl, R__parent, "DM", &DM);
05160 R__insp.Inspect(R__cl, R__parent, "ST", &ST);
05161 R__insp.Inspect(R__cl, R__parent, "QU", &QU);
05162 R__insp.Inspect(R__cl, R__parent, "Q1", &Q1);
05163 R__insp.Inspect(R__cl, R__parent, "Q2", &Q2);
05164 R__insp.Inspect(R__cl, R__parent, "M1", &M1);
05165 R__insp.Inspect(R__cl, R__parent, "M2", &M2);
05166 R__insp.Inspect(R__cl, R__parent, "MA", &MA);
05167 R__insp.Inspect(R__cl, R__parent, "ER", &ER);
05168 R__insp.Inspect(R__cl, R__parent, "TR", &TR);
05169 R__insp.Inspect(R__cl, R__parent, "PR", &PR);
05170 R__insp.Inspect(R__cl, R__parent, "EF", &EF);
05171 R__insp.Inspect(R__cl, R__parent, "GC", &GC);
05172 R__insp.Inspect(R__cl, R__parent, "ZS", &ZS);
05173 R__insp.Inspect(R__cl, R__parent, "PL", &PL);
05174 R__insp.Inspect(R__cl, R__parent, "PH", &PH);
05175 R__insp.Inspect(R__cl, R__parent, "PN", &PN);
05176 R__insp.Inspect(R__cl, R__parent, "FA", &FA);
05177 R__insp.Inspect(R__cl, R__parent, "PE", &PE);
05178 TObject::ShowMembers(R__insp, R__parent);
05179 }
05180
05181 namespace ROOT {
05182
05183 TClass *PGAC_IsA(const void *obj) {
05184 return ((::PGAC*)obj)->IsA();
05185 }
05186
05187 void *new_PGAC(void *p) {
05188 return p ? new(p) ::PGAC : new ::PGAC;
05189 }
05190 void *newArray_PGAC(Long_t size) {
05191 return new ::PGAC[size];
05192 }
05193
05194 void delete_PGAC(void *p) {
05195 delete ((::PGAC*)p);
05196 }
05197 void deleteArray_PGAC(void *p) {
05198 delete [] ((::PGAC*)p);
05199 }
05200 void destruct_PGAC(void *p) {
05201 typedef ::PGAC current_t;
05202 ((current_t*)p)->~current_t();
05203 }
05204 }
05205
05206
05207 void PDLT::Streamer(TBuffer &R__b)
05208 {
05209
05210
05211 if (R__b.IsReading()) {
05212 PDLT::Class()->ReadBuffer(R__b, this);
05213 } else {
05214 PDLT::Class()->WriteBuffer(R__b, this);
05215 }
05216 }
05217
05218
05219 void PDLT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05220 {
05221
05222
05223 TClass *R__cl = PDLT::IsA();
05224 Int_t R__ncp = strlen(R__parent);
05225 if (R__ncp || R__cl || R__insp.IsA()) { }
05226 R__insp.Inspect(R__cl, R__parent, "PA", &PA);
05227 R__insp.Inspect(R__cl, R__parent, "JT", &JT);
05228 R__insp.Inspect(R__cl, R__parent, "PI", &PI);
05229 R__insp.Inspect(R__cl, R__parent, "PE", &PE);
05230 R__insp.Inspect(R__cl, R__parent, "VP", &VP);
05231 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
05232 TObject::ShowMembers(R__insp, R__parent);
05233 }
05234
05235 namespace ROOT {
05236
05237 TClass *PDLT_IsA(const void *obj) {
05238 return ((::PDLT*)obj)->IsA();
05239 }
05240
05241 void *new_PDLT(void *p) {
05242 return p ? new(p) ::PDLT : new ::PDLT;
05243 }
05244 void *newArray_PDLT(Long_t size) {
05245 return new ::PDLT[size];
05246 }
05247
05248 void delete_PDLT(void *p) {
05249 delete ((::PDLT*)p);
05250 }
05251 void deleteArray_PDLT(void *p) {
05252 delete [] ((::PDLT*)p);
05253 }
05254 void destruct_PDLT(void *p) {
05255 typedef ::PDLT current_t;
05256 ((current_t*)p)->~current_t();
05257 }
05258 }
05259
05260
05261 void PMLT::Streamer(TBuffer &R__b)
05262 {
05263
05264
05265 if (R__b.IsReading()) {
05266 PMLT::Class()->ReadBuffer(R__b, this);
05267 } else {
05268 PMLT::Class()->WriteBuffer(R__b, this);
05269 }
05270 }
05271
05272
05273 void PMLT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05274 {
05275
05276
05277 TClass *R__cl = PMLT::IsA();
05278 Int_t R__ncp = strlen(R__parent);
05279 if (R__ncp || R__cl || R__insp.IsA()) { }
05280 R__insp.Inspect(R__cl, R__parent, "FL", &FL);
05281 R__insp.Inspect(R__cl, R__parent, "PO", &PO);
05282 R__insp.Inspect(R__cl, R__parent, "CH", &CH);
05283 R__insp.Inspect(R__cl, R__parent, "SP", &SP);
05284 R__insp.Inspect(R__cl, R__parent, "LE", &LE);
05285 R__insp.Inspect(R__cl, R__parent, "ME", &ME);
05286 R__insp.Inspect(R__cl, R__parent, "KT", &KT);
05287 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
05288 TObject::ShowMembers(R__insp, R__parent);
05289 }
05290
05291 namespace ROOT {
05292
05293 TClass *PMLT_IsA(const void *obj) {
05294 return ((::PMLT*)obj)->IsA();
05295 }
05296
05297 void *new_PMLT(void *p) {
05298 return p ? new(p) ::PMLT : new ::PMLT;
05299 }
05300 void *newArray_PMLT(Long_t size) {
05301 return new ::PMLT[size];
05302 }
05303
05304 void delete_PMLT(void *p) {
05305 delete ((::PMLT*)p);
05306 }
05307 void deleteArray_PMLT(void *p) {
05308 delete [] ((::PMLT*)p);
05309 }
05310 void destruct_PMLT(void *p) {
05311 typedef ::PMLT current_t;
05312 ((current_t*)p)->~current_t();
05313 }
05314 }
05315
05316
05317 void R__QDET_AF(TBuffer &R__b, void *R__p, int)
05318 {
05319 FRFT** AF = (FRFT**)R__p;
05320 if (R__b.IsReading()) {
05321 R__b >> *AF;
05322 } else {
05323 R__b << (TObject*)*AF;
05324 }
05325 }
05326
05327
05328 void R__QDET_AL(TBuffer &R__b, void *R__p, int)
05329 {
05330 FRTL** AL = (FRTL**)R__p;
05331 if (R__b.IsReading()) {
05332 R__b >> *AL;
05333 } else {
05334 R__b << (TObject*)*AL;
05335 }
05336 }
05337
05338
05339 void R__QDET_AT(TBuffer &R__b, void *R__p, int)
05340 {
05341 TEXS** AT = (TEXS**)R__p;
05342 if (R__b.IsReading()) {
05343 for (Int_t R__l = 0; R__l < 4; R__l++) {
05344 R__b >> AT[R__l];
05345 }
05346 } else {
05347 for (Int_t R__l = 0; R__l < 4; R__l++) {
05348 R__b << (TObject*)AT[R__l];
05349 }
05350 }
05351 }
05352
05353
05354 void R__QDET_LT(TBuffer &R__b, void *R__p, int)
05355 {
05356 TEXS** LT = (TEXS**)R__p;
05357 if (R__b.IsReading()) {
05358 R__b >> *LT;
05359 } else {
05360 R__b << (TObject*)*LT;
05361 }
05362 }
05363
05364
05365 void R__QDET_AE(TBuffer &R__b, void *R__p, int)
05366 {
05367 EIDT** AE = (EIDT**)R__p;
05368 if (R__b.IsReading()) {
05369 R__b >> *AE;
05370 } else {
05371 R__b << (TObject*)*AE;
05372 }
05373 }
05374
05375
05376 void R__QDET_AH(TBuffer &R__b, void *R__p, int)
05377 {
05378 HMAD** AH = (HMAD**)R__p;
05379 if (R__b.IsReading()) {
05380 R__b >> *AH;
05381 } else {
05382 R__b << (TObject*)*AH;
05383 }
05384 }
05385
05386
05387 void R__QDET_EC(TBuffer &R__b, void *R__p, int)
05388 {
05389 PECO** EC = (PECO**)R__p;
05390 if (R__b.IsReading()) {
05391 R__b >> *EC;
05392 } else {
05393 R__b << (TObject*)*EC;
05394 }
05395 }
05396
05397
05398 void R__QDET_HC(TBuffer &R__b, void *R__p, int)
05399 {
05400 PHCO** HC = (PHCO**)R__p;
05401 if (R__b.IsReading()) {
05402 R__b >> *HC;
05403 } else {
05404 R__b << (TObject*)*HC;
05405 }
05406 }
05407
05408
05409 void R__QDET_ET(TBuffer &R__b, void *R__p, int)
05410 {
05411 PEPT** ET = (PEPT**)R__p;
05412 if (R__b.IsReading()) {
05413 R__b >> *ET;
05414 } else {
05415 R__b << (TObject*)*ET;
05416 }
05417 }
05418
05419
05420 void R__QDET_EF(TBuffer &R__b, void *R__p, int)
05421 {
05422 EFOL** EF = (EFOL**)R__p;
05423 if (R__b.IsReading()) {
05424 R__b >> *EF;
05425 } else {
05426 R__b << (TObject*)*EF;
05427 }
05428 }
05429
05430
05431 void R__QDET_PC(TBuffer &R__b, void *R__p, int)
05432 {
05433 PCQA** PC = (PCQA**)R__p;
05434 if (R__b.IsReading()) {
05435 R__b >> *PC;
05436 } else {
05437 R__b << (TObject*)*PC;
05438 }
05439 }
05440
05441
05442 void R__QDET_EG(TBuffer &R__b, void *R__p, int)
05443 {
05444 EGPC** EG = (EGPC**)R__p;
05445 if (R__b.IsReading()) {
05446 R__b >> *EG;
05447 } else {
05448 R__b << (TObject*)*EG;
05449 }
05450 }
05451
05452
05453 void R__QDET_MU(TBuffer &R__b, void *R__p, int)
05454 {
05455 MUID** MU = (MUID**)R__p;
05456 if (R__b.IsReading()) {
05457 R__b >> *MU;
05458 } else {
05459 R__b << (TObject*)*MU;
05460 }
05461 }
05462
05463
05464 void R__QDET_PG(TBuffer &R__b, void *R__p, int)
05465 {
05466 PGAC** PG = (PGAC**)R__p;
05467 if (R__b.IsReading()) {
05468 R__b >> *PG;
05469 } else {
05470 R__b << (TObject*)*PG;
05471 }
05472 }
05473
05474
05475 void QDET::Streamer(TBuffer &R__b)
05476 {
05477
05478
05479 if (R__b.IsReading()) {
05480 QDET::Class()->ReadBuffer(R__b, this);
05481 } else {
05482 QDET::Class()->WriteBuffer(R__b, this);
05483 }
05484 }
05485
05486
05487 void QDET::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05488 {
05489
05490
05491 TClass *R__cl = QDET::IsA();
05492 Int_t R__ncp = strlen(R__parent);
05493 if (R__ncp || R__cl || R__insp.IsA()) { }
05494 R__insp.Inspect(R__cl, R__parent, "*AF", &AF);
05495 R__cl->SetStreamer("*AF",R__QDET_AF);
05496 R__insp.Inspect(R__cl, R__parent, "*AL", &AL);
05497 R__cl->SetStreamer("*AL",R__QDET_AL);
05498 R__insp.Inspect(R__cl, R__parent, "NT", &NT);
05499 R__insp.Inspect(R__cl, R__parent, "*AT[4]", &AT);
05500 R__cl->SetStreamer("*AT[4]",R__QDET_AT);
05501 R__insp.Inspect(R__cl, R__parent, "*LT", <);
05502 R__cl->SetStreamer("*LT",R__QDET_LT);
05503 R__insp.Inspect(R__cl, R__parent, "*AE", &AE);
05504 R__cl->SetStreamer("*AE",R__QDET_AE);
05505 R__insp.Inspect(R__cl, R__parent, "*AH", &AH);
05506 R__cl->SetStreamer("*AH",R__QDET_AH);
05507 R__insp.Inspect(R__cl, R__parent, "*AM", &AM);
05508 R__insp.Inspect(R__cl, R__parent, "CF", &CF);
05509 R__insp.Inspect(R__cl, R__parent, "*EC", &EC);
05510 R__cl->SetStreamer("*EC",R__QDET_EC);
05511 R__insp.Inspect(R__cl, R__parent, "*HC", &HC);
05512 R__cl->SetStreamer("*HC",R__QDET_HC);
05513 R__insp.Inspect(R__cl, R__parent, "*ET", &ET);
05514 R__cl->SetStreamer("*ET",R__QDET_ET);
05515 R__insp.Inspect(R__cl, R__parent, "*FI", &FI);
05516 R__insp.Inspect(R__cl, R__parent, "NF", &NF);
05517 R__insp.Inspect(R__cl, R__parent, "NE", &NE);
05518 R__insp.Inspect(R__cl, R__parent, "NH", &NH);
05519 R__insp.Inspect(R__cl, R__parent, "LH", &LH);
05520 R__insp.Inspect(R__cl, R__parent, "*EF", &EF);
05521 R__cl->SetStreamer("*EF",R__QDET_EF);
05522 R__insp.Inspect(R__cl, R__parent, "*PC", &PC);
05523 R__cl->SetStreamer("*PC",R__QDET_PC);
05524 R__insp.Inspect(R__cl, R__parent, "*EG", &EG);
05525 R__cl->SetStreamer("*EG",R__QDET_EG);
05526 R__insp.Inspect(R__cl, R__parent, "*MU", &MU);
05527 R__cl->SetStreamer("*MU",R__QDET_MU);
05528 R__insp.Inspect(R__cl, R__parent, "DX", &DX);
05529 R__insp.Inspect(R__cl, R__parent, "*PG", &PG);
05530 R__cl->SetStreamer("*PG",R__QDET_PG);
05531 R__insp.Inspect(R__cl, R__parent, "*PD", &PD);
05532 R__insp.Inspect(R__cl, R__parent, "*PM", &PM);
05533 TObject::ShowMembers(R__insp, R__parent);
05534 }
05535
05536 namespace ROOT {
05537
05538 TClass *QDET_IsA(const void *obj) {
05539 return ((::QDET*)obj)->IsA();
05540 }
05541
05542 void *new_QDET(void *p) {
05543 return p ? new(p) ::QDET : new ::QDET;
05544 }
05545 void *newArray_QDET(Long_t size) {
05546 return new ::QDET[size];
05547 }
05548
05549 void delete_QDET(void *p) {
05550 delete ((::QDET*)p);
05551 }
05552 void deleteArray_QDET(void *p) {
05553 delete [] ((::QDET*)p);
05554 }
05555 void destruct_QDET(void *p) {
05556 typedef ::QDET current_t;
05557 ((current_t*)p)->~current_t();
05558 }
05559 }
05560
05561
05562 void R__QVEC_QD(TBuffer &R__b, void *R__p, int)
05563 {
05564 QDET** QD = (QDET**)R__p;
05565 if (R__b.IsReading()) {
05566 R__b >> *QD;
05567 } else {
05568 R__b << (TObject*)*QD;
05569 }
05570 }
05571
05572
05573 void R__QVEC_NP(TBuffer &R__b, void *R__p, int)
05574 {
05575 QVEC** NP = (QVEC**)R__p;
05576 if (R__b.IsReading()) {
05577 R__b >> *NP;
05578 } else {
05579 R__b << (TObject*)*NP;
05580 }
05581 }
05582
05583
05584 void R__QVEC_SP(TBuffer &R__b, void *R__p, int)
05585 {
05586 QVEC** SP = (QVEC**)R__p;
05587 if (R__b.IsReading()) {
05588 R__b >> *SP;
05589 } else {
05590 R__b << (TObject*)*SP;
05591 }
05592 }
05593
05594
05595 void R__QVEC_DL(TBuffer &R__b, void *R__p, int)
05596 {
05597 vector<unsigned short> &DL = *(vector<unsigned short> *)R__p;
05598 if (R__b.IsReading()) {
05599 {
05600 vector<unsigned short> &R__stl = DL;
05601 R__stl.clear();
05602 int R__i, R__n;
05603 R__b >> R__n;
05604 R__stl.reserve(R__n);
05605 for (R__i = 0; R__i < R__n; R__i++) {
05606 unsigned short R__t;
05607 R__b >> R__t;
05608 R__stl.push_back(R__t);
05609 }
05610 }
05611 } else {
05612 {
05613 vector<unsigned short> &R__stl = DL;
05614 int R__n=(&R__stl) ? int(R__stl.size()) : 0;
05615 R__b << R__n;
05616 if(R__n) {
05617 vector<unsigned short>::iterator R__k;
05618 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
05619 R__b << (*R__k);
05620 }
05621 }
05622 }
05623 }
05624 }
05625
05626
05627 void R__QVEC_OL(TBuffer &R__b, void *R__p, int)
05628 {
05629 vector<unsigned short> &OL = *(vector<unsigned short> *)R__p;
05630 if (R__b.IsReading()) {
05631 {
05632 vector<unsigned short> &R__stl = OL;
05633 R__stl.clear();
05634 int R__i, R__n;
05635 R__b >> R__n;
05636 R__stl.reserve(R__n);
05637 for (R__i = 0; R__i < R__n; R__i++) {
05638 unsigned short R__t;
05639 R__b >> R__t;
05640 R__stl.push_back(R__t);
05641 }
05642 }
05643 } else {
05644 {
05645 vector<unsigned short> &R__stl = OL;
05646 int R__n=(&R__stl) ? int(R__stl.size()) : 0;
05647 R__b << R__n;
05648 if(R__n) {
05649 vector<unsigned short>::iterator R__k;
05650 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
05651 R__b << (*R__k);
05652 }
05653 }
05654 }
05655 }
05656 }
05657
05658
05659 void R__QVEC_ML(TBuffer &R__b, void *R__p, int)
05660 {
05661 vector<unsigned short> &ML = *(vector<unsigned short> *)R__p;
05662 if (R__b.IsReading()) {
05663 {
05664 vector<unsigned short> &R__stl = ML;
05665 R__stl.clear();
05666 int R__i, R__n;
05667 R__b >> R__n;
05668 R__stl.reserve(R__n);
05669 for (R__i = 0; R__i < R__n; R__i++) {
05670 unsigned short R__t;
05671 R__b >> R__t;
05672 R__stl.push_back(R__t);
05673 }
05674 }
05675 } else {
05676 {
05677 vector<unsigned short> &R__stl = ML;
05678 int R__n=(&R__stl) ? int(R__stl.size()) : 0;
05679 R__b << R__n;
05680 if(R__n) {
05681 vector<unsigned short>::iterator R__k;
05682 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
05683 R__b << (*R__k);
05684 }
05685 }
05686 }
05687 }
05688 }
05689
05690
05691 void QVEC::Streamer(TBuffer &R__b)
05692 {
05693
05694
05695 if (R__b.IsReading()) {
05696 QVEC::Class()->ReadBuffer(R__b, this);
05697 } else {
05698 QVEC::Class()->WriteBuffer(R__b, this);
05699 }
05700 }
05701
05702
05703 void QVEC::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05704 {
05705
05706
05707 TClass *R__cl = QVEC::IsA();
05708 Int_t R__ncp = strlen(R__parent);
05709 if (R__ncp || R__cl || R__insp.IsA()) { }
05710 R__insp.Inspect(R__cl, R__parent, "QX", &QX);
05711 R__insp.Inspect(R__cl, R__parent, "QY", &QY);
05712 R__insp.Inspect(R__cl, R__parent, "QZ", &QZ);
05713 R__insp.Inspect(R__cl, R__parent, "QE", &QE);
05714 R__insp.Inspect(R__cl, R__parent, "QM", &QM);
05715 R__insp.Inspect(R__cl, R__parent, "QP", &QP);
05716 R__insp.Inspect(R__cl, R__parent, "QCH", &QCH);
05717 R__insp.Inspect(R__cl, R__parent, "TN", &TN);
05718 R__insp.Inspect(R__cl, R__parent, "SC", &SC);
05719 R__insp.Inspect(R__cl, R__parent, "KS", &KS);
05720 R__insp.Inspect(R__cl, R__parent, "CL", &CL);
05721 R__insp.Inspect(R__cl, R__parent, "PA", &PA);
05722 R__insp.Inspect(R__cl, R__parent, "*QD", &QD);
05723 R__cl->SetStreamer("*QD",R__QVEC_QD);
05724 R__insp.Inspect(R__cl, R__parent, "*NP", &NP);
05725 R__cl->SetStreamer("*NP",R__QVEC_NP);
05726 R__insp.Inspect(R__cl, R__parent, "*SP", &SP);
05727 R__cl->SetStreamer("*SP",R__QVEC_SP);
05728 R__insp.Inspect(R__cl, R__parent, "OV", &OV);
05729 R__insp.Inspect(R__cl, R__parent, "EV", &EV);
05730 R__insp.Inspect(R__cl, R__parent, "ND", &ND);
05731 R__insp.Inspect(R__cl, R__parent, "DL", (void*)&DL);
05732 ROOT::GenericShowMembers("vector<unsigned short>", (void*)&DL, R__insp, strcat(R__parent,"DL."),false);
05733 R__parent[R__ncp] = 0;
05734 R__cl->SetStreamer("DL",R__QVEC_DL);
05735 R__insp.Inspect(R__cl, R__parent, "NO", &NO);
05736 R__insp.Inspect(R__cl, R__parent, "OL", (void*)&OL);
05737 ROOT::GenericShowMembers("vector<unsigned short>", (void*)&OL, R__insp, strcat(R__parent,"OL."),false);
05738 R__parent[R__ncp] = 0;
05739 R__cl->SetStreamer("OL",R__QVEC_OL);
05740 R__insp.Inspect(R__cl, R__parent, "NM", &NM);
05741 R__insp.Inspect(R__cl, R__parent, "ML", (void*)&ML);
05742 ROOT::GenericShowMembers("vector<unsigned short>", (void*)&ML, R__insp, strcat(R__parent,"ML."),false);
05743 R__parent[R__ncp] = 0;
05744 R__cl->SetStreamer("ML",R__QVEC_ML);
05745 R__insp.Inspect(R__cl, R__parent, "BM[14]", BM);
05746 R__insp.Inspect(R__cl, R__parent, "LK", &LK);
05747 R__insp.Inspect(R__cl, R__parent, "DB", &DB);
05748 R__insp.Inspect(R__cl, R__parent, "ZB", &ZB);
05749 R__insp.Inspect(R__cl, R__parent, "SD", &SD);
05750 R__insp.Inspect(R__cl, R__parent, "SZ", &SZ);
05751 R__insp.Inspect(R__cl, R__parent, "CB", &CB);
05752 R__insp.Inspect(R__cl, R__parent, "EM[10]", EM);
05753 R__insp.Inspect(R__cl, R__parent, "CF", &CF);
05754 R__insp.Inspect(R__cl, R__parent, "EW", &EW);
05755 R__insp.Inspect(R__cl, R__parent, "US[18]", US);
05756 TObject::ShowMembers(R__insp, R__parent);
05757 }
05758
05759 namespace ROOT {
05760
05761 TClass *QVEC_IsA(const void *obj) {
05762 return ((::QVEC*)obj)->IsA();
05763 }
05764
05765 void *new_QVEC(void *p) {
05766 return p ? new(p) ::QVEC : new ::QVEC;
05767 }
05768 void *newArray_QVEC(Long_t size) {
05769 return new ::QVEC[size];
05770 }
05771
05772 void delete_QVEC(void *p) {
05773 delete ((::QVEC*)p);
05774 }
05775 void deleteArray_QVEC(void *p) {
05776 delete [] ((::QVEC*)p);
05777 }
05778 void destruct_QVEC(void *p) {
05779 typedef ::QVEC current_t;
05780 ((current_t*)p)->~current_t();
05781 }
05782 }
05783
05784
05785 void YV0V::Streamer(TBuffer &R__b)
05786 {
05787
05788
05789 if (R__b.IsReading()) {
05790 YV0V::Class()->ReadBuffer(R__b, this);
05791 } else {
05792 YV0V::Class()->WriteBuffer(R__b, this);
05793 }
05794 }
05795
05796
05797 void YV0V::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05798 {
05799
05800
05801 TClass *R__cl = YV0V::IsA();
05802 Int_t R__ncp = strlen(R__parent);
05803 if (R__ncp || R__cl || R__insp.IsA()) { }
05804 R__insp.Inspect(R__cl, R__parent, "K1", &K1);
05805 R__insp.Inspect(R__cl, R__parent, "K2", &K2);
05806 R__insp.Inspect(R__cl, R__parent, "VX", &VX);
05807 R__insp.Inspect(R__cl, R__parent, "VY", &VY);
05808 R__insp.Inspect(R__cl, R__parent, "VZ", &VZ);
05809 R__insp.Inspect(R__cl, R__parent, "VM[6]", VM);
05810 R__insp.Inspect(R__cl, R__parent, "PX", &PX);
05811 R__insp.Inspect(R__cl, R__parent, "PY", &PY);
05812 R__insp.Inspect(R__cl, R__parent, "PZ", &PZ);
05813 R__insp.Inspect(R__cl, R__parent, "PM[6]", PM);
05814 R__insp.Inspect(R__cl, R__parent, "X1", &X1);
05815 R__insp.Inspect(R__cl, R__parent, "X2", &X2);
05816 R__insp.Inspect(R__cl, R__parent, "XM[3]", XM);
05817 R__insp.Inspect(R__cl, R__parent, "C2", &C2);
05818 R__insp.Inspect(R__cl, R__parent, "IC", &IC);
05819 R__insp.Inspect(R__cl, R__parent, "P1[3]", P1);
05820 R__insp.Inspect(R__cl, R__parent, "P2[3]", P2);
05821 R__insp.Inspect(R__cl, R__parent, "EP[21]", EP);
05822 R__insp.Inspect(R__cl, R__parent, "DM", &DM);
05823 R__insp.Inspect(R__cl, R__parent, "S1", &S1);
05824 R__insp.Inspect(R__cl, R__parent, "S2", &S2);
05825 TObject::ShowMembers(R__insp, R__parent);
05826 }
05827
05828 namespace ROOT {
05829
05830 TClass *YV0V_IsA(const void *obj) {
05831 return ((::YV0V*)obj)->IsA();
05832 }
05833
05834 void *new_YV0V(void *p) {
05835 return p ? new(p) ::YV0V : new ::YV0V;
05836 }
05837 void *newArray_YV0V(Long_t size) {
05838 return new ::YV0V[size];
05839 }
05840
05841 void delete_YV0V(void *p) {
05842 delete ((::YV0V*)p);
05843 }
05844 void deleteArray_YV0V(void *p) {
05845 delete [] ((::YV0V*)p);
05846 }
05847 void destruct_YV0V(void *p) {
05848 typedef ::YV0V current_t;
05849 ((current_t*)p)->~current_t();
05850 }
05851 }
05852
05853
05854 void FKIN::Streamer(TBuffer &R__b)
05855 {
05856
05857
05858 if (R__b.IsReading()) {
05859 FKIN::Class()->ReadBuffer(R__b, this);
05860 } else {
05861 FKIN::Class()->WriteBuffer(R__b, this);
05862 }
05863 }
05864
05865
05866 void FKIN::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05867 {
05868
05869
05870 TClass *R__cl = FKIN::IsA();
05871 Int_t R__ncp = strlen(R__parent);
05872 if (R__ncp || R__cl || R__insp.IsA()) { }
05873 R__insp.Inspect(R__cl, R__parent, "PX", &PX);
05874 R__insp.Inspect(R__cl, R__parent, "PY", &PY);
05875 R__insp.Inspect(R__cl, R__parent, "PZ", &PZ);
05876 R__insp.Inspect(R__cl, R__parent, "MA", &MA);
05877 R__insp.Inspect(R__cl, R__parent, "PA", &PA);
05878 R__insp.Inspect(R__cl, R__parent, "OV", &OV);
05879 R__insp.Inspect(R__cl, R__parent, "EV", &EV);
05880 R__insp.Inspect(R__cl, R__parent, "HC", &HC);
05881 TObject::ShowMembers(R__insp, R__parent);
05882 }
05883
05884 namespace ROOT {
05885
05886 TClass *FKIN_IsA(const void *obj) {
05887 return ((::FKIN*)obj)->IsA();
05888 }
05889
05890 void *new_FKIN(void *p) {
05891 return p ? new(p) ::FKIN : new ::FKIN;
05892 }
05893 void *newArray_FKIN(Long_t size) {
05894 return new ::FKIN[size];
05895 }
05896
05897 void delete_FKIN(void *p) {
05898 delete ((::FKIN*)p);
05899 }
05900 void deleteArray_FKIN(void *p) {
05901 delete [] ((::FKIN*)p);
05902 }
05903 void destruct_FKIN(void *p) {
05904 typedef ::FKIN current_t;
05905 ((current_t*)p)->~current_t();
05906 }
05907 }
05908
05909
05910 void R__FVER_IP(TBuffer &R__b, void *R__p, int)
05911 {
05912 FKIN** IP = (FKIN**)R__p;
05913 if (R__b.IsReading()) {
05914 R__b >> *IP;
05915 } else {
05916 R__b << (TObject*)*IP;
05917 }
05918 }
05919
05920
05921 void R__FVER_IS(TBuffer &R__b, void *R__p, int)
05922 {
05923 vector<FKIN*> &IS = *(vector<FKIN*> *)R__p;
05924 if (R__b.IsReading()) {
05925 {
05926 vector<FKIN*> &R__stl = IS;
05927 R__stl.clear();
05928 TClass *R__tcl1 = TBuffer::GetClass(typeid(FKIN));
05929 int R__i, R__n;
05930 R__b >> R__n;
05931 R__stl.reserve(R__n);
05932 for (R__i = 0; R__i < R__n; R__i++) {
05933 FKIN* R__t;
05934 R__t = (FKIN*)R__b.ReadObjectAny(R__tcl1);
05935 R__stl.push_back(R__t);
05936 }
05937 }
05938 } else {
05939 {
05940 vector<FKIN*> &R__stl = IS;
05941 int R__n=(&R__stl) ? int(R__stl.size()) : 0;
05942 R__b << R__n;
05943 if(R__n) {
05944 vector<FKIN*>::iterator R__k;
05945 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
05946 R__b << (*R__k);
05947 }
05948 }
05949 }
05950 }
05951 }
05952
05953
05954 void FVER::Streamer(TBuffer &R__b)
05955 {
05956
05957
05958 if (R__b.IsReading()) {
05959 FVER::Class()->ReadBuffer(R__b, this);
05960 } else {
05961 FVER::Class()->WriteBuffer(R__b, this);
05962 }
05963 }
05964
05965
05966 void FVER::ShowMembers(TMemberInspector &R__insp, char *R__parent)
05967 {
05968
05969
05970 TClass *R__cl = FVER::IsA();
05971 Int_t R__ncp = strlen(R__parent);
05972 if (R__ncp || R__cl || R__insp.IsA()) { }
05973 R__insp.Inspect(R__cl, R__parent, "VX", &VX);
05974 R__insp.Inspect(R__cl, R__parent, "VY", &VY);
05975 R__insp.Inspect(R__cl, R__parent, "VZ", &VZ);
05976 R__insp.Inspect(R__cl, R__parent, "TO", &TO);
05977 R__insp.Inspect(R__cl, R__parent, "*IP", &IP);
05978 R__cl->SetStreamer("*IP",R__FVER_IP);
05979 R__insp.Inspect(R__cl, R__parent, "IS", (void*)&IS);
05980 ROOT::GenericShowMembers("vector<FKIN*>", (void*)&IS, R__insp, strcat(R__parent,"IS."),false);
05981 R__parent[R__ncp] = 0;
05982 R__cl->SetStreamer("IS",R__FVER_IS);
05983 R__insp.Inspect(R__cl, R__parent, "NS", &NS);
05984 R__insp.Inspect(R__cl, R__parent, "VN[4]", VN);
05985 R__insp.Inspect(R__cl, R__parent, "VM[4]", VM);
05986 TObject::ShowMembers(R__insp, R__parent);
05987 }
05988
05989 namespace ROOT {
05990
05991 TClass *FVER_IsA(const void *obj) {
05992 return ((::FVER*)obj)->IsA();
05993 }
05994
05995 void *new_FVER(void *p) {
05996 return p ? new(p) ::FVER : new ::FVER;
05997 }
05998 void *newArray_FVER(Long_t size) {
05999 return new ::FVER[size];
06000 }
06001
06002 void delete_FVER(void *p) {
06003 delete ((::FVER*)p);
06004 }
06005 void deleteArray_FVER(void *p) {
06006 delete [] ((::FVER*)p);
06007 }
06008 void destruct_FVER(void *p) {
06009 typedef ::FVER current_t;
06010 ((current_t*)p)->~current_t();
06011 }
06012 }
06013
06014
06015 void R__QVRT_DL(TBuffer &R__b, void *R__p, int)
06016 {
06017 vector<unsigned short> &DL = *(vector<unsigned short> *)R__p;
06018 if (R__b.IsReading()) {
06019 {
06020 vector<unsigned short> &R__stl = DL;
06021 R__stl.clear();
06022 int R__i, R__n;
06023 R__b >> R__n;
06024 R__stl.reserve(R__n);
06025 for (R__i = 0; R__i < R__n; R__i++) {
06026 unsigned short R__t;
06027 R__b >> R__t;
06028 R__stl.push_back(R__t);
06029 }
06030 }
06031 } else {
06032 {
06033 vector<unsigned short> &R__stl = DL;
06034 int R__n=(&R__stl) ? int(R__stl.size()) : 0;
06035 R__b << R__n;
06036 if(R__n) {
06037 vector<unsigned short>::iterator R__k;
06038 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
06039 R__b << (*R__k);
06040 }
06041 }
06042 }
06043 }
06044 }
06045
06046
06047 void R__QVRT_AY(TBuffer &R__b, void *R__p, int)
06048 {
06049 YV0V** AY = (YV0V**)R__p;
06050 if (R__b.IsReading()) {
06051 R__b >> *AY;
06052 } else {
06053 R__b << (TObject*)*AY;
06054 }
06055 }
06056
06057
06058 void R__QVRT_AF(TBuffer &R__b, void *R__p, int)
06059 {
06060 FVER** AF = (FVER**)R__p;
06061 if (R__b.IsReading()) {
06062 R__b >> *AF;
06063 } else {
06064 R__b << (TObject*)*AF;
06065 }
06066 }
06067
06068
06069 void QVRT::Streamer(TBuffer &R__b)
06070 {
06071
06072
06073 if (R__b.IsReading()) {
06074 QVRT::Class()->ReadBuffer(R__b, this);
06075 } else {
06076 QVRT::Class()->WriteBuffer(R__b, this);
06077 }
06078 }
06079
06080
06081 void QVRT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06082 {
06083
06084
06085 TClass *R__cl = QVRT::IsA();
06086 Int_t R__ncp = strlen(R__parent);
06087 if (R__ncp || R__cl || R__insp.IsA()) { }
06088 R__insp.Inspect(R__cl, R__parent, "VX", &VX);
06089 R__insp.Inspect(R__cl, R__parent, "VY", &VY);
06090 R__insp.Inspect(R__cl, R__parent, "VZ", &VZ);
06091 R__insp.Inspect(R__cl, R__parent, "VN", &VN);
06092 R__insp.Inspect(R__cl, R__parent, "TY", &TY);
06093 R__insp.Inspect(R__cl, R__parent, "IP", &IP);
06094 R__insp.Inspect(R__cl, R__parent, "ND", &ND);
06095 R__insp.Inspect(R__cl, R__parent, "DL", (void*)&DL);
06096 ROOT::GenericShowMembers("vector<unsigned short>", (void*)&DL, R__insp, strcat(R__parent,"DL."),false);
06097 R__parent[R__ncp] = 0;
06098 R__cl->SetStreamer("DL",R__QVRT_DL);
06099 R__insp.Inspect(R__cl, R__parent, "*AY", &AY);
06100 R__cl->SetStreamer("*AY",R__QVRT_AY);
06101 R__insp.Inspect(R__cl, R__parent, "*AF", &AF);
06102 R__cl->SetStreamer("*AF",R__QVRT_AF);
06103 R__insp.Inspect(R__cl, R__parent, "EM[6]", EM);
06104 R__insp.Inspect(R__cl, R__parent, "CF", &CF);
06105 R__insp.Inspect(R__cl, R__parent, "ET[7]", ET);
06106 R__insp.Inspect(R__cl, R__parent, "US", &US);
06107 R__insp.Inspect(R__cl, R__parent, "PK", &PK);
06108 R__insp.Inspect(R__cl, R__parent, "PT", &PT);
06109 R__insp.Inspect(R__cl, R__parent, "PL", &PL);
06110 R__insp.Inspect(R__cl, R__parent, "HY", &HY);
06111 TObject::ShowMembers(R__insp, R__parent);
06112 }
06113
06114 namespace ROOT {
06115
06116 TClass *QVRT_IsA(const void *obj) {
06117 return ((::QVRT*)obj)->IsA();
06118 }
06119
06120 void *new_QVRT(void *p) {
06121 return p ? new(p) ::QVRT : new ::QVRT;
06122 }
06123 void *newArray_QVRT(Long_t size) {
06124 return new ::QVRT[size];
06125 }
06126
06127 void delete_QVRT(void *p) {
06128 delete ((::QVRT*)p);
06129 }
06130 void deleteArray_QVRT(void *p) {
06131 delete [] ((::QVRT*)p);
06132 }
06133 void destruct_QVRT(void *p) {
06134 typedef ::QVRT current_t;
06135 ((current_t*)p)->~current_t();
06136 }
06137 }
06138
06139
06140 void ALPB::Streamer(TBuffer &R__b)
06141 {
06142
06143
06144 if (R__b.IsReading()) {
06145 ALPB::Class()->ReadBuffer(R__b, this);
06146 } else {
06147 ALPB::Class()->WriteBuffer(R__b, this);
06148 }
06149 }
06150
06151
06152 void ALPB::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06153 {
06154
06155
06156 TClass *R__cl = ALPB::IsA();
06157 Int_t R__ncp = strlen(R__parent);
06158 if (R__ncp || R__cl || R__insp.IsA()) { }
06159 R__insp.Inspect(R__cl, R__parent, "FE", &FE);
06160 R__insp.Inspect(R__cl, R__parent, "XP", &XP);
06161 R__insp.Inspect(R__cl, R__parent, "XE", &XE);
06162 R__insp.Inspect(R__cl, R__parent, "YP", &YP);
06163 R__insp.Inspect(R__cl, R__parent, "YE", &YE);
06164 TObject::ShowMembers(R__insp, R__parent);
06165 }
06166
06167 namespace ROOT {
06168
06169 TClass *ALPB_IsA(const void *obj) {
06170 return ((::ALPB*)obj)->IsA();
06171 }
06172
06173 void *new_ALPB(void *p) {
06174 return p ? new(p) ::ALPB : new ::ALPB;
06175 }
06176 void *newArray_ALPB(Long_t size) {
06177 return new ::ALPB[size];
06178 }
06179
06180 void delete_ALPB(void *p) {
06181 delete ((::ALPB*)p);
06182 }
06183 void deleteArray_ALPB(void *p) {
06184 delete [] ((::ALPB*)p);
06185 }
06186 void destruct_ALPB(void *p) {
06187 typedef ::ALPB current_t;
06188 ((current_t*)p)->~current_t();
06189 }
06190 }
06191
06192
06193 void ALRP::Streamer(TBuffer &R__b)
06194 {
06195
06196
06197 if (R__b.IsReading()) {
06198 ALRP::Class()->ReadBuffer(R__b, this);
06199 } else {
06200 ALRP::Class()->WriteBuffer(R__b, this);
06201 }
06202 }
06203
06204
06205 void ALRP::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06206 {
06207
06208
06209 TClass *R__cl = ALRP::IsA();
06210 Int_t R__ncp = strlen(R__parent);
06211 if (R__ncp || R__cl || R__insp.IsA()) { }
06212 R__insp.Inspect(R__cl, R__parent, "PN", &PN);
06213 R__insp.Inspect(R__cl, R__parent, "WE", &WE);
06214 R__insp.Inspect(R__cl, R__parent, "ER", &ER);
06215 R__insp.Inspect(R__cl, R__parent, "XS", &XS);
06216 R__insp.Inspect(R__cl, R__parent, "YS", &YS);
06217 R__insp.Inspect(R__cl, R__parent, "ZS", &ZS);
06218 R__insp.Inspect(R__cl, R__parent, "XR", &XR);
06219 R__insp.Inspect(R__cl, R__parent, "YR", &YR);
06220 R__insp.Inspect(R__cl, R__parent, "F1", &F1);
06221 R__insp.Inspect(R__cl, R__parent, "M1", &M1);
06222 R__insp.Inspect(R__cl, R__parent, "S1", &S1);
06223 R__insp.Inspect(R__cl, R__parent, "M2", &M2);
06224 R__insp.Inspect(R__cl, R__parent, "S2", &S2);
06225 TObject::ShowMembers(R__insp, R__parent);
06226 }
06227
06228 namespace ROOT {
06229
06230 TClass *ALRP_IsA(const void *obj) {
06231 return ((::ALRP*)obj)->IsA();
06232 }
06233
06234 void *new_ALRP(void *p) {
06235 return p ? new(p) ::ALRP : new ::ALRP;
06236 }
06237 void *newArray_ALRP(Long_t size) {
06238 return new ::ALRP[size];
06239 }
06240
06241 void delete_ALRP(void *p) {
06242 delete ((::ALRP*)p);
06243 }
06244 void deleteArray_ALRP(void *p) {
06245 delete [] ((::ALRP*)p);
06246 }
06247 void destruct_ALRP(void *p) {
06248 typedef ::ALRP current_t;
06249 ((current_t*)p)->~current_t();
06250 }
06251 }
06252
06253
06254 void RNL2::Streamer(TBuffer &R__b)
06255 {
06256
06257
06258 if (R__b.IsReading()) {
06259 RNL2::Class()->ReadBuffer(R__b, this);
06260 } else {
06261 RNL2::Class()->WriteBuffer(R__b, this);
06262 }
06263 }
06264
06265
06266 void RNL2::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06267 {
06268
06269
06270 TClass *R__cl = RNL2::IsA();
06271 Int_t R__ncp = strlen(R__parent);
06272 if (R__ncp || R__cl || R__insp.IsA()) { }
06273 R__insp.Inspect(R__cl, R__parent, "DA", &DA);
06274 R__insp.Inspect(R__cl, R__parent, "TI", &TI);
06275 R__insp.Inspect(R__cl, R__parent, "EN", &EN);
06276 TObject::ShowMembers(R__insp, R__parent);
06277 }
06278
06279 namespace ROOT {
06280
06281 TClass *RNL2_IsA(const void *obj) {
06282 return ((::RNL2*)obj)->IsA();
06283 }
06284
06285 void *new_RNL2(void *p) {
06286 return p ? new(p) ::RNL2 : new ::RNL2;
06287 }
06288 void *newArray_RNL2(Long_t size) {
06289 return new ::RNL2[size];
06290 }
06291
06292 void delete_RNL2(void *p) {
06293 delete ((::RNL2*)p);
06294 }
06295 void deleteArray_RNL2(void *p) {
06296 delete [] ((::RNL2*)p);
06297 }
06298 void destruct_RNL2(void *p) {
06299 typedef ::RNL2 current_t;
06300 ((current_t*)p)->~current_t();
06301 }
06302 }
06303
06304
06305 void RNF2::Streamer(TBuffer &R__b)
06306 {
06307
06308
06309 if (R__b.IsReading()) {
06310 RNF2::Class()->ReadBuffer(R__b, this);
06311 } else {
06312 RNF2::Class()->WriteBuffer(R__b, this);
06313 }
06314 }
06315
06316
06317 void RNF2::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06318 {
06319
06320
06321 TClass *R__cl = RNF2::IsA();
06322 Int_t R__ncp = strlen(R__parent);
06323 if (R__ncp || R__cl || R__insp.IsA()) { }
06324 R__insp.Inspect(R__cl, R__parent, "FN", &FN);
06325 R__insp.Inspect(R__cl, R__parent, "DS", &DS);
06326 R__insp.Inspect(R__cl, R__parent, "TS", &TS);
06327 R__insp.Inspect(R__cl, R__parent, "DE", &DE);
06328 R__insp.Inspect(R__cl, R__parent, "TE", &TE);
06329 R__insp.Inspect(R__cl, R__parent, "FS", &FS);
06330 R__insp.Inspect(R__cl, R__parent, "LS", &LS);
06331 TObject::ShowMembers(R__insp, R__parent);
06332 }
06333
06334 namespace ROOT {
06335
06336 TClass *RNF2_IsA(const void *obj) {
06337 return ((::RNF2*)obj)->IsA();
06338 }
06339
06340 void *new_RNF2(void *p) {
06341 return p ? new(p) ::RNF2 : new ::RNF2;
06342 }
06343 void *newArray_RNF2(Long_t size) {
06344 return new ::RNF2[size];
06345 }
06346
06347 void delete_RNF2(void *p) {
06348 delete ((::RNF2*)p);
06349 }
06350 void deleteArray_RNF2(void *p) {
06351 delete [] ((::RNF2*)p);
06352 }
06353 void destruct_RNF2(void *p) {
06354 typedef ::RNF2 current_t;
06355 ((current_t*)p)->~current_t();
06356 }
06357 }
06358
06359
06360 void RNR2::Streamer(TBuffer &R__b)
06361 {
06362
06363
06364 if (R__b.IsReading()) {
06365 RNR2::Class()->ReadBuffer(R__b, this);
06366 } else {
06367 RNR2::Class()->WriteBuffer(R__b, this);
06368 }
06369 }
06370
06371
06372 void RNR2::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06373 {
06374
06375
06376 TClass *R__cl = RNR2::IsA();
06377 Int_t R__ncp = strlen(R__parent);
06378 if (R__ncp || R__cl || R__insp.IsA()) { }
06379 R__insp.Inspect(R__cl, R__parent, "RN", &RN);
06380 R__insp.Inspect(R__cl, R__parent, "EN", &EN);
06381 TObject::ShowMembers(R__insp, R__parent);
06382 }
06383
06384 namespace ROOT {
06385
06386 TClass *RNR2_IsA(const void *obj) {
06387 return ((::RNR2*)obj)->IsA();
06388 }
06389
06390 void *new_RNR2(void *p) {
06391 return p ? new(p) ::RNR2 : new ::RNR2;
06392 }
06393 void *newArray_RNR2(Long_t size) {
06394 return new ::RNR2[size];
06395 }
06396
06397 void delete_RNR2(void *p) {
06398 delete ((::RNR2*)p);
06399 }
06400 void deleteArray_RNR2(void *p) {
06401 delete [] ((::RNR2*)p);
06402 }
06403 void destruct_RNR2(void *p) {
06404 typedef ::RNR2 current_t;
06405 ((current_t*)p)->~current_t();
06406 }
06407 }
06408
06409
06410 void RLEP::Streamer(TBuffer &R__b)
06411 {
06412
06413
06414 if (R__b.IsReading()) {
06415 RLEP::Class()->ReadBuffer(R__b, this);
06416 } else {
06417 RLEP::Class()->WriteBuffer(R__b, this);
06418 }
06419 }
06420
06421
06422 void RLEP::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06423 {
06424
06425
06426 TClass *R__cl = RLEP::IsA();
06427 Int_t R__ncp = strlen(R__parent);
06428 if (R__ncp || R__cl || R__insp.IsA()) { }
06429 R__insp.Inspect(R__cl, R__parent, "LE", &LE);
06430 R__insp.Inspect(R__cl, R__parent, "LB[4]", LB);
06431 R__insp.Inspect(R__cl, R__parent, "LD", &LD);
06432 R__insp.Inspect(R__cl, R__parent, "LF", &LF);
06433 R__insp.Inspect(R__cl, R__parent, "LP", &LP);
06434 TObject::ShowMembers(R__insp, R__parent);
06435 }
06436
06437 namespace ROOT {
06438
06439 TClass *RLEP_IsA(const void *obj) {
06440 return ((::RLEP*)obj)->IsA();
06441 }
06442
06443 void *new_RLEP(void *p) {
06444 return p ? new(p) ::RLEP : new ::RLEP;
06445 }
06446 void *newArray_RLEP(Long_t size) {
06447 return new ::RLEP[size];
06448 }
06449
06450 void delete_RLEP(void *p) {
06451 delete ((::RLEP*)p);
06452 }
06453 void deleteArray_RLEP(void *p) {
06454 delete [] ((::RLEP*)p);
06455 }
06456 void destruct_RLEP(void *p) {
06457 typedef ::RLEP current_t;
06458 ((current_t*)p)->~current_t();
06459 }
06460 }
06461
06462
06463 void LFIL::Streamer(TBuffer &R__b)
06464 {
06465
06466
06467 if (R__b.IsReading()) {
06468 LFIL::Class()->ReadBuffer(R__b, this);
06469 } else {
06470 LFIL::Class()->WriteBuffer(R__b, this);
06471 }
06472 }
06473
06474
06475 void LFIL::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06476 {
06477
06478
06479 TClass *R__cl = LFIL::IsA();
06480 Int_t R__ncp = strlen(R__parent);
06481 if (R__ncp || R__cl || R__insp.IsA()) { }
06482 R__insp.Inspect(R__cl, R__parent, "LF", &LF);
06483 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
06484 R__insp.Inspect(R__cl, R__parent, "LR", &LR);
06485 R__insp.Inspect(R__cl, R__parent, "NV", &NV);
06486 R__insp.Inspect(R__cl, R__parent, "LE", &LE);
06487 R__insp.Inspect(R__cl, R__parent, "BX", &BX);
06488 R__insp.Inspect(R__cl, R__parent, "BY", &BY);
06489 R__insp.Inspect(R__cl, R__parent, "BZ", &BZ);
06490 R__insp.Inspect(R__cl, R__parent, "EX", &EX);
06491 R__insp.Inspect(R__cl, R__parent, "EY", &EY);
06492 R__insp.Inspect(R__cl, R__parent, "EZ", &EZ);
06493 R__insp.Inspect(R__cl, R__parent, "OF", &OF);
06494 TObject::ShowMembers(R__insp, R__parent);
06495 }
06496
06497 namespace ROOT {
06498
06499 TClass *LFIL_IsA(const void *obj) {
06500 return ((::LFIL*)obj)->IsA();
06501 }
06502
06503 void *new_LFIL(void *p) {
06504 return p ? new(p) ::LFIL : new ::LFIL;
06505 }
06506 void *newArray_LFIL(Long_t size) {
06507 return new ::LFIL[size];
06508 }
06509
06510 void delete_LFIL(void *p) {
06511 delete ((::LFIL*)p);
06512 }
06513 void deleteArray_LFIL(void *p) {
06514 delete [] ((::LFIL*)p);
06515 }
06516 void destruct_LFIL(void *p) {
06517 typedef ::LFIL current_t;
06518 ((current_t*)p)->~current_t();
06519 }
06520 }
06521
06522
06523 void EVEH::Streamer(TBuffer &R__b)
06524 {
06525
06526
06527 if (R__b.IsReading()) {
06528 EVEH::Class()->ReadBuffer(R__b, this);
06529 } else {
06530 EVEH::Class()->WriteBuffer(R__b, this);
06531 }
06532 }
06533
06534
06535 void EVEH::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06536 {
06537
06538
06539 TClass *R__cl = EVEH::IsA();
06540 Int_t R__ncp = strlen(R__parent);
06541 if (R__ncp || R__cl || R__insp.IsA()) { }
06542 R__insp.Inspect(R__cl, R__parent, "EN", &EN);
06543 R__insp.Inspect(R__cl, R__parent, "RN", &RN);
06544 R__insp.Inspect(R__cl, R__parent, "RT", &RT);
06545 R__insp.Inspect(R__cl, R__parent, "DA", &DA);
06546 R__insp.Inspect(R__cl, R__parent, "TI", &TI);
06547 R__insp.Inspect(R__cl, R__parent, "EV", &EV);
06548 R__insp.Inspect(R__cl, R__parent, "M1", &M1);
06549 R__insp.Inspect(R__cl, R__parent, "M2", &M2);
06550 R__insp.Inspect(R__cl, R__parent, "M3", &M3);
06551 R__insp.Inspect(R__cl, R__parent, "M4", &M4);
06552 R__insp.Inspect(R__cl, R__parent, "TY", &TY);
06553 R__insp.Inspect(R__cl, R__parent, "ES", &ES);
06554 R__insp.Inspect(R__cl, R__parent, "TE", &TE);
06555 TObject::ShowMembers(R__insp, R__parent);
06556 }
06557
06558 namespace ROOT {
06559
06560 TClass *EVEH_IsA(const void *obj) {
06561 return ((::EVEH*)obj)->IsA();
06562 }
06563
06564 void *new_EVEH(void *p) {
06565 return p ? new(p) ::EVEH : new ::EVEH;
06566 }
06567 void *newArray_EVEH(Long_t size) {
06568 return new ::EVEH[size];
06569 }
06570
06571 void delete_EVEH(void *p) {
06572 delete ((::EVEH*)p);
06573 }
06574 void deleteArray_EVEH(void *p) {
06575 delete [] ((::EVEH*)p);
06576 }
06577 void destruct_EVEH(void *p) {
06578 typedef ::EVEH current_t;
06579 ((current_t*)p)->~current_t();
06580 }
06581 }
06582
06583
06584 void KEVH::Streamer(TBuffer &R__b)
06585 {
06586
06587
06588 if (R__b.IsReading()) {
06589 KEVH::Class()->ReadBuffer(R__b, this);
06590 } else {
06591 KEVH::Class()->WriteBuffer(R__b, this);
06592 }
06593 }
06594
06595
06596 void KEVH::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06597 {
06598
06599
06600 TClass *R__cl = KEVH::IsA();
06601 Int_t R__ncp = strlen(R__parent);
06602 if (R__ncp || R__cl || R__insp.IsA()) { }
06603 R__insp.Inspect(R__cl, R__parent, "RN", &RN);
06604 R__insp.Inspect(R__cl, R__parent, "NT", &NT);
06605 R__insp.Inspect(R__cl, R__parent, "NV", &NV);
06606 R__insp.Inspect(R__cl, R__parent, "PI", &PI);
06607 R__insp.Inspect(R__cl, R__parent, "WT", &WT);
06608 R__insp.Inspect(R__cl, R__parent, "SR", &SR);
06609 R__insp.Inspect(R__cl, R__parent, "TR", &TR);
06610 TObject::ShowMembers(R__insp, R__parent);
06611 }
06612
06613 namespace ROOT {
06614
06615 TClass *KEVH_IsA(const void *obj) {
06616 return ((::KEVH*)obj)->IsA();
06617 }
06618
06619 void *new_KEVH(void *p) {
06620 return p ? new(p) ::KEVH : new ::KEVH;
06621 }
06622 void *newArray_KEVH(Long_t size) {
06623 return new ::KEVH[size];
06624 }
06625
06626 void delete_KEVH(void *p) {
06627 delete ((::KEVH*)p);
06628 }
06629 void deleteArray_KEVH(void *p) {
06630 delete [] ((::KEVH*)p);
06631 }
06632 void destruct_KEVH(void *p) {
06633 typedef ::KEVH current_t;
06634 ((current_t*)p)->~current_t();
06635 }
06636 }
06637
06638
06639 void REVH::Streamer(TBuffer &R__b)
06640 {
06641
06642
06643 if (R__b.IsReading()) {
06644 REVH::Class()->ReadBuffer(R__b, this);
06645 } else {
06646 REVH::Class()->WriteBuffer(R__b, this);
06647 }
06648 }
06649
06650
06651 void REVH::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06652 {
06653
06654
06655 TClass *R__cl = REVH::IsA();
06656 Int_t R__ncp = strlen(R__parent);
06657 if (R__ncp || R__cl || R__insp.IsA()) { }
06658 R__insp.Inspect(R__cl, R__parent, "DS", &DS);
06659 R__insp.Inspect(R__cl, R__parent, "FE[2]", FE);
06660 R__insp.Inspect(R__cl, R__parent, "NE[2]", NE);
06661 R__insp.Inspect(R__cl, R__parent, "SB", &SB);
06662 R__insp.Inspect(R__cl, R__parent, "TI", &TI);
06663 R__insp.Inspect(R__cl, R__parent, "RB[2]", RB);
06664 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
06665 TObject::ShowMembers(R__insp, R__parent);
06666 }
06667
06668 namespace ROOT {
06669
06670 TClass *REVH_IsA(const void *obj) {
06671 return ((::REVH*)obj)->IsA();
06672 }
06673
06674 void *new_REVH(void *p) {
06675 return p ? new(p) ::REVH : new ::REVH;
06676 }
06677 void *newArray_REVH(Long_t size) {
06678 return new ::REVH[size];
06679 }
06680
06681 void delete_REVH(void *p) {
06682 delete ((::REVH*)p);
06683 }
06684 void deleteArray_REVH(void *p) {
06685 delete [] ((::REVH*)p);
06686 }
06687 void destruct_REVH(void *p) {
06688 typedef ::REVH current_t;
06689 ((current_t*)p)->~current_t();
06690 }
06691 }
06692
06693
06694 void LOLE::Streamer(TBuffer &R__b)
06695 {
06696
06697
06698 if (R__b.IsReading()) {
06699 LOLE::Class()->ReadBuffer(R__b, this);
06700 } else {
06701 LOLE::Class()->WriteBuffer(R__b, this);
06702 }
06703 }
06704
06705
06706 void LOLE::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06707 {
06708
06709
06710 TClass *R__cl = LOLE::IsA();
06711 Int_t R__ncp = strlen(R__parent);
06712 if (R__ncp || R__cl || R__insp.IsA()) { }
06713 R__insp.Inspect(R__cl, R__parent, "FB[4]", FB);
06714 R__insp.Inspect(R__cl, R__parent, "SP", &SP);
06715 R__insp.Inspect(R__cl, R__parent, "TO", &TO);
06716 R__insp.Inspect(R__cl, R__parent, "MA[4]", MA);
06717 R__insp.Inspect(R__cl, R__parent, "HV", &HV);
06718 R__insp.Inspect(R__cl, R__parent, "ER", &ER);
06719 TObject::ShowMembers(R__insp, R__parent);
06720 }
06721
06722 namespace ROOT {
06723
06724 TClass *LOLE_IsA(const void *obj) {
06725 return ((::LOLE*)obj)->IsA();
06726 }
06727
06728 void *new_LOLE(void *p) {
06729 return p ? new(p) ::LOLE : new ::LOLE;
06730 }
06731 void *newArray_LOLE(Long_t size) {
06732 return new ::LOLE[size];
06733 }
06734
06735 void delete_LOLE(void *p) {
06736 delete ((::LOLE*)p);
06737 }
06738 void deleteArray_LOLE(void *p) {
06739 delete [] ((::LOLE*)p);
06740 }
06741 void destruct_LOLE(void *p) {
06742 typedef ::LOLE current_t;
06743 ((current_t*)p)->~current_t();
06744 }
06745 }
06746
06747
06748 void X1RG::Streamer(TBuffer &R__b)
06749 {
06750
06751
06752 if (R__b.IsReading()) {
06753 X1RG::Class()->ReadBuffer(R__b, this);
06754 } else {
06755 X1RG::Class()->WriteBuffer(R__b, this);
06756 }
06757 }
06758
06759
06760 void X1RG::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06761 {
06762
06763
06764 TClass *R__cl = X1RG::IsA();
06765 Int_t R__ncp = strlen(R__parent);
06766 if (R__ncp || R__cl || R__insp.IsA()) { }
06767 R__insp.Inspect(R__cl, R__parent, "NA[4]", NA);
06768 R__insp.Inspect(R__cl, R__parent, "CO[3]", CO);
06769 TObject::ShowMembers(R__insp, R__parent);
06770 }
06771
06772 namespace ROOT {
06773
06774 TClass *X1RG_IsA(const void *obj) {
06775 return ((::X1RG*)obj)->IsA();
06776 }
06777
06778 void *new_X1RG(void *p) {
06779 return p ? new(p) ::X1RG : new ::X1RG;
06780 }
06781 void *newArray_X1RG(Long_t size) {
06782 return new ::X1RG[size];
06783 }
06784
06785 void delete_X1RG(void *p) {
06786 delete ((::X1RG*)p);
06787 }
06788 void deleteArray_X1RG(void *p) {
06789 delete [] ((::X1RG*)p);
06790 }
06791 void destruct_X1RG(void *p) {
06792 typedef ::X1RG current_t;
06793 ((current_t*)p)->~current_t();
06794 }
06795 }
06796
06797
06798 void BOMB::Streamer(TBuffer &R__b)
06799 {
06800
06801
06802 if (R__b.IsReading()) {
06803 BOMB::Class()->ReadBuffer(R__b, this);
06804 } else {
06805 BOMB::Class()->WriteBuffer(R__b, this);
06806 }
06807 }
06808
06809
06810 void BOMB::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06811 {
06812
06813
06814 TClass *R__cl = BOMB::IsA();
06815 Int_t R__ncp = strlen(R__parent);
06816 if (R__ncp || R__cl || R__insp.IsA()) { }
06817 R__insp.Inspect(R__cl, R__parent, "XX", &XX);
06818 R__insp.Inspect(R__cl, R__parent, "YY", &YY);
06819 R__insp.Inspect(R__cl, R__parent, "EE", &EE);
06820 TObject::ShowMembers(R__insp, R__parent);
06821 }
06822
06823 namespace ROOT {
06824
06825 TClass *BOMB_IsA(const void *obj) {
06826 return ((::BOMB*)obj)->IsA();
06827 }
06828
06829 void *new_BOMB(void *p) {
06830 return p ? new(p) ::BOMB : new ::BOMB;
06831 }
06832 void *newArray_BOMB(Long_t size) {
06833 return new ::BOMB[size];
06834 }
06835
06836 void delete_BOMB(void *p) {
06837 delete ((::BOMB*)p);
06838 }
06839 void deleteArray_BOMB(void *p) {
06840 delete [] ((::BOMB*)p);
06841 }
06842 void destruct_BOMB(void *p) {
06843 typedef ::BOMB current_t;
06844 ((current_t*)p)->~current_t();
06845 }
06846 }
06847
06848
06849 void RUNH::Streamer(TBuffer &R__b)
06850 {
06851
06852
06853 if (R__b.IsReading()) {
06854 RUNH::Class()->ReadBuffer(R__b, this);
06855 } else {
06856 RUNH::Class()->WriteBuffer(R__b, this);
06857 }
06858 }
06859
06860
06861 void RUNH::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06862 {
06863
06864
06865 TClass *R__cl = RUNH::IsA();
06866 Int_t R__ncp = strlen(R__parent);
06867 if (R__ncp || R__cl || R__insp.IsA()) { }
06868 R__insp.Inspect(R__cl, R__parent, "EN", &EN);
06869 R__insp.Inspect(R__cl, R__parent, "RN", &RN);
06870 R__insp.Inspect(R__cl, R__parent, "RT", &RT);
06871 R__insp.Inspect(R__cl, R__parent, "SD", &SD);
06872 R__insp.Inspect(R__cl, R__parent, "ST", &ST);
06873 R__insp.Inspect(R__cl, R__parent, "TT[8]", TT);
06874 R__insp.Inspect(R__cl, R__parent, "RC[8]", RC);
06875 TObject::ShowMembers(R__insp, R__parent);
06876 }
06877
06878 namespace ROOT {
06879
06880 TClass *RUNH_IsA(const void *obj) {
06881 return ((::RUNH*)obj)->IsA();
06882 }
06883
06884 void *new_RUNH(void *p) {
06885 return p ? new(p) ::RUNH : new ::RUNH;
06886 }
06887 void *newArray_RUNH(Long_t size) {
06888 return new ::RUNH[size];
06889 }
06890
06891 void delete_RUNH(void *p) {
06892 delete ((::RUNH*)p);
06893 }
06894 void deleteArray_RUNH(void *p) {
06895 delete [] ((::RUNH*)p);
06896 }
06897 void destruct_RUNH(void *p) {
06898 typedef ::RUNH current_t;
06899 ((current_t*)p)->~current_t();
06900 }
06901 }
06902
06903
06904 void ASIM::Streamer(TBuffer &R__b)
06905 {
06906
06907
06908 if (R__b.IsReading()) {
06909 ASIM::Class()->ReadBuffer(R__b, this);
06910 } else {
06911 ASIM::Class()->WriteBuffer(R__b, this);
06912 }
06913 }
06914
06915
06916 void ASIM::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06917 {
06918
06919
06920 TClass *R__cl = ASIM::IsA();
06921 Int_t R__ncp = strlen(R__parent);
06922 if (R__ncp || R__cl || R__insp.IsA()) { }
06923 R__insp.Inspect(R__cl, R__parent, "YM", &YM);
06924 TObject::ShowMembers(R__insp, R__parent);
06925 }
06926
06927 namespace ROOT {
06928
06929 TClass *ASIM_IsA(const void *obj) {
06930 return ((::ASIM*)obj)->IsA();
06931 }
06932
06933 void *new_ASIM(void *p) {
06934 return p ? new(p) ::ASIM : new ::ASIM;
06935 }
06936 void *newArray_ASIM(Long_t size) {
06937 return new ::ASIM[size];
06938 }
06939
06940 void delete_ASIM(void *p) {
06941 delete ((::ASIM*)p);
06942 }
06943 void deleteArray_ASIM(void *p) {
06944 delete [] ((::ASIM*)p);
06945 }
06946 void destruct_ASIM(void *p) {
06947 typedef ::ASIM current_t;
06948 ((current_t*)p)->~current_t();
06949 }
06950 }
06951
06952
06953 void ADBR::Streamer(TBuffer &R__b)
06954 {
06955
06956
06957 if (R__b.IsReading()) {
06958 ADBR::Class()->ReadBuffer(R__b, this);
06959 } else {
06960 ADBR::Class()->WriteBuffer(R__b, this);
06961 }
06962 }
06963
06964
06965 void ADBR::ShowMembers(TMemberInspector &R__insp, char *R__parent)
06966 {
06967
06968
06969 TClass *R__cl = ADBR::IsA();
06970 Int_t R__ncp = strlen(R__parent);
06971 if (R__ncp || R__cl || R__insp.IsA()) { }
06972 R__insp.Inspect(R__cl, R__parent, "PN", &PN);
06973 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
06974 R__insp.Inspect(R__cl, R__parent, "BP", &BP);
06975 R__insp.Inspect(R__cl, R__parent, "VD", &VD);
06976 R__insp.Inspect(R__cl, R__parent, "IT", &IT);
06977 R__insp.Inspect(R__cl, R__parent, "TP", &TP);
06978 R__insp.Inspect(R__cl, R__parent, "EC", &EC);
06979 R__insp.Inspect(R__cl, R__parent, "LC", &LC);
06980 R__insp.Inspect(R__cl, R__parent, "SA", &SA);
06981 R__insp.Inspect(R__cl, R__parent, "HC", &HC);
06982 R__insp.Inspect(R__cl, R__parent, "MU", &MU);
06983 R__insp.Inspect(R__cl, R__parent, "TR", &TR);
06984 R__insp.Inspect(R__cl, R__parent, "GE", &GE);
06985 R__insp.Inspect(R__cl, R__parent, "DB", &DB);
06986 R__insp.Inspect(R__cl, R__parent, "SI", &SI);
06987 R__insp.Inspect(R__cl, R__parent, "BE", &BE);
06988 TObject::ShowMembers(R__insp, R__parent);
06989 }
06990
06991 namespace ROOT {
06992
06993 TClass *ADBR_IsA(const void *obj) {
06994 return ((::ADBR*)obj)->IsA();
06995 }
06996
06997 void *new_ADBR(void *p) {
06998 return p ? new(p) ::ADBR : new ::ADBR;
06999 }
07000 void *newArray_ADBR(Long_t size) {
07001 return new ::ADBR[size];
07002 }
07003
07004 void delete_ADBR(void *p) {
07005 delete ((::ADBR*)p);
07006 }
07007 void deleteArray_ADBR(void *p) {
07008 delete [] ((::ADBR*)p);
07009 }
07010 void destruct_ADBR(void *p) {
07011 typedef ::ADBR current_t;
07012 ((current_t*)p)->~current_t();
07013 }
07014 }
07015
07016
07017 void XTBN::Streamer(TBuffer &R__b)
07018 {
07019
07020
07021 if (R__b.IsReading()) {
07022 XTBN::Class()->ReadBuffer(R__b, this);
07023 } else {
07024 XTBN::Class()->WriteBuffer(R__b, this);
07025 }
07026 }
07027
07028
07029 void XTBN::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07030 {
07031
07032
07033 TClass *R__cl = XTBN::IsA();
07034 Int_t R__ncp = strlen(R__parent);
07035 if (R__ncp || R__cl || R__insp.IsA()) { }
07036 R__insp.Inspect(R__cl, R__parent, "ID", &ID);
07037 R__insp.Inspect(R__cl, R__parent, "VR[2]", VR);
07038 R__insp.Inspect(R__cl, R__parent, "TN", &TN);
07039 R__insp.Inspect(R__cl, R__parent, "TB", &TB);
07040 R__insp.Inspect(R__cl, R__parent, "BM[8]", BM);
07041 R__insp.Inspect(R__cl, R__parent, "BN[40]", BN);
07042 R__insp.Inspect(R__cl, R__parent, "AD[20]", AD);
07043 R__insp.Inspect(R__cl, R__parent, "L1", &L1);
07044 R__insp.Inspect(R__cl, R__parent, "L2", &L2);
07045 TObject::ShowMembers(R__insp, R__parent);
07046 }
07047
07048 namespace ROOT {
07049
07050 TClass *XTBN_IsA(const void *obj) {
07051 return ((::XTBN*)obj)->IsA();
07052 }
07053
07054 void *new_XTBN(void *p) {
07055 return p ? new(p) ::XTBN : new ::XTBN;
07056 }
07057 void *newArray_XTBN(Long_t size) {
07058 return new ::XTBN[size];
07059 }
07060
07061 void delete_XTBN(void *p) {
07062 delete ((::XTBN*)p);
07063 }
07064 void deleteArray_XTBN(void *p) {
07065 delete [] ((::XTBN*)p);
07066 }
07067 void destruct_XTBN(void *p) {
07068 typedef ::XTBN current_t;
07069 ((current_t*)p)->~current_t();
07070 }
07071 }
07072
07073
07074 void XTCN::Streamer(TBuffer &R__b)
07075 {
07076
07077
07078 if (R__b.IsReading()) {
07079 XTCN::Class()->ReadBuffer(R__b, this);
07080 } else {
07081 XTCN::Class()->WriteBuffer(R__b, this);
07082 }
07083 }
07084
07085
07086 void XTCN::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07087 {
07088
07089
07090 TClass *R__cl = XTCN::IsA();
07091 Int_t R__ncp = strlen(R__parent);
07092 if (R__ncp || R__cl || R__insp.IsA()) { }
07093 R__insp.Inspect(R__cl, R__parent, "TT[2]", TT);
07094 R__insp.Inspect(R__cl, R__parent, "GC", &GC);
07095 R__insp.Inspect(R__cl, R__parent, "LL", &LL);
07096 R__insp.Inspect(R__cl, R__parent, "BN", &BN);
07097 R__insp.Inspect(R__cl, R__parent, "CL", &CL);
07098 R__insp.Inspect(R__cl, R__parent, "TR[10]", TR);
07099 TObject::ShowMembers(R__insp, R__parent);
07100 }
07101
07102 namespace ROOT {
07103
07104 TClass *XTCN_IsA(const void *obj) {
07105 return ((::XTCN*)obj)->IsA();
07106 }
07107
07108 void *new_XTCN(void *p) {
07109 return p ? new(p) ::XTCN : new ::XTCN;
07110 }
07111 void *newArray_XTCN(Long_t size) {
07112 return new ::XTCN[size];
07113 }
07114
07115 void delete_XTCN(void *p) {
07116 delete ((::XTCN*)p);
07117 }
07118 void deleteArray_XTCN(void *p) {
07119 delete [] ((::XTCN*)p);
07120 }
07121 void destruct_XTCN(void *p) {
07122 typedef ::XTCN current_t;
07123 ((current_t*)p)->~current_t();
07124 }
07125 }
07126
07127
07128 void XTOP::Streamer(TBuffer &R__b)
07129 {
07130
07131
07132 if (R__b.IsReading()) {
07133 XTOP::Class()->ReadBuffer(R__b, this);
07134 } else {
07135 XTOP::Class()->WriteBuffer(R__b, this);
07136 }
07137 }
07138
07139
07140 void XTOP::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07141 {
07142
07143
07144 TClass *R__cl = XTOP::IsA();
07145 Int_t R__ncp = strlen(R__parent);
07146 if (R__ncp || R__cl || R__insp.IsA()) { }
07147 R__insp.Inspect(R__cl, R__parent, "ID", &ID);
07148 R__insp.Inspect(R__cl, R__parent, "VR[2]", VR);
07149 R__insp.Inspect(R__cl, R__parent, "NA[2]", NA);
07150 R__insp.Inspect(R__cl, R__parent, "TR", &TR);
07151 R__insp.Inspect(R__cl, R__parent, "GS", &GS);
07152 R__insp.Inspect(R__cl, R__parent, "DS[8]", DS);
07153 R__insp.Inspect(R__cl, R__parent, "TT", &TT);
07154 TObject::ShowMembers(R__insp, R__parent);
07155 }
07156
07157 namespace ROOT {
07158
07159 TClass *XTOP_IsA(const void *obj) {
07160 return ((::XTOP*)obj)->IsA();
07161 }
07162
07163 void *new_XTOP(void *p) {
07164 return p ? new(p) ::XTOP : new ::XTOP;
07165 }
07166 void *newArray_XTOP(Long_t size) {
07167 return new ::XTOP[size];
07168 }
07169
07170 void delete_XTOP(void *p) {
07171 delete ((::XTOP*)p);
07172 }
07173 void deleteArray_XTOP(void *p) {
07174 delete [] ((::XTOP*)p);
07175 }
07176 void destruct_XTOP(void *p) {
07177 typedef ::XTOP current_t;
07178 ((current_t*)p)->~current_t();
07179 }
07180 }
07181
07182
07183 void LUPA::Streamer(TBuffer &R__b)
07184 {
07185
07186
07187 if (R__b.IsReading()) {
07188 LUPA::Class()->ReadBuffer(R__b, this);
07189 } else {
07190 LUPA::Class()->WriteBuffer(R__b, this);
07191 }
07192 }
07193
07194
07195 void LUPA::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07196 {
07197
07198
07199 TClass *R__cl = LUPA::IsA();
07200 Int_t R__ncp = strlen(R__parent);
07201 if (R__ncp || R__cl || R__insp.IsA()) { }
07202 R__insp.Inspect(R__cl, R__parent, "GB", &GB);
07203 R__insp.Inspect(R__cl, R__parent, "HV", &HV);
07204 R__insp.Inspect(R__cl, R__parent, "T1", &T1);
07205 R__insp.Inspect(R__cl, R__parent, "L2", &L2);
07206 R__insp.Inspect(R__cl, R__parent, "TE", &TE);
07207 R__insp.Inspect(R__cl, R__parent, "LO", &LO);
07208 R__insp.Inspect(R__cl, R__parent, "AM", &AM);
07209 R__insp.Inspect(R__cl, R__parent, "MD", &MD);
07210 R__insp.Inspect(R__cl, R__parent, "EF", &EF);
07211 R__insp.Inspect(R__cl, R__parent, "EC[2]", EC);
07212 R__insp.Inspect(R__cl, R__parent, "EW[2]", EW);
07213 R__insp.Inspect(R__cl, R__parent, "XC[2]", XC);
07214 R__insp.Inspect(R__cl, R__parent, "YC[2]", YC);
07215 R__insp.Inspect(R__cl, R__parent, "TC[2]", TC);
07216 R__insp.Inspect(R__cl, R__parent, "PC[2]", PC);
07217 R__insp.Inspect(R__cl, R__parent, "AX[2]", AX);
07218 R__insp.Inspect(R__cl, R__parent, "AY[2]", AY);
07219 R__insp.Inspect(R__cl, R__parent, "XX[2]", XX);
07220 R__insp.Inspect(R__cl, R__parent, "YY[2]", YY);
07221 R__insp.Inspect(R__cl, R__parent, "XY[2]", XY);
07222 R__insp.Inspect(R__cl, R__parent, "XA[2]", XA);
07223 R__insp.Inspect(R__cl, R__parent, "YA[2]", YA);
07224 R__insp.Inspect(R__cl, R__parent, "XD[2]", XD);
07225 R__insp.Inspect(R__cl, R__parent, "YD[2]", YD);
07226 R__insp.Inspect(R__cl, R__parent, "AD[2]", AD);
07227 R__insp.Inspect(R__cl, R__parent, "IT[2]", IT);
07228 R__insp.Inspect(R__cl, R__parent, "CT[2]", CT);
07229 R__insp.Inspect(R__cl, R__parent, "TT[2]", TT);
07230 R__insp.Inspect(R__cl, R__parent, "PT[2]", PT);
07231 R__insp.Inspect(R__cl, R__parent, "XT[2]", XT);
07232 R__insp.Inspect(R__cl, R__parent, "YT[2]", YT);
07233 R__insp.Inspect(R__cl, R__parent, "E1[2]", E1);
07234 R__insp.Inspect(R__cl, R__parent, "E2[2]", E2);
07235 R__insp.Inspect(R__cl, R__parent, "XL[2]", XL);
07236 R__insp.Inspect(R__cl, R__parent, "YL[2]", YL);
07237 R__insp.Inspect(R__cl, R__parent, "AI[2]", AI);
07238 R__insp.Inspect(R__cl, R__parent, "ES[2]", ES);
07239 R__insp.Inspect(R__cl, R__parent, "XS[2]", XS);
07240 R__insp.Inspect(R__cl, R__parent, "YS[2]", YS);
07241 R__insp.Inspect(R__cl, R__parent, "AS[2]", AS);
07242 TObject::ShowMembers(R__insp, R__parent);
07243 }
07244
07245 namespace ROOT {
07246
07247 TClass *LUPA_IsA(const void *obj) {
07248 return ((::LUPA*)obj)->IsA();
07249 }
07250
07251 void *new_LUPA(void *p) {
07252 return p ? new(p) ::LUPA : new ::LUPA;
07253 }
07254 void *newArray_LUPA(Long_t size) {
07255 return new ::LUPA[size];
07256 }
07257
07258 void delete_LUPA(void *p) {
07259 delete ((::LUPA*)p);
07260 }
07261 void deleteArray_LUPA(void *p) {
07262 delete [] ((::LUPA*)p);
07263 }
07264 void destruct_LUPA(void *p) {
07265 typedef ::LUPA current_t;
07266 ((current_t*)p)->~current_t();
07267 }
07268 }
07269
07270
07271 void SILH::Streamer(TBuffer &R__b)
07272 {
07273
07274
07275 if (R__b.IsReading()) {
07276 SILH::Class()->ReadBuffer(R__b, this);
07277 } else {
07278 SILH::Class()->WriteBuffer(R__b, this);
07279 }
07280 }
07281
07282
07283 void SILH::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07284 {
07285
07286
07287 TClass *R__cl = SILH::IsA();
07288 Int_t R__ncp = strlen(R__parent);
07289 if (R__ncp || R__cl || R__insp.IsA()) { }
07290 R__insp.Inspect(R__cl, R__parent, "GB", &GB);
07291 R__insp.Inspect(R__cl, R__parent, "HV", &HV);
07292 R__insp.Inspect(R__cl, R__parent, "T1", &T1);
07293 R__insp.Inspect(R__cl, R__parent, "T2", &T2);
07294 R__insp.Inspect(R__cl, R__parent, "TE", &TE);
07295 R__insp.Inspect(R__cl, R__parent, "LO", &LO);
07296 R__insp.Inspect(R__cl, R__parent, "S2", &S2);
07297 R__insp.Inspect(R__cl, R__parent, "DW[3]", DW);
07298 R__insp.Inspect(R__cl, R__parent, "SC[3]", SC);
07299 R__insp.Inspect(R__cl, R__parent, "AM", &AM);
07300 R__insp.Inspect(R__cl, R__parent, "WI", &WI);
07301 TObject::ShowMembers(R__insp, R__parent);
07302 }
07303
07304 namespace ROOT {
07305
07306 TClass *SILH_IsA(const void *obj) {
07307 return ((::SILH*)obj)->IsA();
07308 }
07309
07310 void *new_SILH(void *p) {
07311 return p ? new(p) ::SILH : new ::SILH;
07312 }
07313 void *newArray_SILH(Long_t size) {
07314 return new ::SILH[size];
07315 }
07316
07317 void delete_SILH(void *p) {
07318 delete ((::SILH*)p);
07319 }
07320 void deleteArray_SILH(void *p) {
07321 delete [] ((::SILH*)p);
07322 }
07323 void destruct_SILH(void *p) {
07324 typedef ::SILH current_t;
07325 ((current_t*)p)->~current_t();
07326 }
07327 }
07328
07329
07330 void XHVB::Streamer(TBuffer &R__b)
07331 {
07332
07333
07334 if (R__b.IsReading()) {
07335 XHVB::Class()->ReadBuffer(R__b, this);
07336 } else {
07337 XHVB::Class()->WriteBuffer(R__b, this);
07338 }
07339 }
07340
07341
07342 void XHVB::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07343 {
07344
07345
07346 TClass *R__cl = XHVB::IsA();
07347 Int_t R__ncp = strlen(R__parent);
07348 if (R__ncp || R__cl || R__insp.IsA()) { }
07349 R__insp.Inspect(R__cl, R__parent, "RU", &RU);
07350 R__insp.Inspect(R__cl, R__parent, "FE", &FE);
07351 R__insp.Inspect(R__cl, R__parent, "LE", &LE);
07352 R__insp.Inspect(R__cl, R__parent, "HV", &HV);
07353 R__insp.Inspect(R__cl, R__parent, "DE", &DE);
07354 TObject::ShowMembers(R__insp, R__parent);
07355 }
07356
07357 namespace ROOT {
07358
07359 TClass *XHVB_IsA(const void *obj) {
07360 return ((::XHVB*)obj)->IsA();
07361 }
07362
07363 void *new_XHVB(void *p) {
07364 return p ? new(p) ::XHVB : new ::XHVB;
07365 }
07366 void *newArray_XHVB(Long_t size) {
07367 return new ::XHVB[size];
07368 }
07369
07370 void delete_XHVB(void *p) {
07371 delete ((::XHVB*)p);
07372 }
07373 void deleteArray_XHVB(void *p) {
07374 delete [] ((::XHVB*)p);
07375 }
07376 void destruct_XHVB(void *p) {
07377 typedef ::XHVB current_t;
07378 ((current_t*)p)->~current_t();
07379 }
07380 }
07381
07382
07383 void XTEB::Streamer(TBuffer &R__b)
07384 {
07385
07386
07387 if (R__b.IsReading()) {
07388 XTEB::Class()->ReadBuffer(R__b, this);
07389 } else {
07390 XTEB::Class()->WriteBuffer(R__b, this);
07391 }
07392 }
07393
07394
07395 void XTEB::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07396 {
07397
07398
07399 TClass *R__cl = XTEB::IsA();
07400 Int_t R__ncp = strlen(R__parent);
07401 if (R__ncp || R__cl || R__insp.IsA()) { }
07402 R__insp.Inspect(R__cl, R__parent, "T1", &T1);
07403 R__insp.Inspect(R__cl, R__parent, "T2", &T2);
07404 R__insp.Inspect(R__cl, R__parent, "L2", &L2);
07405 R__insp.Inspect(R__cl, R__parent, "HT[12]", HT);
07406 R__insp.Inspect(R__cl, R__parent, "HW[12]", HW);
07407 R__insp.Inspect(R__cl, R__parent, "LW[12]", LW);
07408 R__insp.Inspect(R__cl, R__parent, "EW[12]", EW);
07409 R__insp.Inspect(R__cl, R__parent, "LT[4]", LT);
07410 R__insp.Inspect(R__cl, R__parent, "TE[2]", TE);
07411 R__insp.Inspect(R__cl, R__parent, "IT[4]", IT);
07412 R__insp.Inspect(R__cl, R__parent, "TP[4]", TP);
07413 TObject::ShowMembers(R__insp, R__parent);
07414 }
07415
07416 namespace ROOT {
07417
07418 TClass *XTEB_IsA(const void *obj) {
07419 return ((::XTEB*)obj)->IsA();
07420 }
07421
07422 void *new_XTEB(void *p) {
07423 return p ? new(p) ::XTEB : new ::XTEB;
07424 }
07425 void *newArray_XTEB(Long_t size) {
07426 return new ::XTEB[size];
07427 }
07428
07429 void delete_XTEB(void *p) {
07430 delete ((::XTEB*)p);
07431 }
07432 void deleteArray_XTEB(void *p) {
07433 delete [] ((::XTEB*)p);
07434 }
07435 void destruct_XTEB(void *p) {
07436 typedef ::XTEB current_t;
07437 ((current_t*)p)->~current_t();
07438 }
07439 }
07440
07441
07442 void XTRB::Streamer(TBuffer &R__b)
07443 {
07444
07445
07446 if (R__b.IsReading()) {
07447 XTRB::Class()->ReadBuffer(R__b, this);
07448 } else {
07449 XTRB::Class()->WriteBuffer(R__b, this);
07450 }
07451 }
07452
07453
07454 void XTRB::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07455 {
07456
07457
07458 TClass *R__cl = XTRB::IsA();
07459 Int_t R__ncp = strlen(R__parent);
07460 if (R__ncp || R__cl || R__insp.IsA()) { }
07461 R__insp.Inspect(R__cl, R__parent, "RP[3]", RP);
07462 R__insp.Inspect(R__cl, R__parent, "RN", &RN);
07463 TObject::ShowMembers(R__insp, R__parent);
07464 }
07465
07466 namespace ROOT {
07467
07468 TClass *XTRB_IsA(const void *obj) {
07469 return ((::XTRB*)obj)->IsA();
07470 }
07471
07472 void *new_XTRB(void *p) {
07473 return p ? new(p) ::XTRB : new ::XTRB;
07474 }
07475 void *newArray_XTRB(Long_t size) {
07476 return new ::XTRB[size];
07477 }
07478
07479 void delete_XTRB(void *p) {
07480 delete ((::XTRB*)p);
07481 }
07482 void deleteArray_XTRB(void *p) {
07483 delete [] ((::XTRB*)p);
07484 }
07485 void destruct_XTRB(void *p) {
07486 typedef ::XTRB current_t;
07487 ((current_t*)p)->~current_t();
07488 }
07489 }
07490
07491
07492 void DTBP::Streamer(TBuffer &R__b)
07493 {
07494
07495
07496 if (R__b.IsReading()) {
07497 DTBP::Class()->ReadBuffer(R__b, this);
07498 } else {
07499 DTBP::Class()->WriteBuffer(R__b, this);
07500 }
07501 }
07502
07503
07504 void DTBP::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07505 {
07506
07507
07508 TClass *R__cl = DTBP::IsA();
07509 Int_t R__ncp = strlen(R__parent);
07510 if (R__ncp || R__cl || R__insp.IsA()) { }
07511 R__insp.Inspect(R__cl, R__parent, "T1", &T1);
07512 R__insp.Inspect(R__cl, R__parent, "T2", &T2);
07513 R__insp.Inspect(R__cl, R__parent, "L2", &L2);
07514 TObject::ShowMembers(R__insp, R__parent);
07515 }
07516
07517 namespace ROOT {
07518
07519 TClass *DTBP_IsA(const void *obj) {
07520 return ((::DTBP*)obj)->IsA();
07521 }
07522
07523 void *new_DTBP(void *p) {
07524 return p ? new(p) ::DTBP : new ::DTBP;
07525 }
07526 void *newArray_DTBP(Long_t size) {
07527 return new ::DTBP[size];
07528 }
07529
07530 void delete_DTBP(void *p) {
07531 delete ((::DTBP*)p);
07532 }
07533 void deleteArray_DTBP(void *p) {
07534 delete [] ((::DTBP*)p);
07535 }
07536 void destruct_DTBP(void *p) {
07537 typedef ::DTBP current_t;
07538 ((current_t*)p)->~current_t();
07539 }
07540 }
07541
07542
07543 void VHBV::Streamer(TBuffer &R__b)
07544 {
07545
07546
07547 if (R__b.IsReading()) {
07548 VHBV::Class()->ReadBuffer(R__b, this);
07549 } else {
07550 VHBV::Class()->WriteBuffer(R__b, this);
07551 }
07552 }
07553
07554
07555 void VHBV::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07556 {
07557
07558
07559 TClass *R__cl = VHBV::IsA();
07560 Int_t R__ncp = strlen(R__parent);
07561 if (R__ncp || R__cl || R__insp.IsA()) { }
07562 R__insp.Inspect(R__cl, R__parent, "BN", &BN);
07563 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
07564 R__insp.Inspect(R__cl, R__parent, "LR", &LR);
07565 TObject::ShowMembers(R__insp, R__parent);
07566 }
07567
07568 namespace ROOT {
07569
07570 TClass *VHBV_IsA(const void *obj) {
07571 return ((::VHBV*)obj)->IsA();
07572 }
07573
07574 void *new_VHBV(void *p) {
07575 return p ? new(p) ::VHBV : new ::VHBV;
07576 }
07577 void *newArray_VHBV(Long_t size) {
07578 return new ::VHBV[size];
07579 }
07580
07581 void delete_VHBV(void *p) {
07582 delete ((::VHBV*)p);
07583 }
07584 void deleteArray_VHBV(void *p) {
07585 delete [] ((::VHBV*)p);
07586 }
07587 void destruct_VHBV(void *p) {
07588 typedef ::VHBV current_t;
07589 ((current_t*)p)->~current_t();
07590 }
07591 }
07592
07593
07594 void VHPV::Streamer(TBuffer &R__b)
07595 {
07596
07597
07598 if (R__b.IsReading()) {
07599 VHPV::Class()->ReadBuffer(R__b, this);
07600 } else {
07601 VHPV::Class()->WriteBuffer(R__b, this);
07602 }
07603 }
07604
07605
07606 void VHPV::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07607 {
07608
07609
07610 TClass *R__cl = VHPV::IsA();
07611 Int_t R__ncp = strlen(R__parent);
07612 if (R__ncp || R__cl || R__insp.IsA()) { }
07613 R__insp.Inspect(R__cl, R__parent, "FR", &FR);
07614 R__insp.Inspect(R__cl, R__parent, "LR", &LR);
07615 TObject::ShowMembers(R__insp, R__parent);
07616 }
07617
07618 namespace ROOT {
07619
07620 TClass *VHPV_IsA(const void *obj) {
07621 return ((::VHPV*)obj)->IsA();
07622 }
07623
07624 void *new_VHPV(void *p) {
07625 return p ? new(p) ::VHPV : new ::VHPV;
07626 }
07627 void *newArray_VHPV(Long_t size) {
07628 return new ::VHPV[size];
07629 }
07630
07631 void delete_VHPV(void *p) {
07632 delete ((::VHPV*)p);
07633 }
07634 void deleteArray_VHPV(void *p) {
07635 delete [] ((::VHPV*)p);
07636 }
07637 void destruct_VHPV(void *p) {
07638 typedef ::VHPV current_t;
07639 ((current_t*)p)->~current_t();
07640 }
07641 }
07642
07643
07644 void EAUX::Streamer(TBuffer &R__b)
07645 {
07646
07647
07648 if (R__b.IsReading()) {
07649 EAUX::Class()->ReadBuffer(R__b, this);
07650 } else {
07651 EAUX::Class()->WriteBuffer(R__b, this);
07652 }
07653 }
07654
07655
07656 void EAUX::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07657 {
07658
07659
07660 TClass *R__cl = EAUX::IsA();
07661 Int_t R__ncp = strlen(R__parent);
07662 if (R__ncp || R__cl || R__insp.IsA()) { }
07663 R__insp.Inspect(R__cl, R__parent, "TR", &TR);
07664 R__insp.Inspect(R__cl, R__parent, "CA", &CA);
07665 R__insp.Inspect(R__cl, R__parent, "HV", &HV);
07666 R__insp.Inspect(R__cl, R__parent, "HE", &HE);
07667 R__insp.Inspect(R__cl, R__parent, "HK", &HK);
07668 R__insp.Inspect(R__cl, R__parent, "E2", &E2);
07669 TObject::ShowMembers(R__insp, R__parent);
07670 }
07671
07672 namespace ROOT {
07673
07674 TClass *EAUX_IsA(const void *obj) {
07675 return ((::EAUX*)obj)->IsA();
07676 }
07677
07678 void *new_EAUX(void *p) {
07679 return p ? new(p) ::EAUX : new ::EAUX;
07680 }
07681 void *newArray_EAUX(Long_t size) {
07682 return new ::EAUX[size];
07683 }
07684
07685 void delete_EAUX(void *p) {
07686 delete ((::EAUX*)p);
07687 }
07688 void deleteArray_EAUX(void *p) {
07689 delete [] ((::EAUX*)p);
07690 }
07691 void destruct_EAUX(void *p) {
07692 typedef ::EAUX current_t;
07693 ((current_t*)p)->~current_t();
07694 }
07695 }
07696
07697
07698 void SIX2::Streamer(TBuffer &R__b)
07699 {
07700
07701
07702 if (R__b.IsReading()) {
07703 SIX2::Class()->ReadBuffer(R__b, this);
07704 } else {
07705 SIX2::Class()->WriteBuffer(R__b, this);
07706 }
07707 }
07708
07709
07710 void SIX2::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07711 {
07712
07713
07714 TClass *R__cl = SIX2::IsA();
07715 Int_t R__ncp = strlen(R__parent);
07716 if (R__ncp || R__cl || R__insp.IsA()) { }
07717 R__insp.Inspect(R__cl, R__parent, "TW", &TW);
07718 TObject::ShowMembers(R__insp, R__parent);
07719 }
07720
07721 namespace ROOT {
07722
07723 TClass *SIX2_IsA(const void *obj) {
07724 return ((::SIX2*)obj)->IsA();
07725 }
07726
07727 void *new_SIX2(void *p) {
07728 return p ? new(p) ::SIX2 : new ::SIX2;
07729 }
07730 void *newArray_SIX2(Long_t size) {
07731 return new ::SIX2[size];
07732 }
07733
07734 void delete_SIX2(void *p) {
07735 delete ((::SIX2*)p);
07736 }
07737 void deleteArray_SIX2(void *p) {
07738 delete [] ((::SIX2*)p);
07739 }
07740 void destruct_SIX2(void *p) {
07741 typedef ::SIX2 current_t;
07742 ((current_t*)p)->~current_t();
07743 }
07744 }
07745
07746
07747 void X1TV::Streamer(TBuffer &R__b)
07748 {
07749
07750
07751 if (R__b.IsReading()) {
07752 X1TV::Class()->ReadBuffer(R__b, this);
07753 } else {
07754 X1TV::Class()->WriteBuffer(R__b, this);
07755 }
07756 }
07757
07758
07759 void X1TV::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07760 {
07761
07762
07763 TClass *R__cl = X1TV::IsA();
07764 Int_t R__ncp = strlen(R__parent);
07765 if (R__ncp || R__cl || R__insp.IsA()) { }
07766 R__insp.Inspect(R__cl, R__parent, "TT[4]", TT);
07767 R__insp.Inspect(R__cl, R__parent, "TV[4]", TV);
07768 TObject::ShowMembers(R__insp, R__parent);
07769 }
07770
07771 namespace ROOT {
07772
07773 TClass *X1TV_IsA(const void *obj) {
07774 return ((::X1TV*)obj)->IsA();
07775 }
07776
07777 void *new_X1TV(void *p) {
07778 return p ? new(p) ::X1TV : new ::X1TV;
07779 }
07780 void *newArray_X1TV(Long_t size) {
07781 return new ::X1TV[size];
07782 }
07783
07784 void delete_X1TV(void *p) {
07785 delete ((::X1TV*)p);
07786 }
07787 void deleteArray_X1TV(void *p) {
07788 delete [] ((::X1TV*)p);
07789 }
07790 void destruct_X1TV(void *p) {
07791 typedef ::X1TV current_t;
07792 ((current_t*)p)->~current_t();
07793 }
07794 }
07795
07796
07797 void KWGT::Streamer(TBuffer &R__b)
07798 {
07799
07800
07801 if (R__b.IsReading()) {
07802 KWGT::Class()->ReadBuffer(R__b, this);
07803 } else {
07804 KWGT::Class()->WriteBuffer(R__b, this);
07805 }
07806 }
07807
07808
07809 void KWGT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07810 {
07811
07812
07813 TClass *R__cl = KWGT::IsA();
07814 Int_t R__ncp = strlen(R__parent);
07815 if (R__ncp || R__cl || R__insp.IsA()) { }
07816 R__insp.Inspect(R__cl, R__parent, "WN", &WN);
07817 R__insp.Inspect(R__cl, R__parent, "WV", &WV);
07818 TObject::ShowMembers(R__insp, R__parent);
07819 }
07820
07821 namespace ROOT {
07822
07823 TClass *KWGT_IsA(const void *obj) {
07824 return ((::KWGT*)obj)->IsA();
07825 }
07826
07827 void *new_KWGT(void *p) {
07828 return p ? new(p) ::KWGT : new ::KWGT;
07829 }
07830 void *newArray_KWGT(Long_t size) {
07831 return new ::KWGT[size];
07832 }
07833
07834 void delete_KWGT(void *p) {
07835 delete ((::KWGT*)p);
07836 }
07837 void deleteArray_KWGT(void *p) {
07838 delete [] ((::KWGT*)p);
07839 }
07840 void destruct_KWGT(void *p) {
07841 typedef ::KWGT current_t;
07842 ((current_t*)p)->~current_t();
07843 }
07844 }
07845
07846
07847 void X1IP::Streamer(TBuffer &R__b)
07848 {
07849
07850
07851 if (R__b.IsReading()) {
07852 X1IP::Class()->ReadBuffer(R__b, this);
07853 } else {
07854 X1IP::Class()->WriteBuffer(R__b, this);
07855 }
07856 }
07857
07858
07859 void X1IP::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07860 {
07861
07862
07863 TClass *R__cl = X1IP::IsA();
07864 Int_t R__ncp = strlen(R__parent);
07865 if (R__ncp || R__cl || R__insp.IsA()) { }
07866 R__insp.Inspect(R__cl, R__parent, "IT[4]", IT);
07867 R__insp.Inspect(R__cl, R__parent, "CO[36]", CO);
07868 TObject::ShowMembers(R__insp, R__parent);
07869 }
07870
07871 namespace ROOT {
07872
07873 TClass *X1IP_IsA(const void *obj) {
07874 return ((::X1IP*)obj)->IsA();
07875 }
07876
07877 void *new_X1IP(void *p) {
07878 return p ? new(p) ::X1IP : new ::X1IP;
07879 }
07880 void *newArray_X1IP(Long_t size) {
07881 return new ::X1IP[size];
07882 }
07883
07884 void delete_X1IP(void *p) {
07885 delete ((::X1IP*)p);
07886 }
07887 void deleteArray_X1IP(void *p) {
07888 delete [] ((::X1IP*)p);
07889 }
07890 void destruct_X1IP(void *p) {
07891 typedef ::X1IP current_t;
07892 ((current_t*)p)->~current_t();
07893 }
07894 }
07895
07896
07897 void SIXA::Streamer(TBuffer &R__b)
07898 {
07899
07900
07901 if (R__b.IsReading()) {
07902 SIXA::Class()->ReadBuffer(R__b, this);
07903 } else {
07904 SIXA::Class()->WriteBuffer(R__b, this);
07905 }
07906 }
07907
07908
07909 void SIXA::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07910 {
07911
07912
07913 TClass *R__cl = SIXA::IsA();
07914 Int_t R__ncp = strlen(R__parent);
07915 if (R__ncp || R__cl || R__insp.IsA()) { }
07916 R__insp.Inspect(R__cl, R__parent, "AO", &AO);
07917 R__insp.Inspect(R__cl, R__parent, "AE", &AE);
07918 TObject::ShowMembers(R__insp, R__parent);
07919 }
07920
07921 namespace ROOT {
07922
07923 TClass *SIXA_IsA(const void *obj) {
07924 return ((::SIXA*)obj)->IsA();
07925 }
07926
07927 void *new_SIXA(void *p) {
07928 return p ? new(p) ::SIXA : new ::SIXA;
07929 }
07930 void *newArray_SIXA(Long_t size) {
07931 return new ::SIXA[size];
07932 }
07933
07934 void delete_SIXA(void *p) {
07935 delete ((::SIXA*)p);
07936 }
07937 void deleteArray_SIXA(void *p) {
07938 delete [] ((::SIXA*)p);
07939 }
07940 void destruct_SIXA(void *p) {
07941 typedef ::SIXA current_t;
07942 ((current_t*)p)->~current_t();
07943 }
07944 }
07945
07946
07947 void SITC::Streamer(TBuffer &R__b)
07948 {
07949
07950
07951 if (R__b.IsReading()) {
07952 SITC::Class()->ReadBuffer(R__b, this);
07953 } else {
07954 SITC::Class()->WriteBuffer(R__b, this);
07955 }
07956 }
07957
07958
07959 void SITC::ShowMembers(TMemberInspector &R__insp, char *R__parent)
07960 {
07961
07962
07963 TClass *R__cl = SITC::IsA();
07964 Int_t R__ncp = strlen(R__parent);
07965 if (R__ncp || R__cl || R__insp.IsA()) { }
07966 R__insp.Inspect(R__cl, R__parent, "TT", &TT);
07967 R__insp.Inspect(R__cl, R__parent, "DO", &DO);
07968 R__insp.Inspect(R__cl, R__parent, "DE", &DE);
07969 TObject::ShowMembers(R__insp, R__parent);
07970 }
07971
07972 namespace ROOT {
07973
07974 TClass *SITC_IsA(const void *obj) {
07975 return ((::SITC*)obj)->IsA();
07976 }
07977
07978 void *new_SITC(void *p) {
07979 return p ? new(p) ::SITC : new ::SITC;
07980 }
07981 void *newArray_SITC(Long_t size) {
07982 return new ::SITC[size];
07983 }
07984
07985 void delete_SITC(void *p) {
07986 delete ((::SITC*)p);
07987 }
07988 void deleteArray_SITC(void *p) {
07989 delete [] ((::SITC*)p);
07990 }
07991 void destruct_SITC(void *p) {
07992 typedef ::SITC current_t;
07993 ((current_t*)p)->~current_t();
07994 }
07995 }
07996
07997
07998 void SRCO::Streamer(TBuffer &R__b)
07999 {
08000
08001
08002 if (R__b.IsReading()) {
08003 SRCO::Class()->ReadBuffer(R__b, this);
08004 } else {
08005 SRCO::Class()->WriteBuffer(R__b, this);
08006 }
08007 }
08008
08009
08010 void SRCO::ShowMembers(TMemberInspector &R__insp, char *R__parent)
08011 {
08012
08013
08014 TClass *R__cl = SRCO::IsA();
08015 Int_t R__ncp = strlen(R__parent);
08016 if (R__ncp || R__cl || R__insp.IsA()) { }
08017 R__insp.Inspect(R__cl, R__parent, "NA[4]", NA);
08018 R__insp.Inspect(R__cl, R__parent, "VA", &VA);
08019 TObject::ShowMembers(R__insp, R__parent);
08020 }
08021
08022 namespace ROOT {
08023
08024 TClass *SRCO_IsA(const void *obj) {
08025 return ((::SRCO*)obj)->IsA();
08026 }
08027
08028 void *new_SRCO(void *p) {
08029 return p ? new(p) ::SRCO : new ::SRCO;
08030 }
08031 void *newArray_SRCO(Long_t size) {
08032 return new ::SRCO[size];
08033 }
08034
08035 void delete_SRCO(void *p) {
08036 delete ((::SRCO*)p);
08037 }
08038 void deleteArray_SRCO(void *p) {
08039 delete [] ((::SRCO*)p);
08040 }
08041 void destruct_SRCO(void *p) {
08042 typedef ::SRCO current_t;
08043 ((current_t*)p)->~current_t();
08044 }
08045 }
08046
08047
08048 void X1TH::Streamer(TBuffer &R__b)
08049 {
08050
08051
08052 if (R__b.IsReading()) {
08053 X1TH::Class()->ReadBuffer(R__b, this);
08054 } else {
08055 X1TH::Class()->WriteBuffer(R__b, this);
08056 }
08057 }
08058
08059
08060 void X1TH::ShowMembers(TMemberInspector &R__insp, char *R__parent)
08061 {
08062
08063
08064 TClass *R__cl = X1TH::IsA();
08065 Int_t R__ncp = strlen(R__parent);
08066 if (R__ncp || R__cl || R__insp.IsA()) { }
08067 R__insp.Inspect(R__cl, R__parent, "ID", &ID);
08068 R__insp.Inspect(R__cl, R__parent, "VR[2]", VR);
08069 R__insp.Inspect(R__cl, R__parent, "TT[4]", TT);
08070 R__insp.Inspect(R__cl, R__parent, "TV[4]", TV);
08071 TObject::ShowMembers(R__insp, R__parent);
08072 }
08073
08074 namespace ROOT {
08075
08076 TClass *X1TH_IsA(const void *obj) {
08077 return ((::X1TH*)obj)->IsA();
08078 }
08079
08080 void *new_X1TH(void *p) {
08081 return p ? new(p) ::X1TH : new ::X1TH;
08082 }
08083 void *newArray_X1TH(Long_t size) {
08084 return new ::X1TH[size];
08085 }
08086
08087 void delete_X1TH(void *p) {
08088 delete ((::X1TH*)p);
08089 }
08090 void deleteArray_X1TH(void *p) {
08091 delete [] ((::X1TH*)p);
08092 }
08093 void destruct_X1TH(void *p) {
08094 typedef ::X1TH current_t;
08095 ((current_t*)p)->~current_t();
08096 }
08097 }
08098
08099
08100 void X1AD::Streamer(TBuffer &R__b)
08101 {
08102
08103
08104 if (R__b.IsReading()) {
08105 X1AD::Class()->ReadBuffer(R__b, this);
08106 } else {
08107 X1AD::Class()->WriteBuffer(R__b, this);
08108 }
08109 }
08110
08111
08112 void X1AD::ShowMembers(TMemberInspector &R__insp, char *R__parent)
08113 {
08114
08115
08116 TClass *R__cl = X1AD::IsA();
08117 Int_t R__ncp = strlen(R__parent);
08118 if (R__ncp || R__cl || R__insp.IsA()) { }
08119 R__insp.Inspect(R__cl, R__parent, "IT[4]", IT);
08120 R__insp.Inspect(R__cl, R__parent, "AV[36]", AV);
08121 TObject::ShowMembers(R__insp, R__parent);
08122 }
08123
08124 namespace ROOT {
08125
08126 TClass *X1AD_IsA(const void *obj) {
08127 return ((::X1AD*)obj)->IsA();
08128 }
08129
08130 void *new_X1AD(void *p) {
08131 return p ? new(p) ::X1AD : new ::X1AD;
08132 }
08133 void *newArray_X1AD(Long_t size) {
08134 return new ::X1AD[size];
08135 }
08136
08137 void delete_X1AD(void *p) {
08138 delete ((::X1AD*)p);
08139 }
08140 void deleteArray_X1AD(void *p) {
08141 delete [] ((::X1AD*)p);
08142 }
08143 void destruct_X1AD(void *p) {
08144 typedef ::X1AD current_t;
08145 ((current_t*)p)->~current_t();
08146 }
08147 }
08148
08149
08150 void R__QEXT_LP(TBuffer &R__b, void *R__p, int)
08151 {
08152 RLEP** LP = (RLEP**)R__p;
08153 if (R__b.IsReading()) {
08154 R__b >> *LP;
08155 } else {
08156 R__b << (TObject*)*LP;
08157 }
08158 }
08159
08160
08161 void QEXT::Streamer(TBuffer &R__b)
08162 {
08163
08164
08165 if (R__b.IsReading()) {
08166 QEXT::Class()->ReadBuffer(R__b, this);
08167 } else {
08168 QEXT::Class()->WriteBuffer(R__b, this);
08169 }
08170 }
08171
08172
08173 void QEXT::ShowMembers(TMemberInspector &R__insp, char *R__parent)
08174 {
08175
08176
08177 TClass *R__cl = QEXT::IsA();
08178 Int_t R__ncp = strlen(R__parent);
08179 if (R__ncp || R__cl || R__insp.IsA()) { }
08180 R__insp.Inspect(R__cl, R__parent, "*LP", &LP);
08181 R__cl->SetStreamer("*LP",R__QEXT_LP);
08182 TObject::ShowMembers(R__insp, R__parent);
08183 }
08184
08185 namespace ROOT {
08186
08187 TClass *QEXT_IsA(const void *obj) {
08188 return ((::QEXT*)obj)->IsA();
08189 }
08190
08191 void *new_QEXT(void *p) {
08192 return p ? new(p) ::QEXT : new ::QEXT;
08193 }
08194 void *newArray_QEXT(Long_t size) {
08195 return new ::QEXT[size];
08196 }
08197
08198 void delete_QEXT(void *p) {
08199 delete ((::QEXT*)p);
08200 }
08201 void deleteArray_QEXT(void *p) {
08202 delete [] ((::QEXT*)p);
08203 }
08204 void destruct_QEXT(void *p) {
08205 typedef ::QEXT current_t;
08206 ((current_t*)p)->~current_t();
08207 }
08208 }
08209
08210
08211 void R__QHAC_EH(TBuffer &R__b, void *R__p, int)
08212 {
08213 EVEH** EH = (EVEH**)R__p;
08214 if (R__b.IsReading()) {
08215 R__b >> *EH;
08216 } else {
08217 R__b << (TObject*)*EH;
08218 }
08219 }
08220
08221
08222 void R__QHAC_RH(TBuffer &R__b, void *R__p, int)
08223 {
08224 RUNH** RH = (RUNH**)R__p;
08225 if (R__b.IsReading()) {
08226 R__b >> *RH;
08227 } else {
08228 R__b << (TObject*)*RH;
08229 }
08230 }
08231
08232
08233 void R__QHAC_AS(TBuffer &R__b, void *R__p, int)
08234 {
08235 ASIM** AS = (ASIM**)R__p;
08236 if (R__b.IsReading()) {
08237 R__b >> *AS;
08238 } else {
08239 R__b << (TObject*)*AS;
08240 }
08241 }
08242
08243
08244 void R__QHAC_KE(TBuffer &R__b, void *R__p, int)
08245 {
08246 KEVH** KE = (KEVH**)R__p;
08247 if (R__b.IsReading()) {
08248 R__b >> *KE;
08249 } else {
08250 R__b << (TObject*)*KE;
08251 }
08252 }
08253
08254
08255 void R__QHAC_RE(TBuffer &R__b, void *R__p, int)
08256 {
08257 REVH** RE = (REVH**)R__p;
08258 if (R__b.IsReading()) {
08259 R__b >> *RE;
08260 } else {
08261 R__b << (TObject*)*RE;
08262 }
08263 }
08264
08265
08266 void R__QHAC_AD(TBuffer &R__b, void *R__p, int)
08267 {
08268 ADBR** AD = (ADBR**)R__p;
08269 if (R__b.IsReading()) {
08270 R__b >> *AD;
08271 } else {
08272 R__b << (TObject*)*AD;
08273 }
08274 }
08275
08276
08277 void R__QHAC_BO(TBuffer &R__b, void *R__p, int)
08278 {
08279 BOMB** BO = (BOMB**)R__p;
08280 if (R__b.IsReading()) {
08281 R__b >> *BO;
08282 } else {
08283 R__b << (TObject*)*BO;
08284 }
08285 }
08286
08287
08288 void R__QHAC_EX(TBuffer &R__b, void *R__p, int)
08289 {
08290 EAUX** EX = (EAUX**)R__p;
08291 if (R__b.IsReading()) {
08292 R__b >> *EX;
08293 } else {
08294 R__b << (TObject*)*EX;
08295 }
08296 }
08297
08298
08299 void R__QHAC_KW(TBuffer &R__b, void *R__p, int)
08300 {
08301 vector<KWGT*> &KW = *(vector<KWGT*> *)R__p;
08302 if (R__b.IsReading()) {
08303 {
08304 vector<KWGT*> &R__stl = KW;
08305 R__stl.clear();
08306 TClass *R__tcl1 = TBuffer::GetClass(typeid(KWGT));
08307 int R__i, R__n;
08308 R__b >> R__n;
08309 R__stl.reserve(R__n);
08310 for (R__i = 0; R__i < R__n; R__i++) {
08311 KWGT* R__t;
08312 R__t = (KWGT*)R__b.ReadObjectAny(R__tcl1);
08313 R__stl.push_back(R__t);
08314 }
08315 }
08316 } else {
08317 {
08318 vector<KWGT*> &R__stl = KW;
08319 int R__n=(&R__stl) ? int(R__stl.size()) : 0;
08320 R__b << R__n;
08321 if(R__n) {
08322 vector<KWGT*>::iterator R__k;
08323 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
08324 R__b << (*R__k);
08325 }
08326 }
08327 }
08328 }
08329 }
08330
08331
08332 void QHAC::Streamer(TBuffer &R__b)
08333 {
08334
08335
08336 if (R__b.IsReading()) {
08337 QHAC::Class()->ReadBuffer(R__b, this);
08338 } else {
08339 QHAC::Class()->WriteBuffer(R__b, this);
08340 }
08341 }
08342
08343
08344 void QHAC::ShowMembers(TMemberInspector &R__insp, char *R__parent)
08345 {
08346
08347
08348 TClass *R__cl = QHAC::IsA();
08349 Int_t R__ncp = strlen(R__parent);
08350 if (R__ncp || R__cl || R__insp.IsA()) { }
08351 R__insp.Inspect(R__cl, R__parent, "*EH", &EH);
08352 R__cl->SetStreamer("*EH",R__QHAC_EH);
08353 R__insp.Inspect(R__cl, R__parent, "*RH", &RH);
08354 R__cl->SetStreamer("*RH",R__QHAC_RH);
08355 R__insp.Inspect(R__cl, R__parent, "*AS", &AS);
08356 R__cl->SetStreamer("*AS",R__QHAC_AS);
08357 R__insp.Inspect(R__cl, R__parent, "*KE", &KE);
08358 R__cl->SetStreamer("*KE",R__QHAC_KE);
08359 R__insp.Inspect(R__cl, R__parent, "*RE", &RE);
08360 R__cl->SetStreamer("*RE",R__QHAC_RE);
08361 R__insp.Inspect(R__cl, R__parent, "LO", (void*)&LO);
08362 ROOT::GenericShowMembers("vector<LOLE*>", (void*)&LO, R__insp, strcat(R__parent,"LO."),true);
08363 R__parent[R__ncp] = 0;
08364 R__insp.Inspect(R__cl, R__parent, "X1", (void*)&X1);
08365 ROOT::GenericShowMembers("vector<X1RG*>", (void*)&X1, R__insp, strcat(R__parent,"X1."),true);
08366 R__parent[R__ncp] = 0;
08367 R__insp.Inspect(R__cl, R__parent, "*AD", &AD);
08368 R__cl->SetStreamer("*AD",R__QHAC_AD);
08369 R__insp.Inspect(R__cl, R__parent, "*BO", &BO);
08370 R__cl->SetStreamer("*BO",R__QHAC_BO);
08371 R__insp.Inspect(R__cl, R__parent, "BN", (void*)&BN);
08372 ROOT::GenericShowMembers("vector<XTBN*>", (void*)&BN, R__insp, strcat(R__parent,"BN."),true);
08373 R__parent[R__ncp] = 0;
08374 R__insp.Inspect(R__cl, R__parent, "*CN", &CN);
08375 R__insp.Inspect(R__cl, R__parent, "*OP", &OP);
08376 R__insp.Inspect(R__cl, R__parent, "*LP", &LP);
08377 R__insp.Inspect(R__cl, R__parent, "*SI", &SI);
08378 R__insp.Inspect(R__cl, R__parent, "HV", (void*)&HV);
08379 ROOT::GenericShowMembers("vector<XHVB*>", (void*)&HV, R__insp, strcat(R__parent,"HV."),true);
08380 R__parent[R__ncp] = 0;
08381 R__insp.Inspect(R__cl, R__parent, "*EB", &EB);
08382 R__insp.Inspect(R__cl, R__parent, "*RB", &RB);
08383 R__insp.Inspect(R__cl, R__parent, "*BP", &BP);
08384 R__insp.Inspect(R__cl, R__parent, "PV", (void*)&PV);
08385 ROOT::GenericShowMembers("vector<VHPV*>", (void*)&PV, R__insp, strcat(R__parent,"PV."),true);
08386 R__parent[R__ncp] = 0;
08387 R__insp.Inspect(R__cl, R__parent, "BV", (void*)&BV);
08388 ROOT::GenericShowMembers("vector<VHBV*>", (void*)&BV, R__insp, strcat(R__parent,"BV."),true);
08389 R__parent[R__ncp] = 0;
08390 R__insp.Inspect(R__cl, R__parent, "*EX", &EX);
08391 R__cl->SetStreamer("*EX",R__QHAC_EX);
08392 R__insp.Inspect(R__cl, R__parent, "*X2", &X2);
08393 R__insp.Inspect(R__cl, R__parent, "TV", (void*)&TV);
08394 ROOT::GenericShowMembers("vector<X1TV*>", (void*)&TV, R__insp, strcat(R__parent,"TV."),true);
08395 R__parent[R__ncp] = 0;
08396 R__insp.Inspect(R__cl, R__parent, "KW", (void*)&KW);
08397 ROOT::GenericShowMembers("vector<KWGT*>", (void*)&KW, R__insp, strcat(R__parent,"KW."),false);
08398 R__parent[R__ncp] = 0;
08399 R__cl->SetStreamer("KW",R__QHAC_KW);
08400 R__insp.Inspect(R__cl, R__parent, "IP", (void*)&IP);
08401 ROOT::GenericShowMembers("vector<X1IP*>", (void*)&IP, R__insp, strcat(R__parent,"IP."),true);
08402 R__parent[R__ncp] = 0;
08403 R__insp.Inspect(R__cl, R__parent, "XA", (void*)&XA);
08404 ROOT::GenericShowMembers("vector<SIXA*>", (void*)&XA, R__insp, strcat(R__parent,"XA."),true);
08405 R__parent[R__ncp] = 0;
08406 R__insp.Inspect(R__cl, R__parent, "*TC", &TC);
08407 R__insp.Inspect(R__cl, R__parent, "CO", (void*)&CO);
08408 ROOT::GenericShowMembers("vector<SRCO*>", (void*)&CO, R__insp, strcat(R__parent,"CO."),true);
08409 R__parent[R__ncp] = 0;
08410 R__insp.Inspect(R__cl, R__parent, "TH", (void*)&TH);
08411 ROOT::GenericShowMembers("vector<X1TH*>", (void*)&TH, R__insp, strcat(R__parent,"TH."),true);
08412 R__parent[R__ncp] = 0;
08413 R__insp.Inspect(R__cl, R__parent, "XD", (void*)&XD);
08414 ROOT::GenericShowMembers("vector<X1AD*>", (void*)&XD, R__insp, strcat(R__parent,"XD."),true);
08415 R__parent[R__ncp] = 0;
08416 TObject::ShowMembers(R__insp, R__parent);
08417 }
08418
08419 namespace ROOT {
08420
08421 TClass *QHAC_IsA(const void *obj) {
08422 return ((::QHAC*)obj)->IsA();
08423 }
08424
08425 void *new_QHAC(void *p) {
08426 return p ? new(p) ::QHAC : new ::QHAC;
08427 }
08428 void *newArray_QHAC(Long_t size) {
08429 return new ::QHAC[size];
08430 }
08431
08432 void delete_QHAC(void *p) {
08433 delete ((::QHAC*)p);
08434 }
08435 void deleteArray_QHAC(void *p) {
08436 delete [] ((::QHAC*)p);
08437 }
08438 void destruct_QHAC(void *p) {
08439 typedef ::QHAC current_t;
08440 ((current_t*)p)->~current_t();
08441 }
08442 }
08443
08444
08445
08446
08447
08448 #ifdef G__MEMTEST
08449 #undef malloc
08450 #undef free
08451 #endif
08452
08453 extern "C" void G__cpp_reset_tagtableBankClassesDict();
08454
08455 extern "C" void G__set_cpp_environmentBankClassesDict() {
08456 G__add_compiledheader("TROOT.h");
08457 G__add_compiledheader("TMemberInspector.h");
08458 G__add_compiledheader("BankClasses.h");
08459 G__cpp_reset_tagtableBankClassesDict();
08460 }
08461 class G__BankClassesDictdOcpp_tag {};
08462
08463 void* operator new(size_t size,G__BankClassesDictdOcpp_tag* p) {
08464 if(p && G__PVOID!=G__getgvp()) return((void*)p);
08465 #ifndef G__ROOT
08466 return(malloc(size));
08467 #else
08468 return(::operator new(size));
08469 #endif
08470 }
08471
08472
08473 #ifdef G__EH_DUMMY_DELETE
08474 void operator delete(void *p,G__BankClassesDictdOcpp_tag* x) {
08475 if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
08476 #ifndef G__ROOT
08477 free(p);
08478 #else
08479 ::operator delete(p);
08480 #endif
08481 }
08482 #endif
08483
08484 static void G__operator_delete(void *p) {
08485 if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
08486 #ifndef G__ROOT
08487 free(p);
08488 #else
08489 ::operator delete(p);
08490 #endif
08491 }
08492
08493 void G__DELDMY_BankClassesDictdOcpp() { G__operator_delete(0); }
08494
08495 extern "C" int G__cpp_dllrevBankClassesDict() { return(30051515); }
08496
08497
08498
08499
08500
08501
08502 static int G__BankClassesDict_217_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08503 QLIN *p=NULL;
08504 if(G__getaryconstruct()) p=new QLIN[G__getaryconstruct()];
08505 else p=new QLIN;
08506 result7->obj.i = (long)p;
08507 result7->ref = (long)p;
08508 result7->type = 'u';
08509 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QLIN);
08510 return(1 || funcname || hash || result7 || libp) ;
08511 }
08512
08513 static int G__BankClassesDict_217_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08514 G__letint(result7,85,(long)QLIN::Class());
08515 return(1 || funcname || hash || result7 || libp) ;
08516 }
08517
08518 static int G__BankClassesDict_217_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08519 G__letint(result7,67,(long)QLIN::Class_Name());
08520 return(1 || funcname || hash || result7 || libp) ;
08521 }
08522
08523 static int G__BankClassesDict_217_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08524 G__letint(result7,115,(long)QLIN::Class_Version());
08525 return(1 || funcname || hash || result7 || libp) ;
08526 }
08527
08528 static int G__BankClassesDict_217_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08529 G__setnull(result7);
08530 QLIN::Dictionary();
08531 return(1 || funcname || hash || result7 || libp) ;
08532 }
08533
08534 static int G__BankClassesDict_217_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08535 G__letint(result7,85,(long)((const QLIN*)(G__getstructoffset()))->IsA());
08536 return(1 || funcname || hash || result7 || libp) ;
08537 }
08538
08539 static int G__BankClassesDict_217_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08540 G__setnull(result7);
08541 ((QLIN*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
08542 return(1 || funcname || hash || result7 || libp) ;
08543 }
08544
08545 static int G__BankClassesDict_217_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08546 G__setnull(result7);
08547 ((QLIN*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
08548 return(1 || funcname || hash || result7 || libp) ;
08549 }
08550
08551 static int G__BankClassesDict_217_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08552 G__setnull(result7);
08553 ((QLIN*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
08554 return(1 || funcname || hash || result7 || libp) ;
08555 }
08556
08557 static int G__BankClassesDict_217_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08558 G__letint(result7,67,(long)QLIN::DeclFileName());
08559 return(1 || funcname || hash || result7 || libp) ;
08560 }
08561
08562 static int G__BankClassesDict_217_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08563 G__letint(result7,105,(long)QLIN::ImplFileLine());
08564 return(1 || funcname || hash || result7 || libp) ;
08565 }
08566
08567 static int G__BankClassesDict_217_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08568 G__letint(result7,67,(long)QLIN::ImplFileName());
08569 return(1 || funcname || hash || result7 || libp) ;
08570 }
08571
08572 static int G__BankClassesDict_217_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08573 G__letint(result7,105,(long)QLIN::DeclFileLine());
08574 return(1 || funcname || hash || result7 || libp) ;
08575 }
08576
08577
08578 static int G__BankClassesDict_217_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
08579 {
08580 QLIN *p;
08581 p=new QLIN(*(QLIN*)G__int(libp->para[0]));
08582 result7->obj.i = (long)p;
08583 result7->ref = (long)p;
08584 result7->type = 'u';
08585 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QLIN);
08586 return(1 || funcname || hash || result7 || libp) ;
08587 }
08588
08589
08590 typedef QLIN G__TQLIN;
08591 static int G__BankClassesDict_217_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08592 if(0==G__getstructoffset()) return(1);
08593 if(G__getaryconstruct())
08594 if(G__PVOID==G__getgvp())
08595 delete[] (QLIN *)(G__getstructoffset());
08596 else
08597 for(int i=G__getaryconstruct()-1;i>=0;i--)
08598 delete (QLIN *)((G__getstructoffset())+sizeof(QLIN)*i);
08599 else delete (QLIN *)(G__getstructoffset());
08600 G__setnull(result7);
08601 return(1 || funcname || hash || result7 || libp) ;
08602 }
08603
08604
08605
08606 static int G__BankClassesDict_218_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08607 QMTL *p=NULL;
08608 if(G__getaryconstruct()) p=new QMTL[G__getaryconstruct()];
08609 else p=new QMTL;
08610 result7->obj.i = (long)p;
08611 result7->ref = (long)p;
08612 result7->type = 'u';
08613 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QMTL);
08614 return(1 || funcname || hash || result7 || libp) ;
08615 }
08616
08617 static int G__BankClassesDict_218_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08618 G__letint(result7,85,(long)QMTL::Class());
08619 return(1 || funcname || hash || result7 || libp) ;
08620 }
08621
08622 static int G__BankClassesDict_218_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08623 G__letint(result7,67,(long)QMTL::Class_Name());
08624 return(1 || funcname || hash || result7 || libp) ;
08625 }
08626
08627 static int G__BankClassesDict_218_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08628 G__letint(result7,115,(long)QMTL::Class_Version());
08629 return(1 || funcname || hash || result7 || libp) ;
08630 }
08631
08632 static int G__BankClassesDict_218_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08633 G__setnull(result7);
08634 QMTL::Dictionary();
08635 return(1 || funcname || hash || result7 || libp) ;
08636 }
08637
08638 static int G__BankClassesDict_218_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08639 G__letint(result7,85,(long)((const QMTL*)(G__getstructoffset()))->IsA());
08640 return(1 || funcname || hash || result7 || libp) ;
08641 }
08642
08643 static int G__BankClassesDict_218_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08644 G__setnull(result7);
08645 ((QMTL*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
08646 return(1 || funcname || hash || result7 || libp) ;
08647 }
08648
08649 static int G__BankClassesDict_218_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08650 G__setnull(result7);
08651 ((QMTL*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
08652 return(1 || funcname || hash || result7 || libp) ;
08653 }
08654
08655 static int G__BankClassesDict_218_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08656 G__setnull(result7);
08657 ((QMTL*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
08658 return(1 || funcname || hash || result7 || libp) ;
08659 }
08660
08661 static int G__BankClassesDict_218_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08662 G__letint(result7,67,(long)QMTL::DeclFileName());
08663 return(1 || funcname || hash || result7 || libp) ;
08664 }
08665
08666 static int G__BankClassesDict_218_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08667 G__letint(result7,105,(long)QMTL::ImplFileLine());
08668 return(1 || funcname || hash || result7 || libp) ;
08669 }
08670
08671 static int G__BankClassesDict_218_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08672 G__letint(result7,67,(long)QMTL::ImplFileName());
08673 return(1 || funcname || hash || result7 || libp) ;
08674 }
08675
08676 static int G__BankClassesDict_218_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08677 G__letint(result7,105,(long)QMTL::DeclFileLine());
08678 return(1 || funcname || hash || result7 || libp) ;
08679 }
08680
08681
08682 static int G__BankClassesDict_218_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
08683 {
08684 QMTL *p;
08685 p=new QMTL(*(QMTL*)G__int(libp->para[0]));
08686 result7->obj.i = (long)p;
08687 result7->ref = (long)p;
08688 result7->type = 'u';
08689 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QMTL);
08690 return(1 || funcname || hash || result7 || libp) ;
08691 }
08692
08693
08694 typedef QMTL G__TQMTL;
08695 static int G__BankClassesDict_218_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08696 if(0==G__getstructoffset()) return(1);
08697 if(G__getaryconstruct())
08698 if(G__PVOID==G__getgvp())
08699 delete[] (QMTL *)(G__getstructoffset());
08700 else
08701 for(int i=G__getaryconstruct()-1;i>=0;i--)
08702 delete (QMTL *)((G__getstructoffset())+sizeof(QMTL)*i);
08703 else delete (QMTL *)(G__getstructoffset());
08704 G__setnull(result7);
08705 return(1 || funcname || hash || result7 || libp) ;
08706 }
08707
08708
08709
08710 static int G__BankClassesDict_219_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08711 QMTS *p=NULL;
08712 if(G__getaryconstruct()) p=new QMTS[G__getaryconstruct()];
08713 else p=new QMTS;
08714 result7->obj.i = (long)p;
08715 result7->ref = (long)p;
08716 result7->type = 'u';
08717 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QMTS);
08718 return(1 || funcname || hash || result7 || libp) ;
08719 }
08720
08721 static int G__BankClassesDict_219_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08722 G__letint(result7,85,(long)QMTS::Class());
08723 return(1 || funcname || hash || result7 || libp) ;
08724 }
08725
08726 static int G__BankClassesDict_219_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08727 G__letint(result7,67,(long)QMTS::Class_Name());
08728 return(1 || funcname || hash || result7 || libp) ;
08729 }
08730
08731 static int G__BankClassesDict_219_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08732 G__letint(result7,115,(long)QMTS::Class_Version());
08733 return(1 || funcname || hash || result7 || libp) ;
08734 }
08735
08736 static int G__BankClassesDict_219_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08737 G__setnull(result7);
08738 QMTS::Dictionary();
08739 return(1 || funcname || hash || result7 || libp) ;
08740 }
08741
08742 static int G__BankClassesDict_219_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08743 G__letint(result7,85,(long)((const QMTS*)(G__getstructoffset()))->IsA());
08744 return(1 || funcname || hash || result7 || libp) ;
08745 }
08746
08747 static int G__BankClassesDict_219_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08748 G__setnull(result7);
08749 ((QMTS*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
08750 return(1 || funcname || hash || result7 || libp) ;
08751 }
08752
08753 static int G__BankClassesDict_219_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08754 G__setnull(result7);
08755 ((QMTS*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
08756 return(1 || funcname || hash || result7 || libp) ;
08757 }
08758
08759 static int G__BankClassesDict_219_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08760 G__setnull(result7);
08761 ((QMTS*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
08762 return(1 || funcname || hash || result7 || libp) ;
08763 }
08764
08765 static int G__BankClassesDict_219_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08766 G__letint(result7,67,(long)QMTS::DeclFileName());
08767 return(1 || funcname || hash || result7 || libp) ;
08768 }
08769
08770 static int G__BankClassesDict_219_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08771 G__letint(result7,105,(long)QMTS::ImplFileLine());
08772 return(1 || funcname || hash || result7 || libp) ;
08773 }
08774
08775 static int G__BankClassesDict_219_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08776 G__letint(result7,67,(long)QMTS::ImplFileName());
08777 return(1 || funcname || hash || result7 || libp) ;
08778 }
08779
08780 static int G__BankClassesDict_219_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08781 G__letint(result7,105,(long)QMTS::DeclFileLine());
08782 return(1 || funcname || hash || result7 || libp) ;
08783 }
08784
08785
08786 static int G__BankClassesDict_219_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
08787 {
08788 QMTS *p;
08789 p=new QMTS(*(QMTS*)G__int(libp->para[0]));
08790 result7->obj.i = (long)p;
08791 result7->ref = (long)p;
08792 result7->type = 'u';
08793 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QMTS);
08794 return(1 || funcname || hash || result7 || libp) ;
08795 }
08796
08797
08798 typedef QMTS G__TQMTS;
08799 static int G__BankClassesDict_219_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08800 if(0==G__getstructoffset()) return(1);
08801 if(G__getaryconstruct())
08802 if(G__PVOID==G__getgvp())
08803 delete[] (QMTS *)(G__getstructoffset());
08804 else
08805 for(int i=G__getaryconstruct()-1;i>=0;i--)
08806 delete (QMTS *)((G__getstructoffset())+sizeof(QMTS)*i);
08807 else delete (QMTS *)(G__getstructoffset());
08808 G__setnull(result7);
08809 return(1 || funcname || hash || result7 || libp) ;
08810 }
08811
08812
08813
08814 static int G__BankClassesDict_220_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08815 FRFT *p=NULL;
08816 if(G__getaryconstruct()) p=new FRFT[G__getaryconstruct()];
08817 else p=new FRFT;
08818 result7->obj.i = (long)p;
08819 result7->ref = (long)p;
08820 result7->type = 'u';
08821 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FRFT);
08822 return(1 || funcname || hash || result7 || libp) ;
08823 }
08824
08825 static int G__BankClassesDict_220_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08826 G__setnull(result7);
08827 ((FRFT*)(G__getstructoffset()))->Assign((FRFT_PATTERN*)G__int(libp->para[0]));
08828 return(1 || funcname || hash || result7 || libp) ;
08829 }
08830
08831 static int G__BankClassesDict_220_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08832 G__letint(result7,85,(long)FRFT::Class());
08833 return(1 || funcname || hash || result7 || libp) ;
08834 }
08835
08836 static int G__BankClassesDict_220_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08837 G__letint(result7,67,(long)FRFT::Class_Name());
08838 return(1 || funcname || hash || result7 || libp) ;
08839 }
08840
08841 static int G__BankClassesDict_220_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08842 G__letint(result7,115,(long)FRFT::Class_Version());
08843 return(1 || funcname || hash || result7 || libp) ;
08844 }
08845
08846 static int G__BankClassesDict_220_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08847 G__setnull(result7);
08848 FRFT::Dictionary();
08849 return(1 || funcname || hash || result7 || libp) ;
08850 }
08851
08852 static int G__BankClassesDict_220_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08853 G__letint(result7,85,(long)((const FRFT*)(G__getstructoffset()))->IsA());
08854 return(1 || funcname || hash || result7 || libp) ;
08855 }
08856
08857 static int G__BankClassesDict_220_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08858 G__setnull(result7);
08859 ((FRFT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
08860 return(1 || funcname || hash || result7 || libp) ;
08861 }
08862
08863 static int G__BankClassesDict_220_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08864 G__setnull(result7);
08865 ((FRFT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
08866 return(1 || funcname || hash || result7 || libp) ;
08867 }
08868
08869 static int G__BankClassesDict_220_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08870 G__setnull(result7);
08871 ((FRFT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
08872 return(1 || funcname || hash || result7 || libp) ;
08873 }
08874
08875 static int G__BankClassesDict_220_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08876 G__letint(result7,67,(long)FRFT::DeclFileName());
08877 return(1 || funcname || hash || result7 || libp) ;
08878 }
08879
08880 static int G__BankClassesDict_220_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08881 G__letint(result7,105,(long)FRFT::ImplFileLine());
08882 return(1 || funcname || hash || result7 || libp) ;
08883 }
08884
08885 static int G__BankClassesDict_220_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08886 G__letint(result7,67,(long)FRFT::ImplFileName());
08887 return(1 || funcname || hash || result7 || libp) ;
08888 }
08889
08890 static int G__BankClassesDict_220_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08891 G__letint(result7,105,(long)FRFT::DeclFileLine());
08892 return(1 || funcname || hash || result7 || libp) ;
08893 }
08894
08895
08896 static int G__BankClassesDict_220_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
08897 {
08898 FRFT *p;
08899 p=new FRFT(*(FRFT*)G__int(libp->para[0]));
08900 result7->obj.i = (long)p;
08901 result7->ref = (long)p;
08902 result7->type = 'u';
08903 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FRFT);
08904 return(1 || funcname || hash || result7 || libp) ;
08905 }
08906
08907
08908 typedef FRFT G__TFRFT;
08909 static int G__BankClassesDict_220_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08910 if(0==G__getstructoffset()) return(1);
08911 if(G__getaryconstruct())
08912 if(G__PVOID==G__getgvp())
08913 delete[] (FRFT *)(G__getstructoffset());
08914 else
08915 for(int i=G__getaryconstruct()-1;i>=0;i--)
08916 delete (FRFT *)((G__getstructoffset())+sizeof(FRFT)*i);
08917 else delete (FRFT *)(G__getstructoffset());
08918 G__setnull(result7);
08919 return(1 || funcname || hash || result7 || libp) ;
08920 }
08921
08922
08923
08924 static int G__BankClassesDict_221_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08925 FRTL *p=NULL;
08926 if(G__getaryconstruct()) p=new FRTL[G__getaryconstruct()];
08927 else p=new FRTL;
08928 result7->obj.i = (long)p;
08929 result7->ref = (long)p;
08930 result7->type = 'u';
08931 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FRTL);
08932 return(1 || funcname || hash || result7 || libp) ;
08933 }
08934
08935 static int G__BankClassesDict_221_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08936 G__setnull(result7);
08937 ((FRTL*)(G__getstructoffset()))->Assign((FRTL_PATTERN*)G__int(libp->para[0]));
08938 return(1 || funcname || hash || result7 || libp) ;
08939 }
08940
08941 static int G__BankClassesDict_221_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08942 G__letint(result7,85,(long)FRTL::Class());
08943 return(1 || funcname || hash || result7 || libp) ;
08944 }
08945
08946 static int G__BankClassesDict_221_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08947 G__letint(result7,67,(long)FRTL::Class_Name());
08948 return(1 || funcname || hash || result7 || libp) ;
08949 }
08950
08951 static int G__BankClassesDict_221_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08952 G__letint(result7,115,(long)FRTL::Class_Version());
08953 return(1 || funcname || hash || result7 || libp) ;
08954 }
08955
08956 static int G__BankClassesDict_221_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08957 G__setnull(result7);
08958 FRTL::Dictionary();
08959 return(1 || funcname || hash || result7 || libp) ;
08960 }
08961
08962 static int G__BankClassesDict_221_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08963 G__letint(result7,85,(long)((const FRTL*)(G__getstructoffset()))->IsA());
08964 return(1 || funcname || hash || result7 || libp) ;
08965 }
08966
08967 static int G__BankClassesDict_221_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08968 G__setnull(result7);
08969 ((FRTL*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
08970 return(1 || funcname || hash || result7 || libp) ;
08971 }
08972
08973 static int G__BankClassesDict_221_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08974 G__setnull(result7);
08975 ((FRTL*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
08976 return(1 || funcname || hash || result7 || libp) ;
08977 }
08978
08979 static int G__BankClassesDict_221_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08980 G__setnull(result7);
08981 ((FRTL*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
08982 return(1 || funcname || hash || result7 || libp) ;
08983 }
08984
08985 static int G__BankClassesDict_221_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08986 G__letint(result7,67,(long)FRTL::DeclFileName());
08987 return(1 || funcname || hash || result7 || libp) ;
08988 }
08989
08990 static int G__BankClassesDict_221_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08991 G__letint(result7,105,(long)FRTL::ImplFileLine());
08992 return(1 || funcname || hash || result7 || libp) ;
08993 }
08994
08995 static int G__BankClassesDict_221_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
08996 G__letint(result7,67,(long)FRTL::ImplFileName());
08997 return(1 || funcname || hash || result7 || libp) ;
08998 }
08999
09000 static int G__BankClassesDict_221_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09001 G__letint(result7,105,(long)FRTL::DeclFileLine());
09002 return(1 || funcname || hash || result7 || libp) ;
09003 }
09004
09005
09006 static int G__BankClassesDict_221_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09007 {
09008 FRTL *p;
09009 p=new FRTL(*(FRTL*)G__int(libp->para[0]));
09010 result7->obj.i = (long)p;
09011 result7->ref = (long)p;
09012 result7->type = 'u';
09013 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FRTL);
09014 return(1 || funcname || hash || result7 || libp) ;
09015 }
09016
09017
09018 typedef FRTL G__TFRTL;
09019 static int G__BankClassesDict_221_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09020 if(0==G__getstructoffset()) return(1);
09021 if(G__getaryconstruct())
09022 if(G__PVOID==G__getgvp())
09023 delete[] (FRTL *)(G__getstructoffset());
09024 else
09025 for(int i=G__getaryconstruct()-1;i>=0;i--)
09026 delete (FRTL *)((G__getstructoffset())+sizeof(FRTL)*i);
09027 else delete (FRTL *)(G__getstructoffset());
09028 G__setnull(result7);
09029 return(1 || funcname || hash || result7 || libp) ;
09030 }
09031
09032
09033
09034 static int G__BankClassesDict_222_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09035 TEXS *p=NULL;
09036 if(G__getaryconstruct()) p=new TEXS[G__getaryconstruct()];
09037 else p=new TEXS;
09038 result7->obj.i = (long)p;
09039 result7->ref = (long)p;
09040 result7->type = 'u';
09041 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_TEXS);
09042 return(1 || funcname || hash || result7 || libp) ;
09043 }
09044
09045 static int G__BankClassesDict_222_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09046 G__setnull(result7);
09047 ((TEXS*)(G__getstructoffset()))->Assign((TEXS_PATTERN*)G__int(libp->para[0]));
09048 return(1 || funcname || hash || result7 || libp) ;
09049 }
09050
09051 static int G__BankClassesDict_222_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09052 G__letint(result7,85,(long)TEXS::Class());
09053 return(1 || funcname || hash || result7 || libp) ;
09054 }
09055
09056 static int G__BankClassesDict_222_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09057 G__letint(result7,67,(long)TEXS::Class_Name());
09058 return(1 || funcname || hash || result7 || libp) ;
09059 }
09060
09061 static int G__BankClassesDict_222_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09062 G__letint(result7,115,(long)TEXS::Class_Version());
09063 return(1 || funcname || hash || result7 || libp) ;
09064 }
09065
09066 static int G__BankClassesDict_222_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09067 G__setnull(result7);
09068 TEXS::Dictionary();
09069 return(1 || funcname || hash || result7 || libp) ;
09070 }
09071
09072 static int G__BankClassesDict_222_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09073 G__letint(result7,85,(long)((const TEXS*)(G__getstructoffset()))->IsA());
09074 return(1 || funcname || hash || result7 || libp) ;
09075 }
09076
09077 static int G__BankClassesDict_222_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09078 G__setnull(result7);
09079 ((TEXS*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09080 return(1 || funcname || hash || result7 || libp) ;
09081 }
09082
09083 static int G__BankClassesDict_222_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09084 G__setnull(result7);
09085 ((TEXS*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09086 return(1 || funcname || hash || result7 || libp) ;
09087 }
09088
09089 static int G__BankClassesDict_222_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09090 G__setnull(result7);
09091 ((TEXS*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09092 return(1 || funcname || hash || result7 || libp) ;
09093 }
09094
09095 static int G__BankClassesDict_222_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09096 G__letint(result7,67,(long)TEXS::DeclFileName());
09097 return(1 || funcname || hash || result7 || libp) ;
09098 }
09099
09100 static int G__BankClassesDict_222_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09101 G__letint(result7,105,(long)TEXS::ImplFileLine());
09102 return(1 || funcname || hash || result7 || libp) ;
09103 }
09104
09105 static int G__BankClassesDict_222_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09106 G__letint(result7,67,(long)TEXS::ImplFileName());
09107 return(1 || funcname || hash || result7 || libp) ;
09108 }
09109
09110 static int G__BankClassesDict_222_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09111 G__letint(result7,105,(long)TEXS::DeclFileLine());
09112 return(1 || funcname || hash || result7 || libp) ;
09113 }
09114
09115
09116 static int G__BankClassesDict_222_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09117 {
09118 TEXS *p;
09119 p=new TEXS(*(TEXS*)G__int(libp->para[0]));
09120 result7->obj.i = (long)p;
09121 result7->ref = (long)p;
09122 result7->type = 'u';
09123 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_TEXS);
09124 return(1 || funcname || hash || result7 || libp) ;
09125 }
09126
09127
09128 typedef TEXS G__TTEXS;
09129 static int G__BankClassesDict_222_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09130 if(0==G__getstructoffset()) return(1);
09131 if(G__getaryconstruct())
09132 if(G__PVOID==G__getgvp())
09133 delete[] (TEXS *)(G__getstructoffset());
09134 else
09135 for(int i=G__getaryconstruct()-1;i>=0;i--)
09136 delete (TEXS *)((G__getstructoffset())+sizeof(TEXS)*i);
09137 else delete (TEXS *)(G__getstructoffset());
09138 G__setnull(result7);
09139 return(1 || funcname || hash || result7 || libp) ;
09140 }
09141
09142
09143
09144 static int G__BankClassesDict_223_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09145 HMAD *p=NULL;
09146 if(G__getaryconstruct()) p=new HMAD[G__getaryconstruct()];
09147 else p=new HMAD;
09148 result7->obj.i = (long)p;
09149 result7->ref = (long)p;
09150 result7->type = 'u';
09151 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_HMAD);
09152 return(1 || funcname || hash || result7 || libp) ;
09153 }
09154
09155 static int G__BankClassesDict_223_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09156 G__setnull(result7);
09157 ((HMAD*)(G__getstructoffset()))->Assign((HMAD_PATTERN*)G__int(libp->para[0]));
09158 return(1 || funcname || hash || result7 || libp) ;
09159 }
09160
09161 static int G__BankClassesDict_223_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09162 G__letint(result7,85,(long)HMAD::Class());
09163 return(1 || funcname || hash || result7 || libp) ;
09164 }
09165
09166 static int G__BankClassesDict_223_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09167 G__letint(result7,67,(long)HMAD::Class_Name());
09168 return(1 || funcname || hash || result7 || libp) ;
09169 }
09170
09171 static int G__BankClassesDict_223_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09172 G__letint(result7,115,(long)HMAD::Class_Version());
09173 return(1 || funcname || hash || result7 || libp) ;
09174 }
09175
09176 static int G__BankClassesDict_223_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09177 G__setnull(result7);
09178 HMAD::Dictionary();
09179 return(1 || funcname || hash || result7 || libp) ;
09180 }
09181
09182 static int G__BankClassesDict_223_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09183 G__letint(result7,85,(long)((const HMAD*)(G__getstructoffset()))->IsA());
09184 return(1 || funcname || hash || result7 || libp) ;
09185 }
09186
09187 static int G__BankClassesDict_223_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09188 G__setnull(result7);
09189 ((HMAD*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09190 return(1 || funcname || hash || result7 || libp) ;
09191 }
09192
09193 static int G__BankClassesDict_223_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09194 G__setnull(result7);
09195 ((HMAD*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09196 return(1 || funcname || hash || result7 || libp) ;
09197 }
09198
09199 static int G__BankClassesDict_223_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09200 G__setnull(result7);
09201 ((HMAD*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09202 return(1 || funcname || hash || result7 || libp) ;
09203 }
09204
09205 static int G__BankClassesDict_223_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09206 G__letint(result7,67,(long)HMAD::DeclFileName());
09207 return(1 || funcname || hash || result7 || libp) ;
09208 }
09209
09210 static int G__BankClassesDict_223_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09211 G__letint(result7,105,(long)HMAD::ImplFileLine());
09212 return(1 || funcname || hash || result7 || libp) ;
09213 }
09214
09215 static int G__BankClassesDict_223_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09216 G__letint(result7,67,(long)HMAD::ImplFileName());
09217 return(1 || funcname || hash || result7 || libp) ;
09218 }
09219
09220 static int G__BankClassesDict_223_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09221 G__letint(result7,105,(long)HMAD::DeclFileLine());
09222 return(1 || funcname || hash || result7 || libp) ;
09223 }
09224
09225
09226 static int G__BankClassesDict_223_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09227 {
09228 HMAD *p;
09229 p=new HMAD(*(HMAD*)G__int(libp->para[0]));
09230 result7->obj.i = (long)p;
09231 result7->ref = (long)p;
09232 result7->type = 'u';
09233 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_HMAD);
09234 return(1 || funcname || hash || result7 || libp) ;
09235 }
09236
09237
09238 typedef HMAD G__THMAD;
09239 static int G__BankClassesDict_223_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09240 if(0==G__getstructoffset()) return(1);
09241 if(G__getaryconstruct())
09242 if(G__PVOID==G__getgvp())
09243 delete[] (HMAD *)(G__getstructoffset());
09244 else
09245 for(int i=G__getaryconstruct()-1;i>=0;i--)
09246 delete (HMAD *)((G__getstructoffset())+sizeof(HMAD)*i);
09247 else delete (HMAD *)(G__getstructoffset());
09248 G__setnull(result7);
09249 return(1 || funcname || hash || result7 || libp) ;
09250 }
09251
09252
09253
09254 static int G__BankClassesDict_224_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09255 MCAD *p=NULL;
09256 if(G__getaryconstruct()) p=new MCAD[G__getaryconstruct()];
09257 else p=new MCAD;
09258 result7->obj.i = (long)p;
09259 result7->ref = (long)p;
09260 result7->type = 'u';
09261 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_MCAD);
09262 return(1 || funcname || hash || result7 || libp) ;
09263 }
09264
09265 static int G__BankClassesDict_224_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09266 G__setnull(result7);
09267 ((MCAD*)(G__getstructoffset()))->Assign((MCAD_PATTERN*)G__int(libp->para[0]));
09268 return(1 || funcname || hash || result7 || libp) ;
09269 }
09270
09271 static int G__BankClassesDict_224_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09272 G__letint(result7,85,(long)MCAD::Class());
09273 return(1 || funcname || hash || result7 || libp) ;
09274 }
09275
09276 static int G__BankClassesDict_224_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09277 G__letint(result7,67,(long)MCAD::Class_Name());
09278 return(1 || funcname || hash || result7 || libp) ;
09279 }
09280
09281 static int G__BankClassesDict_224_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09282 G__letint(result7,115,(long)MCAD::Class_Version());
09283 return(1 || funcname || hash || result7 || libp) ;
09284 }
09285
09286 static int G__BankClassesDict_224_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09287 G__setnull(result7);
09288 MCAD::Dictionary();
09289 return(1 || funcname || hash || result7 || libp) ;
09290 }
09291
09292 static int G__BankClassesDict_224_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09293 G__letint(result7,85,(long)((const MCAD*)(G__getstructoffset()))->IsA());
09294 return(1 || funcname || hash || result7 || libp) ;
09295 }
09296
09297 static int G__BankClassesDict_224_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09298 G__setnull(result7);
09299 ((MCAD*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09300 return(1 || funcname || hash || result7 || libp) ;
09301 }
09302
09303 static int G__BankClassesDict_224_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09304 G__setnull(result7);
09305 ((MCAD*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09306 return(1 || funcname || hash || result7 || libp) ;
09307 }
09308
09309 static int G__BankClassesDict_224_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09310 G__setnull(result7);
09311 ((MCAD*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09312 return(1 || funcname || hash || result7 || libp) ;
09313 }
09314
09315 static int G__BankClassesDict_224_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09316 G__letint(result7,67,(long)MCAD::DeclFileName());
09317 return(1 || funcname || hash || result7 || libp) ;
09318 }
09319
09320 static int G__BankClassesDict_224_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09321 G__letint(result7,105,(long)MCAD::ImplFileLine());
09322 return(1 || funcname || hash || result7 || libp) ;
09323 }
09324
09325 static int G__BankClassesDict_224_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09326 G__letint(result7,67,(long)MCAD::ImplFileName());
09327 return(1 || funcname || hash || result7 || libp) ;
09328 }
09329
09330 static int G__BankClassesDict_224_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09331 G__letint(result7,105,(long)MCAD::DeclFileLine());
09332 return(1 || funcname || hash || result7 || libp) ;
09333 }
09334
09335
09336 static int G__BankClassesDict_224_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09337 {
09338 MCAD *p;
09339 p=new MCAD(*(MCAD*)G__int(libp->para[0]));
09340 result7->obj.i = (long)p;
09341 result7->ref = (long)p;
09342 result7->type = 'u';
09343 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_MCAD);
09344 return(1 || funcname || hash || result7 || libp) ;
09345 }
09346
09347
09348 typedef MCAD G__TMCAD;
09349 static int G__BankClassesDict_224_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09350 if(0==G__getstructoffset()) return(1);
09351 if(G__getaryconstruct())
09352 if(G__PVOID==G__getgvp())
09353 delete[] (MCAD *)(G__getstructoffset());
09354 else
09355 for(int i=G__getaryconstruct()-1;i>=0;i--)
09356 delete (MCAD *)((G__getstructoffset())+sizeof(MCAD)*i);
09357 else delete (MCAD *)(G__getstructoffset());
09358 G__setnull(result7);
09359 return(1 || funcname || hash || result7 || libp) ;
09360 }
09361
09362
09363
09364 static int G__BankClassesDict_225_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09365 PECO *p=NULL;
09366 if(G__getaryconstruct()) p=new PECO[G__getaryconstruct()];
09367 else p=new PECO;
09368 result7->obj.i = (long)p;
09369 result7->ref = (long)p;
09370 result7->type = 'u';
09371 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PECO);
09372 return(1 || funcname || hash || result7 || libp) ;
09373 }
09374
09375 static int G__BankClassesDict_225_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09376 G__setnull(result7);
09377 ((PECO*)(G__getstructoffset()))->Assign((PECO_PATTERN*)G__int(libp->para[0]));
09378 return(1 || funcname || hash || result7 || libp) ;
09379 }
09380
09381 static int G__BankClassesDict_225_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09382 G__letint(result7,85,(long)PECO::Class());
09383 return(1 || funcname || hash || result7 || libp) ;
09384 }
09385
09386 static int G__BankClassesDict_225_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09387 G__letint(result7,67,(long)PECO::Class_Name());
09388 return(1 || funcname || hash || result7 || libp) ;
09389 }
09390
09391 static int G__BankClassesDict_225_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09392 G__letint(result7,115,(long)PECO::Class_Version());
09393 return(1 || funcname || hash || result7 || libp) ;
09394 }
09395
09396 static int G__BankClassesDict_225_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09397 G__setnull(result7);
09398 PECO::Dictionary();
09399 return(1 || funcname || hash || result7 || libp) ;
09400 }
09401
09402 static int G__BankClassesDict_225_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09403 G__letint(result7,85,(long)((const PECO*)(G__getstructoffset()))->IsA());
09404 return(1 || funcname || hash || result7 || libp) ;
09405 }
09406
09407 static int G__BankClassesDict_225_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09408 G__setnull(result7);
09409 ((PECO*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09410 return(1 || funcname || hash || result7 || libp) ;
09411 }
09412
09413 static int G__BankClassesDict_225_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09414 G__setnull(result7);
09415 ((PECO*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09416 return(1 || funcname || hash || result7 || libp) ;
09417 }
09418
09419 static int G__BankClassesDict_225_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09420 G__setnull(result7);
09421 ((PECO*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09422 return(1 || funcname || hash || result7 || libp) ;
09423 }
09424
09425 static int G__BankClassesDict_225_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09426 G__letint(result7,67,(long)PECO::DeclFileName());
09427 return(1 || funcname || hash || result7 || libp) ;
09428 }
09429
09430 static int G__BankClassesDict_225_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09431 G__letint(result7,105,(long)PECO::ImplFileLine());
09432 return(1 || funcname || hash || result7 || libp) ;
09433 }
09434
09435 static int G__BankClassesDict_225_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09436 G__letint(result7,67,(long)PECO::ImplFileName());
09437 return(1 || funcname || hash || result7 || libp) ;
09438 }
09439
09440 static int G__BankClassesDict_225_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09441 G__letint(result7,105,(long)PECO::DeclFileLine());
09442 return(1 || funcname || hash || result7 || libp) ;
09443 }
09444
09445
09446 static int G__BankClassesDict_225_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09447 {
09448 PECO *p;
09449 p=new PECO(*(PECO*)G__int(libp->para[0]));
09450 result7->obj.i = (long)p;
09451 result7->ref = (long)p;
09452 result7->type = 'u';
09453 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PECO);
09454 return(1 || funcname || hash || result7 || libp) ;
09455 }
09456
09457
09458 typedef PECO G__TPECO;
09459 static int G__BankClassesDict_225_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09460 if(0==G__getstructoffset()) return(1);
09461 if(G__getaryconstruct())
09462 if(G__PVOID==G__getgvp())
09463 delete[] (PECO *)(G__getstructoffset());
09464 else
09465 for(int i=G__getaryconstruct()-1;i>=0;i--)
09466 delete (PECO *)((G__getstructoffset())+sizeof(PECO)*i);
09467 else delete (PECO *)(G__getstructoffset());
09468 G__setnull(result7);
09469 return(1 || funcname || hash || result7 || libp) ;
09470 }
09471
09472
09473
09474 static int G__BankClassesDict_226_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09475 EIDT *p=NULL;
09476 if(G__getaryconstruct()) p=new EIDT[G__getaryconstruct()];
09477 else p=new EIDT;
09478 result7->obj.i = (long)p;
09479 result7->ref = (long)p;
09480 result7->type = 'u';
09481 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EIDT);
09482 return(1 || funcname || hash || result7 || libp) ;
09483 }
09484
09485 static int G__BankClassesDict_226_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09486 G__setnull(result7);
09487 ((EIDT*)(G__getstructoffset()))->Assign((EIDT_PATTERN*)G__int(libp->para[0]));
09488 return(1 || funcname || hash || result7 || libp) ;
09489 }
09490
09491 static int G__BankClassesDict_226_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09492 G__letint(result7,85,(long)EIDT::Class());
09493 return(1 || funcname || hash || result7 || libp) ;
09494 }
09495
09496 static int G__BankClassesDict_226_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09497 G__letint(result7,67,(long)EIDT::Class_Name());
09498 return(1 || funcname || hash || result7 || libp) ;
09499 }
09500
09501 static int G__BankClassesDict_226_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09502 G__letint(result7,115,(long)EIDT::Class_Version());
09503 return(1 || funcname || hash || result7 || libp) ;
09504 }
09505
09506 static int G__BankClassesDict_226_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09507 G__setnull(result7);
09508 EIDT::Dictionary();
09509 return(1 || funcname || hash || result7 || libp) ;
09510 }
09511
09512 static int G__BankClassesDict_226_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09513 G__letint(result7,85,(long)((const EIDT*)(G__getstructoffset()))->IsA());
09514 return(1 || funcname || hash || result7 || libp) ;
09515 }
09516
09517 static int G__BankClassesDict_226_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09518 G__setnull(result7);
09519 ((EIDT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09520 return(1 || funcname || hash || result7 || libp) ;
09521 }
09522
09523 static int G__BankClassesDict_226_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09524 G__setnull(result7);
09525 ((EIDT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09526 return(1 || funcname || hash || result7 || libp) ;
09527 }
09528
09529 static int G__BankClassesDict_226_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09530 G__setnull(result7);
09531 ((EIDT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09532 return(1 || funcname || hash || result7 || libp) ;
09533 }
09534
09535 static int G__BankClassesDict_226_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09536 G__letint(result7,67,(long)EIDT::DeclFileName());
09537 return(1 || funcname || hash || result7 || libp) ;
09538 }
09539
09540 static int G__BankClassesDict_226_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09541 G__letint(result7,105,(long)EIDT::ImplFileLine());
09542 return(1 || funcname || hash || result7 || libp) ;
09543 }
09544
09545 static int G__BankClassesDict_226_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09546 G__letint(result7,67,(long)EIDT::ImplFileName());
09547 return(1 || funcname || hash || result7 || libp) ;
09548 }
09549
09550 static int G__BankClassesDict_226_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09551 G__letint(result7,105,(long)EIDT::DeclFileLine());
09552 return(1 || funcname || hash || result7 || libp) ;
09553 }
09554
09555
09556 static int G__BankClassesDict_226_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09557 {
09558 EIDT *p;
09559 p=new EIDT(*(EIDT*)G__int(libp->para[0]));
09560 result7->obj.i = (long)p;
09561 result7->ref = (long)p;
09562 result7->type = 'u';
09563 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EIDT);
09564 return(1 || funcname || hash || result7 || libp) ;
09565 }
09566
09567
09568 typedef EIDT G__TEIDT;
09569 static int G__BankClassesDict_226_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09570 if(0==G__getstructoffset()) return(1);
09571 if(G__getaryconstruct())
09572 if(G__PVOID==G__getgvp())
09573 delete[] (EIDT *)(G__getstructoffset());
09574 else
09575 for(int i=G__getaryconstruct()-1;i>=0;i--)
09576 delete (EIDT *)((G__getstructoffset())+sizeof(EIDT)*i);
09577 else delete (EIDT *)(G__getstructoffset());
09578 G__setnull(result7);
09579 return(1 || funcname || hash || result7 || libp) ;
09580 }
09581
09582
09583
09584 static int G__BankClassesDict_227_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09585 PHCO *p=NULL;
09586 if(G__getaryconstruct()) p=new PHCO[G__getaryconstruct()];
09587 else p=new PHCO;
09588 result7->obj.i = (long)p;
09589 result7->ref = (long)p;
09590 result7->type = 'u';
09591 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PHCO);
09592 return(1 || funcname || hash || result7 || libp) ;
09593 }
09594
09595 static int G__BankClassesDict_227_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09596 G__setnull(result7);
09597 ((PHCO*)(G__getstructoffset()))->Assign((PHCO_PATTERN*)G__int(libp->para[0]));
09598 return(1 || funcname || hash || result7 || libp) ;
09599 }
09600
09601 static int G__BankClassesDict_227_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09602 G__letint(result7,85,(long)PHCO::Class());
09603 return(1 || funcname || hash || result7 || libp) ;
09604 }
09605
09606 static int G__BankClassesDict_227_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09607 G__letint(result7,67,(long)PHCO::Class_Name());
09608 return(1 || funcname || hash || result7 || libp) ;
09609 }
09610
09611 static int G__BankClassesDict_227_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09612 G__letint(result7,115,(long)PHCO::Class_Version());
09613 return(1 || funcname || hash || result7 || libp) ;
09614 }
09615
09616 static int G__BankClassesDict_227_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09617 G__setnull(result7);
09618 PHCO::Dictionary();
09619 return(1 || funcname || hash || result7 || libp) ;
09620 }
09621
09622 static int G__BankClassesDict_227_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09623 G__letint(result7,85,(long)((const PHCO*)(G__getstructoffset()))->IsA());
09624 return(1 || funcname || hash || result7 || libp) ;
09625 }
09626
09627 static int G__BankClassesDict_227_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09628 G__setnull(result7);
09629 ((PHCO*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09630 return(1 || funcname || hash || result7 || libp) ;
09631 }
09632
09633 static int G__BankClassesDict_227_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09634 G__setnull(result7);
09635 ((PHCO*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09636 return(1 || funcname || hash || result7 || libp) ;
09637 }
09638
09639 static int G__BankClassesDict_227_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09640 G__setnull(result7);
09641 ((PHCO*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09642 return(1 || funcname || hash || result7 || libp) ;
09643 }
09644
09645 static int G__BankClassesDict_227_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09646 G__letint(result7,67,(long)PHCO::DeclFileName());
09647 return(1 || funcname || hash || result7 || libp) ;
09648 }
09649
09650 static int G__BankClassesDict_227_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09651 G__letint(result7,105,(long)PHCO::ImplFileLine());
09652 return(1 || funcname || hash || result7 || libp) ;
09653 }
09654
09655 static int G__BankClassesDict_227_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09656 G__letint(result7,67,(long)PHCO::ImplFileName());
09657 return(1 || funcname || hash || result7 || libp) ;
09658 }
09659
09660 static int G__BankClassesDict_227_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09661 G__letint(result7,105,(long)PHCO::DeclFileLine());
09662 return(1 || funcname || hash || result7 || libp) ;
09663 }
09664
09665
09666 static int G__BankClassesDict_227_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09667 {
09668 PHCO *p;
09669 p=new PHCO(*(PHCO*)G__int(libp->para[0]));
09670 result7->obj.i = (long)p;
09671 result7->ref = (long)p;
09672 result7->type = 'u';
09673 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PHCO);
09674 return(1 || funcname || hash || result7 || libp) ;
09675 }
09676
09677
09678 typedef PHCO G__TPHCO;
09679 static int G__BankClassesDict_227_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09680 if(0==G__getstructoffset()) return(1);
09681 if(G__getaryconstruct())
09682 if(G__PVOID==G__getgvp())
09683 delete[] (PHCO *)(G__getstructoffset());
09684 else
09685 for(int i=G__getaryconstruct()-1;i>=0;i--)
09686 delete (PHCO *)((G__getstructoffset())+sizeof(PHCO)*i);
09687 else delete (PHCO *)(G__getstructoffset());
09688 G__setnull(result7);
09689 return(1 || funcname || hash || result7 || libp) ;
09690 }
09691
09692
09693
09694 static int G__BankClassesDict_228_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09695 PEPT *p=NULL;
09696 if(G__getaryconstruct()) p=new PEPT[G__getaryconstruct()];
09697 else p=new PEPT;
09698 result7->obj.i = (long)p;
09699 result7->ref = (long)p;
09700 result7->type = 'u';
09701 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PEPT);
09702 return(1 || funcname || hash || result7 || libp) ;
09703 }
09704
09705 static int G__BankClassesDict_228_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09706 G__setnull(result7);
09707 ((PEPT*)(G__getstructoffset()))->Assign((PEPT_PATTERN*)G__int(libp->para[0]));
09708 return(1 || funcname || hash || result7 || libp) ;
09709 }
09710
09711 static int G__BankClassesDict_228_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09712 G__letint(result7,85,(long)PEPT::Class());
09713 return(1 || funcname || hash || result7 || libp) ;
09714 }
09715
09716 static int G__BankClassesDict_228_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09717 G__letint(result7,67,(long)PEPT::Class_Name());
09718 return(1 || funcname || hash || result7 || libp) ;
09719 }
09720
09721 static int G__BankClassesDict_228_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09722 G__letint(result7,115,(long)PEPT::Class_Version());
09723 return(1 || funcname || hash || result7 || libp) ;
09724 }
09725
09726 static int G__BankClassesDict_228_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09727 G__setnull(result7);
09728 PEPT::Dictionary();
09729 return(1 || funcname || hash || result7 || libp) ;
09730 }
09731
09732 static int G__BankClassesDict_228_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09733 G__letint(result7,85,(long)((const PEPT*)(G__getstructoffset()))->IsA());
09734 return(1 || funcname || hash || result7 || libp) ;
09735 }
09736
09737 static int G__BankClassesDict_228_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09738 G__setnull(result7);
09739 ((PEPT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09740 return(1 || funcname || hash || result7 || libp) ;
09741 }
09742
09743 static int G__BankClassesDict_228_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09744 G__setnull(result7);
09745 ((PEPT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09746 return(1 || funcname || hash || result7 || libp) ;
09747 }
09748
09749 static int G__BankClassesDict_228_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09750 G__setnull(result7);
09751 ((PEPT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09752 return(1 || funcname || hash || result7 || libp) ;
09753 }
09754
09755 static int G__BankClassesDict_228_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09756 G__letint(result7,67,(long)PEPT::DeclFileName());
09757 return(1 || funcname || hash || result7 || libp) ;
09758 }
09759
09760 static int G__BankClassesDict_228_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09761 G__letint(result7,105,(long)PEPT::ImplFileLine());
09762 return(1 || funcname || hash || result7 || libp) ;
09763 }
09764
09765 static int G__BankClassesDict_228_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09766 G__letint(result7,67,(long)PEPT::ImplFileName());
09767 return(1 || funcname || hash || result7 || libp) ;
09768 }
09769
09770 static int G__BankClassesDict_228_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09771 G__letint(result7,105,(long)PEPT::DeclFileLine());
09772 return(1 || funcname || hash || result7 || libp) ;
09773 }
09774
09775
09776 static int G__BankClassesDict_228_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09777 {
09778 PEPT *p;
09779 p=new PEPT(*(PEPT*)G__int(libp->para[0]));
09780 result7->obj.i = (long)p;
09781 result7->ref = (long)p;
09782 result7->type = 'u';
09783 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PEPT);
09784 return(1 || funcname || hash || result7 || libp) ;
09785 }
09786
09787
09788 typedef PEPT G__TPEPT;
09789 static int G__BankClassesDict_228_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09790 if(0==G__getstructoffset()) return(1);
09791 if(G__getaryconstruct())
09792 if(G__PVOID==G__getgvp())
09793 delete[] (PEPT *)(G__getstructoffset());
09794 else
09795 for(int i=G__getaryconstruct()-1;i>=0;i--)
09796 delete (PEPT *)((G__getstructoffset())+sizeof(PEPT)*i);
09797 else delete (PEPT *)(G__getstructoffset());
09798 G__setnull(result7);
09799 return(1 || funcname || hash || result7 || libp) ;
09800 }
09801
09802
09803
09804 static int G__BankClassesDict_229_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09805 FRID *p=NULL;
09806 if(G__getaryconstruct()) p=new FRID[G__getaryconstruct()];
09807 else p=new FRID;
09808 result7->obj.i = (long)p;
09809 result7->ref = (long)p;
09810 result7->type = 'u';
09811 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FRID);
09812 return(1 || funcname || hash || result7 || libp) ;
09813 }
09814
09815 static int G__BankClassesDict_229_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09816 G__setnull(result7);
09817 ((FRID*)(G__getstructoffset()))->Assign((FRID_PATTERN*)G__int(libp->para[0]));
09818 return(1 || funcname || hash || result7 || libp) ;
09819 }
09820
09821 static int G__BankClassesDict_229_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09822 G__letint(result7,85,(long)FRID::Class());
09823 return(1 || funcname || hash || result7 || libp) ;
09824 }
09825
09826 static int G__BankClassesDict_229_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09827 G__letint(result7,67,(long)FRID::Class_Name());
09828 return(1 || funcname || hash || result7 || libp) ;
09829 }
09830
09831 static int G__BankClassesDict_229_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09832 G__letint(result7,115,(long)FRID::Class_Version());
09833 return(1 || funcname || hash || result7 || libp) ;
09834 }
09835
09836 static int G__BankClassesDict_229_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09837 G__setnull(result7);
09838 FRID::Dictionary();
09839 return(1 || funcname || hash || result7 || libp) ;
09840 }
09841
09842 static int G__BankClassesDict_229_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09843 G__letint(result7,85,(long)((const FRID*)(G__getstructoffset()))->IsA());
09844 return(1 || funcname || hash || result7 || libp) ;
09845 }
09846
09847 static int G__BankClassesDict_229_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09848 G__setnull(result7);
09849 ((FRID*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09850 return(1 || funcname || hash || result7 || libp) ;
09851 }
09852
09853 static int G__BankClassesDict_229_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09854 G__setnull(result7);
09855 ((FRID*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09856 return(1 || funcname || hash || result7 || libp) ;
09857 }
09858
09859 static int G__BankClassesDict_229_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09860 G__setnull(result7);
09861 ((FRID*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09862 return(1 || funcname || hash || result7 || libp) ;
09863 }
09864
09865 static int G__BankClassesDict_229_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09866 G__letint(result7,67,(long)FRID::DeclFileName());
09867 return(1 || funcname || hash || result7 || libp) ;
09868 }
09869
09870 static int G__BankClassesDict_229_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09871 G__letint(result7,105,(long)FRID::ImplFileLine());
09872 return(1 || funcname || hash || result7 || libp) ;
09873 }
09874
09875 static int G__BankClassesDict_229_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09876 G__letint(result7,67,(long)FRID::ImplFileName());
09877 return(1 || funcname || hash || result7 || libp) ;
09878 }
09879
09880 static int G__BankClassesDict_229_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09881 G__letint(result7,105,(long)FRID::DeclFileLine());
09882 return(1 || funcname || hash || result7 || libp) ;
09883 }
09884
09885
09886 static int G__BankClassesDict_229_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
09887 {
09888 FRID *p;
09889 p=new FRID(*(FRID*)G__int(libp->para[0]));
09890 result7->obj.i = (long)p;
09891 result7->ref = (long)p;
09892 result7->type = 'u';
09893 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FRID);
09894 return(1 || funcname || hash || result7 || libp) ;
09895 }
09896
09897
09898 typedef FRID G__TFRID;
09899 static int G__BankClassesDict_229_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09900 if(0==G__getstructoffset()) return(1);
09901 if(G__getaryconstruct())
09902 if(G__PVOID==G__getgvp())
09903 delete[] (FRID *)(G__getstructoffset());
09904 else
09905 for(int i=G__getaryconstruct()-1;i>=0;i--)
09906 delete (FRID *)((G__getstructoffset())+sizeof(FRID)*i);
09907 else delete (FRID *)(G__getstructoffset());
09908 G__setnull(result7);
09909 return(1 || funcname || hash || result7 || libp) ;
09910 }
09911
09912
09913
09914 static int G__BankClassesDict_230_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09915 EFOL *p=NULL;
09916 if(G__getaryconstruct()) p=new EFOL[G__getaryconstruct()];
09917 else p=new EFOL;
09918 result7->obj.i = (long)p;
09919 result7->ref = (long)p;
09920 result7->type = 'u';
09921 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EFOL);
09922 return(1 || funcname || hash || result7 || libp) ;
09923 }
09924
09925 static int G__BankClassesDict_230_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09926 G__setnull(result7);
09927 ((EFOL*)(G__getstructoffset()))->Assign((EFOL_PATTERN*)G__int(libp->para[0]));
09928 return(1 || funcname || hash || result7 || libp) ;
09929 }
09930
09931 static int G__BankClassesDict_230_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09932 G__setnull(result7);
09933 ((EFOL*)(G__getstructoffset()))->Assign((DENF_PATTERN*)G__int(libp->para[0]));
09934 return(1 || funcname || hash || result7 || libp) ;
09935 }
09936
09937 static int G__BankClassesDict_230_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09938 G__setnull(result7);
09939 ((EFOL*)(G__getstructoffset()))->Assign((DENW_PATTERN*)G__int(libp->para[0]));
09940 return(1 || funcname || hash || result7 || libp) ;
09941 }
09942
09943 static int G__BankClassesDict_230_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09944 G__letint(result7,85,(long)EFOL::Class());
09945 return(1 || funcname || hash || result7 || libp) ;
09946 }
09947
09948 static int G__BankClassesDict_230_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09949 G__letint(result7,67,(long)EFOL::Class_Name());
09950 return(1 || funcname || hash || result7 || libp) ;
09951 }
09952
09953 static int G__BankClassesDict_230_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09954 G__letint(result7,115,(long)EFOL::Class_Version());
09955 return(1 || funcname || hash || result7 || libp) ;
09956 }
09957
09958 static int G__BankClassesDict_230_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09959 G__setnull(result7);
09960 EFOL::Dictionary();
09961 return(1 || funcname || hash || result7 || libp) ;
09962 }
09963
09964 static int G__BankClassesDict_230_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09965 G__letint(result7,85,(long)((const EFOL*)(G__getstructoffset()))->IsA());
09966 return(1 || funcname || hash || result7 || libp) ;
09967 }
09968
09969 static int G__BankClassesDict_230_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09970 G__setnull(result7);
09971 ((EFOL*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
09972 return(1 || funcname || hash || result7 || libp) ;
09973 }
09974
09975 static int G__BankClassesDict_230_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09976 G__setnull(result7);
09977 ((EFOL*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
09978 return(1 || funcname || hash || result7 || libp) ;
09979 }
09980
09981 static int G__BankClassesDict_230_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09982 G__setnull(result7);
09983 ((EFOL*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
09984 return(1 || funcname || hash || result7 || libp) ;
09985 }
09986
09987 static int G__BankClassesDict_230_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09988 G__letint(result7,67,(long)EFOL::DeclFileName());
09989 return(1 || funcname || hash || result7 || libp) ;
09990 }
09991
09992 static int G__BankClassesDict_230_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09993 G__letint(result7,105,(long)EFOL::ImplFileLine());
09994 return(1 || funcname || hash || result7 || libp) ;
09995 }
09996
09997 static int G__BankClassesDict_230_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
09998 G__letint(result7,67,(long)EFOL::ImplFileName());
09999 return(1 || funcname || hash || result7 || libp) ;
10000 }
10001
10002 static int G__BankClassesDict_230_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10003 G__letint(result7,105,(long)EFOL::DeclFileLine());
10004 return(1 || funcname || hash || result7 || libp) ;
10005 }
10006
10007
10008 static int G__BankClassesDict_230_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10009 {
10010 EFOL *p;
10011 p=new EFOL(*(EFOL*)G__int(libp->para[0]));
10012 result7->obj.i = (long)p;
10013 result7->ref = (long)p;
10014 result7->type = 'u';
10015 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EFOL);
10016 return(1 || funcname || hash || result7 || libp) ;
10017 }
10018
10019
10020 typedef EFOL G__TEFOL;
10021 static int G__BankClassesDict_230_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10022 if(0==G__getstructoffset()) return(1);
10023 if(G__getaryconstruct())
10024 if(G__PVOID==G__getgvp())
10025 delete[] (EFOL *)(G__getstructoffset());
10026 else
10027 for(int i=G__getaryconstruct()-1;i>=0;i--)
10028 delete (EFOL *)((G__getstructoffset())+sizeof(EFOL)*i);
10029 else delete (EFOL *)(G__getstructoffset());
10030 G__setnull(result7);
10031 return(1 || funcname || hash || result7 || libp) ;
10032 }
10033
10034
10035
10036 static int G__BankClassesDict_231_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10037 PCQA *p=NULL;
10038 if(G__getaryconstruct()) p=new PCQA[G__getaryconstruct()];
10039 else p=new PCQA;
10040 result7->obj.i = (long)p;
10041 result7->ref = (long)p;
10042 result7->type = 'u';
10043 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PCQA);
10044 return(1 || funcname || hash || result7 || libp) ;
10045 }
10046
10047 static int G__BankClassesDict_231_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10048 G__setnull(result7);
10049 ((PCQA*)(G__getstructoffset()))->Assign((PCQA_PATTERN*)G__int(libp->para[0]));
10050 return(1 || funcname || hash || result7 || libp) ;
10051 }
10052
10053 static int G__BankClassesDict_231_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10054 G__letint(result7,85,(long)PCQA::Class());
10055 return(1 || funcname || hash || result7 || libp) ;
10056 }
10057
10058 static int G__BankClassesDict_231_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10059 G__letint(result7,67,(long)PCQA::Class_Name());
10060 return(1 || funcname || hash || result7 || libp) ;
10061 }
10062
10063 static int G__BankClassesDict_231_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10064 G__letint(result7,115,(long)PCQA::Class_Version());
10065 return(1 || funcname || hash || result7 || libp) ;
10066 }
10067
10068 static int G__BankClassesDict_231_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10069 G__setnull(result7);
10070 PCQA::Dictionary();
10071 return(1 || funcname || hash || result7 || libp) ;
10072 }
10073
10074 static int G__BankClassesDict_231_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10075 G__letint(result7,85,(long)((const PCQA*)(G__getstructoffset()))->IsA());
10076 return(1 || funcname || hash || result7 || libp) ;
10077 }
10078
10079 static int G__BankClassesDict_231_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10080 G__setnull(result7);
10081 ((PCQA*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10082 return(1 || funcname || hash || result7 || libp) ;
10083 }
10084
10085 static int G__BankClassesDict_231_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10086 G__setnull(result7);
10087 ((PCQA*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10088 return(1 || funcname || hash || result7 || libp) ;
10089 }
10090
10091 static int G__BankClassesDict_231_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10092 G__setnull(result7);
10093 ((PCQA*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10094 return(1 || funcname || hash || result7 || libp) ;
10095 }
10096
10097 static int G__BankClassesDict_231_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10098 G__letint(result7,67,(long)PCQA::DeclFileName());
10099 return(1 || funcname || hash || result7 || libp) ;
10100 }
10101
10102 static int G__BankClassesDict_231_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10103 G__letint(result7,105,(long)PCQA::ImplFileLine());
10104 return(1 || funcname || hash || result7 || libp) ;
10105 }
10106
10107 static int G__BankClassesDict_231_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10108 G__letint(result7,67,(long)PCQA::ImplFileName());
10109 return(1 || funcname || hash || result7 || libp) ;
10110 }
10111
10112 static int G__BankClassesDict_231_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10113 G__letint(result7,105,(long)PCQA::DeclFileLine());
10114 return(1 || funcname || hash || result7 || libp) ;
10115 }
10116
10117
10118 static int G__BankClassesDict_231_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10119 {
10120 PCQA *p;
10121 p=new PCQA(*(PCQA*)G__int(libp->para[0]));
10122 result7->obj.i = (long)p;
10123 result7->ref = (long)p;
10124 result7->type = 'u';
10125 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PCQA);
10126 return(1 || funcname || hash || result7 || libp) ;
10127 }
10128
10129
10130 typedef PCQA G__TPCQA;
10131 static int G__BankClassesDict_231_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10132 if(0==G__getstructoffset()) return(1);
10133 if(G__getaryconstruct())
10134 if(G__PVOID==G__getgvp())
10135 delete[] (PCQA *)(G__getstructoffset());
10136 else
10137 for(int i=G__getaryconstruct()-1;i>=0;i--)
10138 delete (PCQA *)((G__getstructoffset())+sizeof(PCQA)*i);
10139 else delete (PCQA *)(G__getstructoffset());
10140 G__setnull(result7);
10141 return(1 || funcname || hash || result7 || libp) ;
10142 }
10143
10144
10145
10146 static int G__BankClassesDict_232_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10147 EGPC *p=NULL;
10148 if(G__getaryconstruct()) p=new EGPC[G__getaryconstruct()];
10149 else p=new EGPC;
10150 result7->obj.i = (long)p;
10151 result7->ref = (long)p;
10152 result7->type = 'u';
10153 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EGPC);
10154 return(1 || funcname || hash || result7 || libp) ;
10155 }
10156
10157 static int G__BankClassesDict_232_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10158 G__setnull(result7);
10159 ((EGPC*)(G__getstructoffset()))->Assign((EGPC_PATTERN*)G__int(libp->para[0]));
10160 return(1 || funcname || hash || result7 || libp) ;
10161 }
10162
10163 static int G__BankClassesDict_232_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10164 G__letint(result7,85,(long)EGPC::Class());
10165 return(1 || funcname || hash || result7 || libp) ;
10166 }
10167
10168 static int G__BankClassesDict_232_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10169 G__letint(result7,67,(long)EGPC::Class_Name());
10170 return(1 || funcname || hash || result7 || libp) ;
10171 }
10172
10173 static int G__BankClassesDict_232_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10174 G__letint(result7,115,(long)EGPC::Class_Version());
10175 return(1 || funcname || hash || result7 || libp) ;
10176 }
10177
10178 static int G__BankClassesDict_232_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10179 G__setnull(result7);
10180 EGPC::Dictionary();
10181 return(1 || funcname || hash || result7 || libp) ;
10182 }
10183
10184 static int G__BankClassesDict_232_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10185 G__letint(result7,85,(long)((const EGPC*)(G__getstructoffset()))->IsA());
10186 return(1 || funcname || hash || result7 || libp) ;
10187 }
10188
10189 static int G__BankClassesDict_232_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10190 G__setnull(result7);
10191 ((EGPC*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10192 return(1 || funcname || hash || result7 || libp) ;
10193 }
10194
10195 static int G__BankClassesDict_232_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10196 G__setnull(result7);
10197 ((EGPC*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10198 return(1 || funcname || hash || result7 || libp) ;
10199 }
10200
10201 static int G__BankClassesDict_232_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10202 G__setnull(result7);
10203 ((EGPC*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10204 return(1 || funcname || hash || result7 || libp) ;
10205 }
10206
10207 static int G__BankClassesDict_232_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10208 G__letint(result7,67,(long)EGPC::DeclFileName());
10209 return(1 || funcname || hash || result7 || libp) ;
10210 }
10211
10212 static int G__BankClassesDict_232_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10213 G__letint(result7,105,(long)EGPC::ImplFileLine());
10214 return(1 || funcname || hash || result7 || libp) ;
10215 }
10216
10217 static int G__BankClassesDict_232_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10218 G__letint(result7,67,(long)EGPC::ImplFileName());
10219 return(1 || funcname || hash || result7 || libp) ;
10220 }
10221
10222 static int G__BankClassesDict_232_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10223 G__letint(result7,105,(long)EGPC::DeclFileLine());
10224 return(1 || funcname || hash || result7 || libp) ;
10225 }
10226
10227
10228 static int G__BankClassesDict_232_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10229 {
10230 EGPC *p;
10231 p=new EGPC(*(EGPC*)G__int(libp->para[0]));
10232 result7->obj.i = (long)p;
10233 result7->ref = (long)p;
10234 result7->type = 'u';
10235 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EGPC);
10236 return(1 || funcname || hash || result7 || libp) ;
10237 }
10238
10239
10240 typedef EGPC G__TEGPC;
10241 static int G__BankClassesDict_232_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10242 if(0==G__getstructoffset()) return(1);
10243 if(G__getaryconstruct())
10244 if(G__PVOID==G__getgvp())
10245 delete[] (EGPC *)(G__getstructoffset());
10246 else
10247 for(int i=G__getaryconstruct()-1;i>=0;i--)
10248 delete (EGPC *)((G__getstructoffset())+sizeof(EGPC)*i);
10249 else delete (EGPC *)(G__getstructoffset());
10250 G__setnull(result7);
10251 return(1 || funcname || hash || result7 || libp) ;
10252 }
10253
10254
10255
10256 static int G__BankClassesDict_233_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10257 MUID *p=NULL;
10258 if(G__getaryconstruct()) p=new MUID[G__getaryconstruct()];
10259 else p=new MUID;
10260 result7->obj.i = (long)p;
10261 result7->ref = (long)p;
10262 result7->type = 'u';
10263 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_MUID);
10264 return(1 || funcname || hash || result7 || libp) ;
10265 }
10266
10267 static int G__BankClassesDict_233_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10268 G__setnull(result7);
10269 ((MUID*)(G__getstructoffset()))->Assign((MUID_PATTERN*)G__int(libp->para[0]));
10270 return(1 || funcname || hash || result7 || libp) ;
10271 }
10272
10273 static int G__BankClassesDict_233_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10274 G__letint(result7,85,(long)MUID::Class());
10275 return(1 || funcname || hash || result7 || libp) ;
10276 }
10277
10278 static int G__BankClassesDict_233_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10279 G__letint(result7,67,(long)MUID::Class_Name());
10280 return(1 || funcname || hash || result7 || libp) ;
10281 }
10282
10283 static int G__BankClassesDict_233_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10284 G__letint(result7,115,(long)MUID::Class_Version());
10285 return(1 || funcname || hash || result7 || libp) ;
10286 }
10287
10288 static int G__BankClassesDict_233_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10289 G__setnull(result7);
10290 MUID::Dictionary();
10291 return(1 || funcname || hash || result7 || libp) ;
10292 }
10293
10294 static int G__BankClassesDict_233_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10295 G__letint(result7,85,(long)((const MUID*)(G__getstructoffset()))->IsA());
10296 return(1 || funcname || hash || result7 || libp) ;
10297 }
10298
10299 static int G__BankClassesDict_233_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10300 G__setnull(result7);
10301 ((MUID*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10302 return(1 || funcname || hash || result7 || libp) ;
10303 }
10304
10305 static int G__BankClassesDict_233_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10306 G__setnull(result7);
10307 ((MUID*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10308 return(1 || funcname || hash || result7 || libp) ;
10309 }
10310
10311 static int G__BankClassesDict_233_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10312 G__setnull(result7);
10313 ((MUID*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10314 return(1 || funcname || hash || result7 || libp) ;
10315 }
10316
10317 static int G__BankClassesDict_233_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10318 G__letint(result7,67,(long)MUID::DeclFileName());
10319 return(1 || funcname || hash || result7 || libp) ;
10320 }
10321
10322 static int G__BankClassesDict_233_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10323 G__letint(result7,105,(long)MUID::ImplFileLine());
10324 return(1 || funcname || hash || result7 || libp) ;
10325 }
10326
10327 static int G__BankClassesDict_233_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10328 G__letint(result7,67,(long)MUID::ImplFileName());
10329 return(1 || funcname || hash || result7 || libp) ;
10330 }
10331
10332 static int G__BankClassesDict_233_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10333 G__letint(result7,105,(long)MUID::DeclFileLine());
10334 return(1 || funcname || hash || result7 || libp) ;
10335 }
10336
10337
10338 static int G__BankClassesDict_233_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10339 {
10340 MUID *p;
10341 p=new MUID(*(MUID*)G__int(libp->para[0]));
10342 result7->obj.i = (long)p;
10343 result7->ref = (long)p;
10344 result7->type = 'u';
10345 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_MUID);
10346 return(1 || funcname || hash || result7 || libp) ;
10347 }
10348
10349
10350 typedef MUID G__TMUID;
10351 static int G__BankClassesDict_233_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10352 if(0==G__getstructoffset()) return(1);
10353 if(G__getaryconstruct())
10354 if(G__PVOID==G__getgvp())
10355 delete[] (MUID *)(G__getstructoffset());
10356 else
10357 for(int i=G__getaryconstruct()-1;i>=0;i--)
10358 delete (MUID *)((G__getstructoffset())+sizeof(MUID)*i);
10359 else delete (MUID *)(G__getstructoffset());
10360 G__setnull(result7);
10361 return(1 || funcname || hash || result7 || libp) ;
10362 }
10363
10364
10365
10366 static int G__BankClassesDict_234_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10367 PGPC *p=NULL;
10368 if(G__getaryconstruct()) p=new PGPC[G__getaryconstruct()];
10369 else p=new PGPC;
10370 result7->obj.i = (long)p;
10371 result7->ref = (long)p;
10372 result7->type = 'u';
10373 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PGPC);
10374 return(1 || funcname || hash || result7 || libp) ;
10375 }
10376
10377 static int G__BankClassesDict_234_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10378 G__setnull(result7);
10379 ((PGPC*)(G__getstructoffset()))->Assign((PGPC_PATTERN*)G__int(libp->para[0]));
10380 return(1 || funcname || hash || result7 || libp) ;
10381 }
10382
10383 static int G__BankClassesDict_234_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10384 G__letint(result7,85,(long)PGPC::Class());
10385 return(1 || funcname || hash || result7 || libp) ;
10386 }
10387
10388 static int G__BankClassesDict_234_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10389 G__letint(result7,67,(long)PGPC::Class_Name());
10390 return(1 || funcname || hash || result7 || libp) ;
10391 }
10392
10393 static int G__BankClassesDict_234_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10394 G__letint(result7,115,(long)PGPC::Class_Version());
10395 return(1 || funcname || hash || result7 || libp) ;
10396 }
10397
10398 static int G__BankClassesDict_234_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10399 G__setnull(result7);
10400 PGPC::Dictionary();
10401 return(1 || funcname || hash || result7 || libp) ;
10402 }
10403
10404 static int G__BankClassesDict_234_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10405 G__letint(result7,85,(long)((const PGPC*)(G__getstructoffset()))->IsA());
10406 return(1 || funcname || hash || result7 || libp) ;
10407 }
10408
10409 static int G__BankClassesDict_234_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10410 G__setnull(result7);
10411 ((PGPC*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10412 return(1 || funcname || hash || result7 || libp) ;
10413 }
10414
10415 static int G__BankClassesDict_234_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10416 G__setnull(result7);
10417 ((PGPC*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10418 return(1 || funcname || hash || result7 || libp) ;
10419 }
10420
10421 static int G__BankClassesDict_234_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10422 G__setnull(result7);
10423 ((PGPC*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10424 return(1 || funcname || hash || result7 || libp) ;
10425 }
10426
10427 static int G__BankClassesDict_234_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10428 G__letint(result7,67,(long)PGPC::DeclFileName());
10429 return(1 || funcname || hash || result7 || libp) ;
10430 }
10431
10432 static int G__BankClassesDict_234_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10433 G__letint(result7,105,(long)PGPC::ImplFileLine());
10434 return(1 || funcname || hash || result7 || libp) ;
10435 }
10436
10437 static int G__BankClassesDict_234_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10438 G__letint(result7,67,(long)PGPC::ImplFileName());
10439 return(1 || funcname || hash || result7 || libp) ;
10440 }
10441
10442 static int G__BankClassesDict_234_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10443 G__letint(result7,105,(long)PGPC::DeclFileLine());
10444 return(1 || funcname || hash || result7 || libp) ;
10445 }
10446
10447
10448 static int G__BankClassesDict_234_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10449 {
10450 PGPC *p;
10451 p=new PGPC(*(PGPC*)G__int(libp->para[0]));
10452 result7->obj.i = (long)p;
10453 result7->ref = (long)p;
10454 result7->type = 'u';
10455 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PGPC);
10456 return(1 || funcname || hash || result7 || libp) ;
10457 }
10458
10459
10460 typedef PGPC G__TPGPC;
10461 static int G__BankClassesDict_234_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10462 if(0==G__getstructoffset()) return(1);
10463 if(G__getaryconstruct())
10464 if(G__PVOID==G__getgvp())
10465 delete[] (PGPC *)(G__getstructoffset());
10466 else
10467 for(int i=G__getaryconstruct()-1;i>=0;i--)
10468 delete (PGPC *)((G__getstructoffset())+sizeof(PGPC)*i);
10469 else delete (PGPC *)(G__getstructoffset());
10470 G__setnull(result7);
10471 return(1 || funcname || hash || result7 || libp) ;
10472 }
10473
10474
10475
10476 static int G__BankClassesDict_235_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10477 PGAC *p=NULL;
10478 if(G__getaryconstruct()) p=new PGAC[G__getaryconstruct()];
10479 else p=new PGAC;
10480 result7->obj.i = (long)p;
10481 result7->ref = (long)p;
10482 result7->type = 'u';
10483 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PGAC);
10484 return(1 || funcname || hash || result7 || libp) ;
10485 }
10486
10487 static int G__BankClassesDict_235_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10488 G__setnull(result7);
10489 ((PGAC*)(G__getstructoffset()))->Assign((PGAC_PATTERN*)G__int(libp->para[0]));
10490 return(1 || funcname || hash || result7 || libp) ;
10491 }
10492
10493 static int G__BankClassesDict_235_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10494 G__letint(result7,85,(long)PGAC::Class());
10495 return(1 || funcname || hash || result7 || libp) ;
10496 }
10497
10498 static int G__BankClassesDict_235_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10499 G__letint(result7,67,(long)PGAC::Class_Name());
10500 return(1 || funcname || hash || result7 || libp) ;
10501 }
10502
10503 static int G__BankClassesDict_235_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10504 G__letint(result7,115,(long)PGAC::Class_Version());
10505 return(1 || funcname || hash || result7 || libp) ;
10506 }
10507
10508 static int G__BankClassesDict_235_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10509 G__setnull(result7);
10510 PGAC::Dictionary();
10511 return(1 || funcname || hash || result7 || libp) ;
10512 }
10513
10514 static int G__BankClassesDict_235_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10515 G__letint(result7,85,(long)((const PGAC*)(G__getstructoffset()))->IsA());
10516 return(1 || funcname || hash || result7 || libp) ;
10517 }
10518
10519 static int G__BankClassesDict_235_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10520 G__setnull(result7);
10521 ((PGAC*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10522 return(1 || funcname || hash || result7 || libp) ;
10523 }
10524
10525 static int G__BankClassesDict_235_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10526 G__setnull(result7);
10527 ((PGAC*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10528 return(1 || funcname || hash || result7 || libp) ;
10529 }
10530
10531 static int G__BankClassesDict_235_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10532 G__setnull(result7);
10533 ((PGAC*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10534 return(1 || funcname || hash || result7 || libp) ;
10535 }
10536
10537 static int G__BankClassesDict_235_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10538 G__letint(result7,67,(long)PGAC::DeclFileName());
10539 return(1 || funcname || hash || result7 || libp) ;
10540 }
10541
10542 static int G__BankClassesDict_235_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10543 G__letint(result7,105,(long)PGAC::ImplFileLine());
10544 return(1 || funcname || hash || result7 || libp) ;
10545 }
10546
10547 static int G__BankClassesDict_235_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10548 G__letint(result7,67,(long)PGAC::ImplFileName());
10549 return(1 || funcname || hash || result7 || libp) ;
10550 }
10551
10552 static int G__BankClassesDict_235_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10553 G__letint(result7,105,(long)PGAC::DeclFileLine());
10554 return(1 || funcname || hash || result7 || libp) ;
10555 }
10556
10557
10558 static int G__BankClassesDict_235_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10559 {
10560 PGAC *p;
10561 p=new PGAC(*(PGAC*)G__int(libp->para[0]));
10562 result7->obj.i = (long)p;
10563 result7->ref = (long)p;
10564 result7->type = 'u';
10565 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PGAC);
10566 return(1 || funcname || hash || result7 || libp) ;
10567 }
10568
10569
10570 typedef PGAC G__TPGAC;
10571 static int G__BankClassesDict_235_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10572 if(0==G__getstructoffset()) return(1);
10573 if(G__getaryconstruct())
10574 if(G__PVOID==G__getgvp())
10575 delete[] (PGAC *)(G__getstructoffset());
10576 else
10577 for(int i=G__getaryconstruct()-1;i>=0;i--)
10578 delete (PGAC *)((G__getstructoffset())+sizeof(PGAC)*i);
10579 else delete (PGAC *)(G__getstructoffset());
10580 G__setnull(result7);
10581 return(1 || funcname || hash || result7 || libp) ;
10582 }
10583
10584
10585
10586 static int G__BankClassesDict_236_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10587 PDLT *p=NULL;
10588 if(G__getaryconstruct()) p=new PDLT[G__getaryconstruct()];
10589 else p=new PDLT;
10590 result7->obj.i = (long)p;
10591 result7->ref = (long)p;
10592 result7->type = 'u';
10593 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PDLT);
10594 return(1 || funcname || hash || result7 || libp) ;
10595 }
10596
10597 static int G__BankClassesDict_236_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10598 G__setnull(result7);
10599 ((PDLT*)(G__getstructoffset()))->Assign((PDLT_PATTERN*)G__int(libp->para[0]));
10600 return(1 || funcname || hash || result7 || libp) ;
10601 }
10602
10603 static int G__BankClassesDict_236_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10604 G__letint(result7,85,(long)PDLT::Class());
10605 return(1 || funcname || hash || result7 || libp) ;
10606 }
10607
10608 static int G__BankClassesDict_236_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10609 G__letint(result7,67,(long)PDLT::Class_Name());
10610 return(1 || funcname || hash || result7 || libp) ;
10611 }
10612
10613 static int G__BankClassesDict_236_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10614 G__letint(result7,115,(long)PDLT::Class_Version());
10615 return(1 || funcname || hash || result7 || libp) ;
10616 }
10617
10618 static int G__BankClassesDict_236_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10619 G__setnull(result7);
10620 PDLT::Dictionary();
10621 return(1 || funcname || hash || result7 || libp) ;
10622 }
10623
10624 static int G__BankClassesDict_236_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10625 G__letint(result7,85,(long)((const PDLT*)(G__getstructoffset()))->IsA());
10626 return(1 || funcname || hash || result7 || libp) ;
10627 }
10628
10629 static int G__BankClassesDict_236_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10630 G__setnull(result7);
10631 ((PDLT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10632 return(1 || funcname || hash || result7 || libp) ;
10633 }
10634
10635 static int G__BankClassesDict_236_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10636 G__setnull(result7);
10637 ((PDLT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10638 return(1 || funcname || hash || result7 || libp) ;
10639 }
10640
10641 static int G__BankClassesDict_236_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10642 G__setnull(result7);
10643 ((PDLT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10644 return(1 || funcname || hash || result7 || libp) ;
10645 }
10646
10647 static int G__BankClassesDict_236_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10648 G__letint(result7,67,(long)PDLT::DeclFileName());
10649 return(1 || funcname || hash || result7 || libp) ;
10650 }
10651
10652 static int G__BankClassesDict_236_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10653 G__letint(result7,105,(long)PDLT::ImplFileLine());
10654 return(1 || funcname || hash || result7 || libp) ;
10655 }
10656
10657 static int G__BankClassesDict_236_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10658 G__letint(result7,67,(long)PDLT::ImplFileName());
10659 return(1 || funcname || hash || result7 || libp) ;
10660 }
10661
10662 static int G__BankClassesDict_236_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10663 G__letint(result7,105,(long)PDLT::DeclFileLine());
10664 return(1 || funcname || hash || result7 || libp) ;
10665 }
10666
10667
10668 static int G__BankClassesDict_236_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10669 {
10670 PDLT *p;
10671 p=new PDLT(*(PDLT*)G__int(libp->para[0]));
10672 result7->obj.i = (long)p;
10673 result7->ref = (long)p;
10674 result7->type = 'u';
10675 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PDLT);
10676 return(1 || funcname || hash || result7 || libp) ;
10677 }
10678
10679
10680 typedef PDLT G__TPDLT;
10681 static int G__BankClassesDict_236_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10682 if(0==G__getstructoffset()) return(1);
10683 if(G__getaryconstruct())
10684 if(G__PVOID==G__getgvp())
10685 delete[] (PDLT *)(G__getstructoffset());
10686 else
10687 for(int i=G__getaryconstruct()-1;i>=0;i--)
10688 delete (PDLT *)((G__getstructoffset())+sizeof(PDLT)*i);
10689 else delete (PDLT *)(G__getstructoffset());
10690 G__setnull(result7);
10691 return(1 || funcname || hash || result7 || libp) ;
10692 }
10693
10694
10695
10696 static int G__BankClassesDict_237_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10697 PMLT *p=NULL;
10698 if(G__getaryconstruct()) p=new PMLT[G__getaryconstruct()];
10699 else p=new PMLT;
10700 result7->obj.i = (long)p;
10701 result7->ref = (long)p;
10702 result7->type = 'u';
10703 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PMLT);
10704 return(1 || funcname || hash || result7 || libp) ;
10705 }
10706
10707 static int G__BankClassesDict_237_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10708 G__setnull(result7);
10709 ((PMLT*)(G__getstructoffset()))->Assign((PMLT_PATTERN*)G__int(libp->para[0]));
10710 return(1 || funcname || hash || result7 || libp) ;
10711 }
10712
10713 static int G__BankClassesDict_237_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10714 G__letint(result7,85,(long)PMLT::Class());
10715 return(1 || funcname || hash || result7 || libp) ;
10716 }
10717
10718 static int G__BankClassesDict_237_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10719 G__letint(result7,67,(long)PMLT::Class_Name());
10720 return(1 || funcname || hash || result7 || libp) ;
10721 }
10722
10723 static int G__BankClassesDict_237_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10724 G__letint(result7,115,(long)PMLT::Class_Version());
10725 return(1 || funcname || hash || result7 || libp) ;
10726 }
10727
10728 static int G__BankClassesDict_237_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10729 G__setnull(result7);
10730 PMLT::Dictionary();
10731 return(1 || funcname || hash || result7 || libp) ;
10732 }
10733
10734 static int G__BankClassesDict_237_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10735 G__letint(result7,85,(long)((const PMLT*)(G__getstructoffset()))->IsA());
10736 return(1 || funcname || hash || result7 || libp) ;
10737 }
10738
10739 static int G__BankClassesDict_237_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10740 G__setnull(result7);
10741 ((PMLT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10742 return(1 || funcname || hash || result7 || libp) ;
10743 }
10744
10745 static int G__BankClassesDict_237_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10746 G__setnull(result7);
10747 ((PMLT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10748 return(1 || funcname || hash || result7 || libp) ;
10749 }
10750
10751 static int G__BankClassesDict_237_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10752 G__setnull(result7);
10753 ((PMLT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10754 return(1 || funcname || hash || result7 || libp) ;
10755 }
10756
10757 static int G__BankClassesDict_237_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10758 G__letint(result7,67,(long)PMLT::DeclFileName());
10759 return(1 || funcname || hash || result7 || libp) ;
10760 }
10761
10762 static int G__BankClassesDict_237_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10763 G__letint(result7,105,(long)PMLT::ImplFileLine());
10764 return(1 || funcname || hash || result7 || libp) ;
10765 }
10766
10767 static int G__BankClassesDict_237_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10768 G__letint(result7,67,(long)PMLT::ImplFileName());
10769 return(1 || funcname || hash || result7 || libp) ;
10770 }
10771
10772 static int G__BankClassesDict_237_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10773 G__letint(result7,105,(long)PMLT::DeclFileLine());
10774 return(1 || funcname || hash || result7 || libp) ;
10775 }
10776
10777
10778 static int G__BankClassesDict_237_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10779 {
10780 PMLT *p;
10781 p=new PMLT(*(PMLT*)G__int(libp->para[0]));
10782 result7->obj.i = (long)p;
10783 result7->ref = (long)p;
10784 result7->type = 'u';
10785 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_PMLT);
10786 return(1 || funcname || hash || result7 || libp) ;
10787 }
10788
10789
10790 typedef PMLT G__TPMLT;
10791 static int G__BankClassesDict_237_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10792 if(0==G__getstructoffset()) return(1);
10793 if(G__getaryconstruct())
10794 if(G__PVOID==G__getgvp())
10795 delete[] (PMLT *)(G__getstructoffset());
10796 else
10797 for(int i=G__getaryconstruct()-1;i>=0;i--)
10798 delete (PMLT *)((G__getstructoffset())+sizeof(PMLT)*i);
10799 else delete (PMLT *)(G__getstructoffset());
10800 G__setnull(result7);
10801 return(1 || funcname || hash || result7 || libp) ;
10802 }
10803
10804
10805
10806 static int G__BankClassesDict_238_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10807 QDET *p=NULL;
10808 if(G__getaryconstruct()) p=new QDET[G__getaryconstruct()];
10809 else p=new QDET;
10810 result7->obj.i = (long)p;
10811 result7->ref = (long)p;
10812 result7->type = 'u';
10813 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QDET);
10814 return(1 || funcname || hash || result7 || libp) ;
10815 }
10816
10817 static int G__BankClassesDict_238_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10818 G__setnull(result7);
10819 ((QDET*)(G__getstructoffset()))->Assign((QDET_PATTERN*)G__int(libp->para[0]));
10820 return(1 || funcname || hash || result7 || libp) ;
10821 }
10822
10823 static int G__BankClassesDict_238_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10824 G__letint(result7,85,(long)QDET::Class());
10825 return(1 || funcname || hash || result7 || libp) ;
10826 }
10827
10828 static int G__BankClassesDict_238_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10829 G__letint(result7,67,(long)QDET::Class_Name());
10830 return(1 || funcname || hash || result7 || libp) ;
10831 }
10832
10833 static int G__BankClassesDict_238_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10834 G__letint(result7,115,(long)QDET::Class_Version());
10835 return(1 || funcname || hash || result7 || libp) ;
10836 }
10837
10838 static int G__BankClassesDict_238_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10839 G__setnull(result7);
10840 QDET::Dictionary();
10841 return(1 || funcname || hash || result7 || libp) ;
10842 }
10843
10844 static int G__BankClassesDict_238_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10845 G__letint(result7,85,(long)((const QDET*)(G__getstructoffset()))->IsA());
10846 return(1 || funcname || hash || result7 || libp) ;
10847 }
10848
10849 static int G__BankClassesDict_238_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10850 G__setnull(result7);
10851 ((QDET*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10852 return(1 || funcname || hash || result7 || libp) ;
10853 }
10854
10855 static int G__BankClassesDict_238_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10856 G__setnull(result7);
10857 ((QDET*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10858 return(1 || funcname || hash || result7 || libp) ;
10859 }
10860
10861 static int G__BankClassesDict_238_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10862 G__setnull(result7);
10863 ((QDET*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10864 return(1 || funcname || hash || result7 || libp) ;
10865 }
10866
10867 static int G__BankClassesDict_238_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10868 G__letint(result7,67,(long)QDET::DeclFileName());
10869 return(1 || funcname || hash || result7 || libp) ;
10870 }
10871
10872 static int G__BankClassesDict_238_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10873 G__letint(result7,105,(long)QDET::ImplFileLine());
10874 return(1 || funcname || hash || result7 || libp) ;
10875 }
10876
10877 static int G__BankClassesDict_238_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10878 G__letint(result7,67,(long)QDET::ImplFileName());
10879 return(1 || funcname || hash || result7 || libp) ;
10880 }
10881
10882 static int G__BankClassesDict_238_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10883 G__letint(result7,105,(long)QDET::DeclFileLine());
10884 return(1 || funcname || hash || result7 || libp) ;
10885 }
10886
10887
10888 static int G__BankClassesDict_238_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10889 {
10890 QDET *p;
10891 p=new QDET(*(QDET*)G__int(libp->para[0]));
10892 result7->obj.i = (long)p;
10893 result7->ref = (long)p;
10894 result7->type = 'u';
10895 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QDET);
10896 return(1 || funcname || hash || result7 || libp) ;
10897 }
10898
10899
10900 typedef QDET G__TQDET;
10901 static int G__BankClassesDict_238_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10902 if(0==G__getstructoffset()) return(1);
10903 if(G__getaryconstruct())
10904 if(G__PVOID==G__getgvp())
10905 delete[] (QDET *)(G__getstructoffset());
10906 else
10907 for(int i=G__getaryconstruct()-1;i>=0;i--)
10908 delete (QDET *)((G__getstructoffset())+sizeof(QDET)*i);
10909 else delete (QDET *)(G__getstructoffset());
10910 G__setnull(result7);
10911 return(1 || funcname || hash || result7 || libp) ;
10912 }
10913
10914
10915
10916 static int G__BankClassesDict_239_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10917 QVEC *p=NULL;
10918 if(G__getaryconstruct()) p=new QVEC[G__getaryconstruct()];
10919 else p=new QVEC;
10920 result7->obj.i = (long)p;
10921 result7->ref = (long)p;
10922 result7->type = 'u';
10923 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QVEC);
10924 return(1 || funcname || hash || result7 || libp) ;
10925 }
10926
10927 static int G__BankClassesDict_239_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10928 G__setnull(result7);
10929 ((QVEC*)(G__getstructoffset()))->Assign((QVEC_PATTERN*)G__int(libp->para[0]));
10930 return(1 || funcname || hash || result7 || libp) ;
10931 }
10932
10933 static int G__BankClassesDict_239_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10934 G__letint(result7,85,(long)QVEC::Class());
10935 return(1 || funcname || hash || result7 || libp) ;
10936 }
10937
10938 static int G__BankClassesDict_239_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10939 G__letint(result7,67,(long)QVEC::Class_Name());
10940 return(1 || funcname || hash || result7 || libp) ;
10941 }
10942
10943 static int G__BankClassesDict_239_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10944 G__letint(result7,115,(long)QVEC::Class_Version());
10945 return(1 || funcname || hash || result7 || libp) ;
10946 }
10947
10948 static int G__BankClassesDict_239_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10949 G__setnull(result7);
10950 QVEC::Dictionary();
10951 return(1 || funcname || hash || result7 || libp) ;
10952 }
10953
10954 static int G__BankClassesDict_239_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10955 G__letint(result7,85,(long)((const QVEC*)(G__getstructoffset()))->IsA());
10956 return(1 || funcname || hash || result7 || libp) ;
10957 }
10958
10959 static int G__BankClassesDict_239_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10960 G__setnull(result7);
10961 ((QVEC*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
10962 return(1 || funcname || hash || result7 || libp) ;
10963 }
10964
10965 static int G__BankClassesDict_239_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10966 G__setnull(result7);
10967 ((QVEC*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
10968 return(1 || funcname || hash || result7 || libp) ;
10969 }
10970
10971 static int G__BankClassesDict_239_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10972 G__setnull(result7);
10973 ((QVEC*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
10974 return(1 || funcname || hash || result7 || libp) ;
10975 }
10976
10977 static int G__BankClassesDict_239_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10978 G__letint(result7,67,(long)QVEC::DeclFileName());
10979 return(1 || funcname || hash || result7 || libp) ;
10980 }
10981
10982 static int G__BankClassesDict_239_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10983 G__letint(result7,105,(long)QVEC::ImplFileLine());
10984 return(1 || funcname || hash || result7 || libp) ;
10985 }
10986
10987 static int G__BankClassesDict_239_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10988 G__letint(result7,67,(long)QVEC::ImplFileName());
10989 return(1 || funcname || hash || result7 || libp) ;
10990 }
10991
10992 static int G__BankClassesDict_239_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
10993 G__letint(result7,105,(long)QVEC::DeclFileLine());
10994 return(1 || funcname || hash || result7 || libp) ;
10995 }
10996
10997
10998 static int G__BankClassesDict_239_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
10999 {
11000 QVEC *p;
11001 p=new QVEC(*(QVEC*)G__int(libp->para[0]));
11002 result7->obj.i = (long)p;
11003 result7->ref = (long)p;
11004 result7->type = 'u';
11005 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QVEC);
11006 return(1 || funcname || hash || result7 || libp) ;
11007 }
11008
11009
11010 typedef QVEC G__TQVEC;
11011 static int G__BankClassesDict_239_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11012 if(0==G__getstructoffset()) return(1);
11013 if(G__getaryconstruct())
11014 if(G__PVOID==G__getgvp())
11015 delete[] (QVEC *)(G__getstructoffset());
11016 else
11017 for(int i=G__getaryconstruct()-1;i>=0;i--)
11018 delete (QVEC *)((G__getstructoffset())+sizeof(QVEC)*i);
11019 else delete (QVEC *)(G__getstructoffset());
11020 G__setnull(result7);
11021 return(1 || funcname || hash || result7 || libp) ;
11022 }
11023
11024
11025
11026 static int G__BankClassesDict_244_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11027 YV0V *p=NULL;
11028 if(G__getaryconstruct()) p=new YV0V[G__getaryconstruct()];
11029 else p=new YV0V;
11030 result7->obj.i = (long)p;
11031 result7->ref = (long)p;
11032 result7->type = 'u';
11033 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_YV0V);
11034 return(1 || funcname || hash || result7 || libp) ;
11035 }
11036
11037 static int G__BankClassesDict_244_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11038 G__setnull(result7);
11039 ((YV0V*)(G__getstructoffset()))->Assign((YV0V_PATTERN*)G__int(libp->para[0]));
11040 return(1 || funcname || hash || result7 || libp) ;
11041 }
11042
11043 static int G__BankClassesDict_244_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11044 G__letint(result7,85,(long)YV0V::Class());
11045 return(1 || funcname || hash || result7 || libp) ;
11046 }
11047
11048 static int G__BankClassesDict_244_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11049 G__letint(result7,67,(long)YV0V::Class_Name());
11050 return(1 || funcname || hash || result7 || libp) ;
11051 }
11052
11053 static int G__BankClassesDict_244_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11054 G__letint(result7,115,(long)YV0V::Class_Version());
11055 return(1 || funcname || hash || result7 || libp) ;
11056 }
11057
11058 static int G__BankClassesDict_244_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11059 G__setnull(result7);
11060 YV0V::Dictionary();
11061 return(1 || funcname || hash || result7 || libp) ;
11062 }
11063
11064 static int G__BankClassesDict_244_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11065 G__letint(result7,85,(long)((const YV0V*)(G__getstructoffset()))->IsA());
11066 return(1 || funcname || hash || result7 || libp) ;
11067 }
11068
11069 static int G__BankClassesDict_244_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11070 G__setnull(result7);
11071 ((YV0V*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11072 return(1 || funcname || hash || result7 || libp) ;
11073 }
11074
11075 static int G__BankClassesDict_244_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11076 G__setnull(result7);
11077 ((YV0V*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11078 return(1 || funcname || hash || result7 || libp) ;
11079 }
11080
11081 static int G__BankClassesDict_244_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11082 G__setnull(result7);
11083 ((YV0V*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11084 return(1 || funcname || hash || result7 || libp) ;
11085 }
11086
11087 static int G__BankClassesDict_244_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11088 G__letint(result7,67,(long)YV0V::DeclFileName());
11089 return(1 || funcname || hash || result7 || libp) ;
11090 }
11091
11092 static int G__BankClassesDict_244_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11093 G__letint(result7,105,(long)YV0V::ImplFileLine());
11094 return(1 || funcname || hash || result7 || libp) ;
11095 }
11096
11097 static int G__BankClassesDict_244_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11098 G__letint(result7,67,(long)YV0V::ImplFileName());
11099 return(1 || funcname || hash || result7 || libp) ;
11100 }
11101
11102 static int G__BankClassesDict_244_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11103 G__letint(result7,105,(long)YV0V::DeclFileLine());
11104 return(1 || funcname || hash || result7 || libp) ;
11105 }
11106
11107
11108 static int G__BankClassesDict_244_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11109 {
11110 YV0V *p;
11111 p=new YV0V(*(YV0V*)G__int(libp->para[0]));
11112 result7->obj.i = (long)p;
11113 result7->ref = (long)p;
11114 result7->type = 'u';
11115 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_YV0V);
11116 return(1 || funcname || hash || result7 || libp) ;
11117 }
11118
11119
11120 typedef YV0V G__TYV0V;
11121 static int G__BankClassesDict_244_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11122 if(0==G__getstructoffset()) return(1);
11123 if(G__getaryconstruct())
11124 if(G__PVOID==G__getgvp())
11125 delete[] (YV0V *)(G__getstructoffset());
11126 else
11127 for(int i=G__getaryconstruct()-1;i>=0;i--)
11128 delete (YV0V *)((G__getstructoffset())+sizeof(YV0V)*i);
11129 else delete (YV0V *)(G__getstructoffset());
11130 G__setnull(result7);
11131 return(1 || funcname || hash || result7 || libp) ;
11132 }
11133
11134
11135
11136 static int G__BankClassesDict_245_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11137 FKIN *p=NULL;
11138 if(G__getaryconstruct()) p=new FKIN[G__getaryconstruct()];
11139 else p=new FKIN;
11140 result7->obj.i = (long)p;
11141 result7->ref = (long)p;
11142 result7->type = 'u';
11143 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FKIN);
11144 return(1 || funcname || hash || result7 || libp) ;
11145 }
11146
11147 static int G__BankClassesDict_245_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11148 G__setnull(result7);
11149 ((FKIN*)(G__getstructoffset()))->Assign((FKIN_PATTERN*)G__int(libp->para[0]));
11150 return(1 || funcname || hash || result7 || libp) ;
11151 }
11152
11153 static int G__BankClassesDict_245_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11154 G__letint(result7,85,(long)FKIN::Class());
11155 return(1 || funcname || hash || result7 || libp) ;
11156 }
11157
11158 static int G__BankClassesDict_245_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11159 G__letint(result7,67,(long)FKIN::Class_Name());
11160 return(1 || funcname || hash || result7 || libp) ;
11161 }
11162
11163 static int G__BankClassesDict_245_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11164 G__letint(result7,115,(long)FKIN::Class_Version());
11165 return(1 || funcname || hash || result7 || libp) ;
11166 }
11167
11168 static int G__BankClassesDict_245_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11169 G__setnull(result7);
11170 FKIN::Dictionary();
11171 return(1 || funcname || hash || result7 || libp) ;
11172 }
11173
11174 static int G__BankClassesDict_245_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11175 G__letint(result7,85,(long)((const FKIN*)(G__getstructoffset()))->IsA());
11176 return(1 || funcname || hash || result7 || libp) ;
11177 }
11178
11179 static int G__BankClassesDict_245_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11180 G__setnull(result7);
11181 ((FKIN*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11182 return(1 || funcname || hash || result7 || libp) ;
11183 }
11184
11185 static int G__BankClassesDict_245_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11186 G__setnull(result7);
11187 ((FKIN*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11188 return(1 || funcname || hash || result7 || libp) ;
11189 }
11190
11191 static int G__BankClassesDict_245_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11192 G__setnull(result7);
11193 ((FKIN*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11194 return(1 || funcname || hash || result7 || libp) ;
11195 }
11196
11197 static int G__BankClassesDict_245_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11198 G__letint(result7,67,(long)FKIN::DeclFileName());
11199 return(1 || funcname || hash || result7 || libp) ;
11200 }
11201
11202 static int G__BankClassesDict_245_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11203 G__letint(result7,105,(long)FKIN::ImplFileLine());
11204 return(1 || funcname || hash || result7 || libp) ;
11205 }
11206
11207 static int G__BankClassesDict_245_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11208 G__letint(result7,67,(long)FKIN::ImplFileName());
11209 return(1 || funcname || hash || result7 || libp) ;
11210 }
11211
11212 static int G__BankClassesDict_245_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11213 G__letint(result7,105,(long)FKIN::DeclFileLine());
11214 return(1 || funcname || hash || result7 || libp) ;
11215 }
11216
11217
11218 static int G__BankClassesDict_245_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11219 {
11220 FKIN *p;
11221 p=new FKIN(*(FKIN*)G__int(libp->para[0]));
11222 result7->obj.i = (long)p;
11223 result7->ref = (long)p;
11224 result7->type = 'u';
11225 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FKIN);
11226 return(1 || funcname || hash || result7 || libp) ;
11227 }
11228
11229
11230 typedef FKIN G__TFKIN;
11231 static int G__BankClassesDict_245_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11232 if(0==G__getstructoffset()) return(1);
11233 if(G__getaryconstruct())
11234 if(G__PVOID==G__getgvp())
11235 delete[] (FKIN *)(G__getstructoffset());
11236 else
11237 for(int i=G__getaryconstruct()-1;i>=0;i--)
11238 delete (FKIN *)((G__getstructoffset())+sizeof(FKIN)*i);
11239 else delete (FKIN *)(G__getstructoffset());
11240 G__setnull(result7);
11241 return(1 || funcname || hash || result7 || libp) ;
11242 }
11243
11244
11245
11246 static int G__BankClassesDict_246_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11247 FVER *p=NULL;
11248 if(G__getaryconstruct()) p=new FVER[G__getaryconstruct()];
11249 else p=new FVER;
11250 result7->obj.i = (long)p;
11251 result7->ref = (long)p;
11252 result7->type = 'u';
11253 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FVER);
11254 return(1 || funcname || hash || result7 || libp) ;
11255 }
11256
11257 static int G__BankClassesDict_246_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11258 G__setnull(result7);
11259 ((FVER*)(G__getstructoffset()))->Assign((FVER_PATTERN*)G__int(libp->para[0]));
11260 return(1 || funcname || hash || result7 || libp) ;
11261 }
11262
11263 static int G__BankClassesDict_246_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11264 G__letint(result7,85,(long)FVER::Class());
11265 return(1 || funcname || hash || result7 || libp) ;
11266 }
11267
11268 static int G__BankClassesDict_246_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11269 G__letint(result7,67,(long)FVER::Class_Name());
11270 return(1 || funcname || hash || result7 || libp) ;
11271 }
11272
11273 static int G__BankClassesDict_246_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11274 G__letint(result7,115,(long)FVER::Class_Version());
11275 return(1 || funcname || hash || result7 || libp) ;
11276 }
11277
11278 static int G__BankClassesDict_246_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11279 G__setnull(result7);
11280 FVER::Dictionary();
11281 return(1 || funcname || hash || result7 || libp) ;
11282 }
11283
11284 static int G__BankClassesDict_246_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11285 G__letint(result7,85,(long)((const FVER*)(G__getstructoffset()))->IsA());
11286 return(1 || funcname || hash || result7 || libp) ;
11287 }
11288
11289 static int G__BankClassesDict_246_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11290 G__setnull(result7);
11291 ((FVER*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11292 return(1 || funcname || hash || result7 || libp) ;
11293 }
11294
11295 static int G__BankClassesDict_246_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11296 G__setnull(result7);
11297 ((FVER*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11298 return(1 || funcname || hash || result7 || libp) ;
11299 }
11300
11301 static int G__BankClassesDict_246_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11302 G__setnull(result7);
11303 ((FVER*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11304 return(1 || funcname || hash || result7 || libp) ;
11305 }
11306
11307 static int G__BankClassesDict_246_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11308 G__letint(result7,67,(long)FVER::DeclFileName());
11309 return(1 || funcname || hash || result7 || libp) ;
11310 }
11311
11312 static int G__BankClassesDict_246_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11313 G__letint(result7,105,(long)FVER::ImplFileLine());
11314 return(1 || funcname || hash || result7 || libp) ;
11315 }
11316
11317 static int G__BankClassesDict_246_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11318 G__letint(result7,67,(long)FVER::ImplFileName());
11319 return(1 || funcname || hash || result7 || libp) ;
11320 }
11321
11322 static int G__BankClassesDict_246_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11323 G__letint(result7,105,(long)FVER::DeclFileLine());
11324 return(1 || funcname || hash || result7 || libp) ;
11325 }
11326
11327
11328 static int G__BankClassesDict_246_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11329 {
11330 FVER *p;
11331 p=new FVER(*(FVER*)G__int(libp->para[0]));
11332 result7->obj.i = (long)p;
11333 result7->ref = (long)p;
11334 result7->type = 'u';
11335 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_FVER);
11336 return(1 || funcname || hash || result7 || libp) ;
11337 }
11338
11339
11340 typedef FVER G__TFVER;
11341 static int G__BankClassesDict_246_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11342 if(0==G__getstructoffset()) return(1);
11343 if(G__getaryconstruct())
11344 if(G__PVOID==G__getgvp())
11345 delete[] (FVER *)(G__getstructoffset());
11346 else
11347 for(int i=G__getaryconstruct()-1;i>=0;i--)
11348 delete (FVER *)((G__getstructoffset())+sizeof(FVER)*i);
11349 else delete (FVER *)(G__getstructoffset());
11350 G__setnull(result7);
11351 return(1 || funcname || hash || result7 || libp) ;
11352 }
11353
11354
11355
11356 static int G__BankClassesDict_251_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11357 QVRT *p=NULL;
11358 if(G__getaryconstruct()) p=new QVRT[G__getaryconstruct()];
11359 else p=new QVRT;
11360 result7->obj.i = (long)p;
11361 result7->ref = (long)p;
11362 result7->type = 'u';
11363 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QVRT);
11364 return(1 || funcname || hash || result7 || libp) ;
11365 }
11366
11367 static int G__BankClassesDict_251_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11368 G__setnull(result7);
11369 ((QVRT*)(G__getstructoffset()))->Assign((QVRT_PATTERN*)G__int(libp->para[0]));
11370 return(1 || funcname || hash || result7 || libp) ;
11371 }
11372
11373 static int G__BankClassesDict_251_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11374 G__letint(result7,85,(long)QVRT::Class());
11375 return(1 || funcname || hash || result7 || libp) ;
11376 }
11377
11378 static int G__BankClassesDict_251_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11379 G__letint(result7,67,(long)QVRT::Class_Name());
11380 return(1 || funcname || hash || result7 || libp) ;
11381 }
11382
11383 static int G__BankClassesDict_251_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11384 G__letint(result7,115,(long)QVRT::Class_Version());
11385 return(1 || funcname || hash || result7 || libp) ;
11386 }
11387
11388 static int G__BankClassesDict_251_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11389 G__setnull(result7);
11390 QVRT::Dictionary();
11391 return(1 || funcname || hash || result7 || libp) ;
11392 }
11393
11394 static int G__BankClassesDict_251_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11395 G__letint(result7,85,(long)((const QVRT*)(G__getstructoffset()))->IsA());
11396 return(1 || funcname || hash || result7 || libp) ;
11397 }
11398
11399 static int G__BankClassesDict_251_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11400 G__setnull(result7);
11401 ((QVRT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11402 return(1 || funcname || hash || result7 || libp) ;
11403 }
11404
11405 static int G__BankClassesDict_251_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11406 G__setnull(result7);
11407 ((QVRT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11408 return(1 || funcname || hash || result7 || libp) ;
11409 }
11410
11411 static int G__BankClassesDict_251_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11412 G__setnull(result7);
11413 ((QVRT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11414 return(1 || funcname || hash || result7 || libp) ;
11415 }
11416
11417 static int G__BankClassesDict_251_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11418 G__letint(result7,67,(long)QVRT::DeclFileName());
11419 return(1 || funcname || hash || result7 || libp) ;
11420 }
11421
11422 static int G__BankClassesDict_251_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11423 G__letint(result7,105,(long)QVRT::ImplFileLine());
11424 return(1 || funcname || hash || result7 || libp) ;
11425 }
11426
11427 static int G__BankClassesDict_251_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11428 G__letint(result7,67,(long)QVRT::ImplFileName());
11429 return(1 || funcname || hash || result7 || libp) ;
11430 }
11431
11432 static int G__BankClassesDict_251_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11433 G__letint(result7,105,(long)QVRT::DeclFileLine());
11434 return(1 || funcname || hash || result7 || libp) ;
11435 }
11436
11437
11438 static int G__BankClassesDict_251_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11439 {
11440 QVRT *p;
11441 p=new QVRT(*(QVRT*)G__int(libp->para[0]));
11442 result7->obj.i = (long)p;
11443 result7->ref = (long)p;
11444 result7->type = 'u';
11445 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QVRT);
11446 return(1 || funcname || hash || result7 || libp) ;
11447 }
11448
11449
11450 typedef QVRT G__TQVRT;
11451 static int G__BankClassesDict_251_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11452 if(0==G__getstructoffset()) return(1);
11453 if(G__getaryconstruct())
11454 if(G__PVOID==G__getgvp())
11455 delete[] (QVRT *)(G__getstructoffset());
11456 else
11457 for(int i=G__getaryconstruct()-1;i>=0;i--)
11458 delete (QVRT *)((G__getstructoffset())+sizeof(QVRT)*i);
11459 else delete (QVRT *)(G__getstructoffset());
11460 G__setnull(result7);
11461 return(1 || funcname || hash || result7 || libp) ;
11462 }
11463
11464
11465
11466 static int G__BankClassesDict_252_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11467 ALPB *p=NULL;
11468 if(G__getaryconstruct()) p=new ALPB[G__getaryconstruct()];
11469 else p=new ALPB;
11470 result7->obj.i = (long)p;
11471 result7->ref = (long)p;
11472 result7->type = 'u';
11473 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ALPB);
11474 return(1 || funcname || hash || result7 || libp) ;
11475 }
11476
11477 static int G__BankClassesDict_252_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11478 G__setnull(result7);
11479 ((ALPB*)(G__getstructoffset()))->Assign((ALPB_PATTERN*)G__int(libp->para[0]));
11480 return(1 || funcname || hash || result7 || libp) ;
11481 }
11482
11483 static int G__BankClassesDict_252_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11484 G__letint(result7,85,(long)ALPB::Class());
11485 return(1 || funcname || hash || result7 || libp) ;
11486 }
11487
11488 static int G__BankClassesDict_252_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11489 G__letint(result7,67,(long)ALPB::Class_Name());
11490 return(1 || funcname || hash || result7 || libp) ;
11491 }
11492
11493 static int G__BankClassesDict_252_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11494 G__letint(result7,115,(long)ALPB::Class_Version());
11495 return(1 || funcname || hash || result7 || libp) ;
11496 }
11497
11498 static int G__BankClassesDict_252_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11499 G__setnull(result7);
11500 ALPB::Dictionary();
11501 return(1 || funcname || hash || result7 || libp) ;
11502 }
11503
11504 static int G__BankClassesDict_252_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11505 G__letint(result7,85,(long)((const ALPB*)(G__getstructoffset()))->IsA());
11506 return(1 || funcname || hash || result7 || libp) ;
11507 }
11508
11509 static int G__BankClassesDict_252_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11510 G__setnull(result7);
11511 ((ALPB*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11512 return(1 || funcname || hash || result7 || libp) ;
11513 }
11514
11515 static int G__BankClassesDict_252_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11516 G__setnull(result7);
11517 ((ALPB*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11518 return(1 || funcname || hash || result7 || libp) ;
11519 }
11520
11521 static int G__BankClassesDict_252_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11522 G__setnull(result7);
11523 ((ALPB*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11524 return(1 || funcname || hash || result7 || libp) ;
11525 }
11526
11527 static int G__BankClassesDict_252_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11528 G__letint(result7,67,(long)ALPB::DeclFileName());
11529 return(1 || funcname || hash || result7 || libp) ;
11530 }
11531
11532 static int G__BankClassesDict_252_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11533 G__letint(result7,105,(long)ALPB::ImplFileLine());
11534 return(1 || funcname || hash || result7 || libp) ;
11535 }
11536
11537 static int G__BankClassesDict_252_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11538 G__letint(result7,67,(long)ALPB::ImplFileName());
11539 return(1 || funcname || hash || result7 || libp) ;
11540 }
11541
11542 static int G__BankClassesDict_252_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11543 G__letint(result7,105,(long)ALPB::DeclFileLine());
11544 return(1 || funcname || hash || result7 || libp) ;
11545 }
11546
11547
11548 static int G__BankClassesDict_252_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11549 {
11550 ALPB *p;
11551 p=new ALPB(*(ALPB*)G__int(libp->para[0]));
11552 result7->obj.i = (long)p;
11553 result7->ref = (long)p;
11554 result7->type = 'u';
11555 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ALPB);
11556 return(1 || funcname || hash || result7 || libp) ;
11557 }
11558
11559
11560 typedef ALPB G__TALPB;
11561 static int G__BankClassesDict_252_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11562 if(0==G__getstructoffset()) return(1);
11563 if(G__getaryconstruct())
11564 if(G__PVOID==G__getgvp())
11565 delete[] (ALPB *)(G__getstructoffset());
11566 else
11567 for(int i=G__getaryconstruct()-1;i>=0;i--)
11568 delete (ALPB *)((G__getstructoffset())+sizeof(ALPB)*i);
11569 else delete (ALPB *)(G__getstructoffset());
11570 G__setnull(result7);
11571 return(1 || funcname || hash || result7 || libp) ;
11572 }
11573
11574
11575
11576 static int G__BankClassesDict_253_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11577 ALRP *p=NULL;
11578 if(G__getaryconstruct()) p=new ALRP[G__getaryconstruct()];
11579 else p=new ALRP;
11580 result7->obj.i = (long)p;
11581 result7->ref = (long)p;
11582 result7->type = 'u';
11583 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ALRP);
11584 return(1 || funcname || hash || result7 || libp) ;
11585 }
11586
11587 static int G__BankClassesDict_253_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11588 G__setnull(result7);
11589 ((ALRP*)(G__getstructoffset()))->Assign((ALRP_PATTERN*)G__int(libp->para[0]));
11590 return(1 || funcname || hash || result7 || libp) ;
11591 }
11592
11593 static int G__BankClassesDict_253_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11594 G__letint(result7,85,(long)ALRP::Class());
11595 return(1 || funcname || hash || result7 || libp) ;
11596 }
11597
11598 static int G__BankClassesDict_253_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11599 G__letint(result7,67,(long)ALRP::Class_Name());
11600 return(1 || funcname || hash || result7 || libp) ;
11601 }
11602
11603 static int G__BankClassesDict_253_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11604 G__letint(result7,115,(long)ALRP::Class_Version());
11605 return(1 || funcname || hash || result7 || libp) ;
11606 }
11607
11608 static int G__BankClassesDict_253_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11609 G__setnull(result7);
11610 ALRP::Dictionary();
11611 return(1 || funcname || hash || result7 || libp) ;
11612 }
11613
11614 static int G__BankClassesDict_253_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11615 G__letint(result7,85,(long)((const ALRP*)(G__getstructoffset()))->IsA());
11616 return(1 || funcname || hash || result7 || libp) ;
11617 }
11618
11619 static int G__BankClassesDict_253_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11620 G__setnull(result7);
11621 ((ALRP*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11622 return(1 || funcname || hash || result7 || libp) ;
11623 }
11624
11625 static int G__BankClassesDict_253_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11626 G__setnull(result7);
11627 ((ALRP*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11628 return(1 || funcname || hash || result7 || libp) ;
11629 }
11630
11631 static int G__BankClassesDict_253_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11632 G__setnull(result7);
11633 ((ALRP*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11634 return(1 || funcname || hash || result7 || libp) ;
11635 }
11636
11637 static int G__BankClassesDict_253_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11638 G__letint(result7,67,(long)ALRP::DeclFileName());
11639 return(1 || funcname || hash || result7 || libp) ;
11640 }
11641
11642 static int G__BankClassesDict_253_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11643 G__letint(result7,105,(long)ALRP::ImplFileLine());
11644 return(1 || funcname || hash || result7 || libp) ;
11645 }
11646
11647 static int G__BankClassesDict_253_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11648 G__letint(result7,67,(long)ALRP::ImplFileName());
11649 return(1 || funcname || hash || result7 || libp) ;
11650 }
11651
11652 static int G__BankClassesDict_253_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11653 G__letint(result7,105,(long)ALRP::DeclFileLine());
11654 return(1 || funcname || hash || result7 || libp) ;
11655 }
11656
11657
11658 static int G__BankClassesDict_253_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11659 {
11660 ALRP *p;
11661 p=new ALRP(*(ALRP*)G__int(libp->para[0]));
11662 result7->obj.i = (long)p;
11663 result7->ref = (long)p;
11664 result7->type = 'u';
11665 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ALRP);
11666 return(1 || funcname || hash || result7 || libp) ;
11667 }
11668
11669
11670 typedef ALRP G__TALRP;
11671 static int G__BankClassesDict_253_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11672 if(0==G__getstructoffset()) return(1);
11673 if(G__getaryconstruct())
11674 if(G__PVOID==G__getgvp())
11675 delete[] (ALRP *)(G__getstructoffset());
11676 else
11677 for(int i=G__getaryconstruct()-1;i>=0;i--)
11678 delete (ALRP *)((G__getstructoffset())+sizeof(ALRP)*i);
11679 else delete (ALRP *)(G__getstructoffset());
11680 G__setnull(result7);
11681 return(1 || funcname || hash || result7 || libp) ;
11682 }
11683
11684
11685
11686 static int G__BankClassesDict_254_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11687 RNL2 *p=NULL;
11688 if(G__getaryconstruct()) p=new RNL2[G__getaryconstruct()];
11689 else p=new RNL2;
11690 result7->obj.i = (long)p;
11691 result7->ref = (long)p;
11692 result7->type = 'u';
11693 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RNL2);
11694 return(1 || funcname || hash || result7 || libp) ;
11695 }
11696
11697 static int G__BankClassesDict_254_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11698 G__setnull(result7);
11699 ((RNL2*)(G__getstructoffset()))->Assign((RNL2_PATTERN*)G__int(libp->para[0]));
11700 return(1 || funcname || hash || result7 || libp) ;
11701 }
11702
11703 static int G__BankClassesDict_254_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11704 G__letint(result7,85,(long)RNL2::Class());
11705 return(1 || funcname || hash || result7 || libp) ;
11706 }
11707
11708 static int G__BankClassesDict_254_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11709 G__letint(result7,67,(long)RNL2::Class_Name());
11710 return(1 || funcname || hash || result7 || libp) ;
11711 }
11712
11713 static int G__BankClassesDict_254_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11714 G__letint(result7,115,(long)RNL2::Class_Version());
11715 return(1 || funcname || hash || result7 || libp) ;
11716 }
11717
11718 static int G__BankClassesDict_254_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11719 G__setnull(result7);
11720 RNL2::Dictionary();
11721 return(1 || funcname || hash || result7 || libp) ;
11722 }
11723
11724 static int G__BankClassesDict_254_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11725 G__letint(result7,85,(long)((const RNL2*)(G__getstructoffset()))->IsA());
11726 return(1 || funcname || hash || result7 || libp) ;
11727 }
11728
11729 static int G__BankClassesDict_254_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11730 G__setnull(result7);
11731 ((RNL2*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11732 return(1 || funcname || hash || result7 || libp) ;
11733 }
11734
11735 static int G__BankClassesDict_254_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11736 G__setnull(result7);
11737 ((RNL2*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11738 return(1 || funcname || hash || result7 || libp) ;
11739 }
11740
11741 static int G__BankClassesDict_254_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11742 G__setnull(result7);
11743 ((RNL2*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11744 return(1 || funcname || hash || result7 || libp) ;
11745 }
11746
11747 static int G__BankClassesDict_254_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11748 G__letint(result7,67,(long)RNL2::DeclFileName());
11749 return(1 || funcname || hash || result7 || libp) ;
11750 }
11751
11752 static int G__BankClassesDict_254_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11753 G__letint(result7,105,(long)RNL2::ImplFileLine());
11754 return(1 || funcname || hash || result7 || libp) ;
11755 }
11756
11757 static int G__BankClassesDict_254_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11758 G__letint(result7,67,(long)RNL2::ImplFileName());
11759 return(1 || funcname || hash || result7 || libp) ;
11760 }
11761
11762 static int G__BankClassesDict_254_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11763 G__letint(result7,105,(long)RNL2::DeclFileLine());
11764 return(1 || funcname || hash || result7 || libp) ;
11765 }
11766
11767
11768 static int G__BankClassesDict_254_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11769 {
11770 RNL2 *p;
11771 p=new RNL2(*(RNL2*)G__int(libp->para[0]));
11772 result7->obj.i = (long)p;
11773 result7->ref = (long)p;
11774 result7->type = 'u';
11775 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RNL2);
11776 return(1 || funcname || hash || result7 || libp) ;
11777 }
11778
11779
11780 typedef RNL2 G__TRNL2;
11781 static int G__BankClassesDict_254_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11782 if(0==G__getstructoffset()) return(1);
11783 if(G__getaryconstruct())
11784 if(G__PVOID==G__getgvp())
11785 delete[] (RNL2 *)(G__getstructoffset());
11786 else
11787 for(int i=G__getaryconstruct()-1;i>=0;i--)
11788 delete (RNL2 *)((G__getstructoffset())+sizeof(RNL2)*i);
11789 else delete (RNL2 *)(G__getstructoffset());
11790 G__setnull(result7);
11791 return(1 || funcname || hash || result7 || libp) ;
11792 }
11793
11794
11795
11796 static int G__BankClassesDict_255_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11797 RNF2 *p=NULL;
11798 if(G__getaryconstruct()) p=new RNF2[G__getaryconstruct()];
11799 else p=new RNF2;
11800 result7->obj.i = (long)p;
11801 result7->ref = (long)p;
11802 result7->type = 'u';
11803 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RNF2);
11804 return(1 || funcname || hash || result7 || libp) ;
11805 }
11806
11807 static int G__BankClassesDict_255_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11808 G__setnull(result7);
11809 ((RNF2*)(G__getstructoffset()))->Assign((RNF2_PATTERN*)G__int(libp->para[0]));
11810 return(1 || funcname || hash || result7 || libp) ;
11811 }
11812
11813 static int G__BankClassesDict_255_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11814 G__letint(result7,85,(long)RNF2::Class());
11815 return(1 || funcname || hash || result7 || libp) ;
11816 }
11817
11818 static int G__BankClassesDict_255_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11819 G__letint(result7,67,(long)RNF2::Class_Name());
11820 return(1 || funcname || hash || result7 || libp) ;
11821 }
11822
11823 static int G__BankClassesDict_255_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11824 G__letint(result7,115,(long)RNF2::Class_Version());
11825 return(1 || funcname || hash || result7 || libp) ;
11826 }
11827
11828 static int G__BankClassesDict_255_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11829 G__setnull(result7);
11830 RNF2::Dictionary();
11831 return(1 || funcname || hash || result7 || libp) ;
11832 }
11833
11834 static int G__BankClassesDict_255_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11835 G__letint(result7,85,(long)((const RNF2*)(G__getstructoffset()))->IsA());
11836 return(1 || funcname || hash || result7 || libp) ;
11837 }
11838
11839 static int G__BankClassesDict_255_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11840 G__setnull(result7);
11841 ((RNF2*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11842 return(1 || funcname || hash || result7 || libp) ;
11843 }
11844
11845 static int G__BankClassesDict_255_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11846 G__setnull(result7);
11847 ((RNF2*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11848 return(1 || funcname || hash || result7 || libp) ;
11849 }
11850
11851 static int G__BankClassesDict_255_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11852 G__setnull(result7);
11853 ((RNF2*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11854 return(1 || funcname || hash || result7 || libp) ;
11855 }
11856
11857 static int G__BankClassesDict_255_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11858 G__letint(result7,67,(long)RNF2::DeclFileName());
11859 return(1 || funcname || hash || result7 || libp) ;
11860 }
11861
11862 static int G__BankClassesDict_255_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11863 G__letint(result7,105,(long)RNF2::ImplFileLine());
11864 return(1 || funcname || hash || result7 || libp) ;
11865 }
11866
11867 static int G__BankClassesDict_255_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11868 G__letint(result7,67,(long)RNF2::ImplFileName());
11869 return(1 || funcname || hash || result7 || libp) ;
11870 }
11871
11872 static int G__BankClassesDict_255_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11873 G__letint(result7,105,(long)RNF2::DeclFileLine());
11874 return(1 || funcname || hash || result7 || libp) ;
11875 }
11876
11877
11878 static int G__BankClassesDict_255_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11879 {
11880 RNF2 *p;
11881 p=new RNF2(*(RNF2*)G__int(libp->para[0]));
11882 result7->obj.i = (long)p;
11883 result7->ref = (long)p;
11884 result7->type = 'u';
11885 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RNF2);
11886 return(1 || funcname || hash || result7 || libp) ;
11887 }
11888
11889
11890 typedef RNF2 G__TRNF2;
11891 static int G__BankClassesDict_255_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11892 if(0==G__getstructoffset()) return(1);
11893 if(G__getaryconstruct())
11894 if(G__PVOID==G__getgvp())
11895 delete[] (RNF2 *)(G__getstructoffset());
11896 else
11897 for(int i=G__getaryconstruct()-1;i>=0;i--)
11898 delete (RNF2 *)((G__getstructoffset())+sizeof(RNF2)*i);
11899 else delete (RNF2 *)(G__getstructoffset());
11900 G__setnull(result7);
11901 return(1 || funcname || hash || result7 || libp) ;
11902 }
11903
11904
11905
11906 static int G__BankClassesDict_256_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11907 RNR2 *p=NULL;
11908 if(G__getaryconstruct()) p=new RNR2[G__getaryconstruct()];
11909 else p=new RNR2;
11910 result7->obj.i = (long)p;
11911 result7->ref = (long)p;
11912 result7->type = 'u';
11913 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RNR2);
11914 return(1 || funcname || hash || result7 || libp) ;
11915 }
11916
11917 static int G__BankClassesDict_256_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11918 G__setnull(result7);
11919 ((RNR2*)(G__getstructoffset()))->Assign((RNR2_PATTERN*)G__int(libp->para[0]));
11920 return(1 || funcname || hash || result7 || libp) ;
11921 }
11922
11923 static int G__BankClassesDict_256_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11924 G__letint(result7,85,(long)RNR2::Class());
11925 return(1 || funcname || hash || result7 || libp) ;
11926 }
11927
11928 static int G__BankClassesDict_256_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11929 G__letint(result7,67,(long)RNR2::Class_Name());
11930 return(1 || funcname || hash || result7 || libp) ;
11931 }
11932
11933 static int G__BankClassesDict_256_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11934 G__letint(result7,115,(long)RNR2::Class_Version());
11935 return(1 || funcname || hash || result7 || libp) ;
11936 }
11937
11938 static int G__BankClassesDict_256_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11939 G__setnull(result7);
11940 RNR2::Dictionary();
11941 return(1 || funcname || hash || result7 || libp) ;
11942 }
11943
11944 static int G__BankClassesDict_256_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11945 G__letint(result7,85,(long)((const RNR2*)(G__getstructoffset()))->IsA());
11946 return(1 || funcname || hash || result7 || libp) ;
11947 }
11948
11949 static int G__BankClassesDict_256_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11950 G__setnull(result7);
11951 ((RNR2*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
11952 return(1 || funcname || hash || result7 || libp) ;
11953 }
11954
11955 static int G__BankClassesDict_256_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11956 G__setnull(result7);
11957 ((RNR2*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
11958 return(1 || funcname || hash || result7 || libp) ;
11959 }
11960
11961 static int G__BankClassesDict_256_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11962 G__setnull(result7);
11963 ((RNR2*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
11964 return(1 || funcname || hash || result7 || libp) ;
11965 }
11966
11967 static int G__BankClassesDict_256_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11968 G__letint(result7,67,(long)RNR2::DeclFileName());
11969 return(1 || funcname || hash || result7 || libp) ;
11970 }
11971
11972 static int G__BankClassesDict_256_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11973 G__letint(result7,105,(long)RNR2::ImplFileLine());
11974 return(1 || funcname || hash || result7 || libp) ;
11975 }
11976
11977 static int G__BankClassesDict_256_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11978 G__letint(result7,67,(long)RNR2::ImplFileName());
11979 return(1 || funcname || hash || result7 || libp) ;
11980 }
11981
11982 static int G__BankClassesDict_256_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
11983 G__letint(result7,105,(long)RNR2::DeclFileLine());
11984 return(1 || funcname || hash || result7 || libp) ;
11985 }
11986
11987
11988 static int G__BankClassesDict_256_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
11989 {
11990 RNR2 *p;
11991 p=new RNR2(*(RNR2*)G__int(libp->para[0]));
11992 result7->obj.i = (long)p;
11993 result7->ref = (long)p;
11994 result7->type = 'u';
11995 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RNR2);
11996 return(1 || funcname || hash || result7 || libp) ;
11997 }
11998
11999
12000 typedef RNR2 G__TRNR2;
12001 static int G__BankClassesDict_256_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12002 if(0==G__getstructoffset()) return(1);
12003 if(G__getaryconstruct())
12004 if(G__PVOID==G__getgvp())
12005 delete[] (RNR2 *)(G__getstructoffset());
12006 else
12007 for(int i=G__getaryconstruct()-1;i>=0;i--)
12008 delete (RNR2 *)((G__getstructoffset())+sizeof(RNR2)*i);
12009 else delete (RNR2 *)(G__getstructoffset());
12010 G__setnull(result7);
12011 return(1 || funcname || hash || result7 || libp) ;
12012 }
12013
12014
12015
12016 static int G__BankClassesDict_257_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12017 RLEP *p=NULL;
12018 if(G__getaryconstruct()) p=new RLEP[G__getaryconstruct()];
12019 else p=new RLEP;
12020 result7->obj.i = (long)p;
12021 result7->ref = (long)p;
12022 result7->type = 'u';
12023 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RLEP);
12024 return(1 || funcname || hash || result7 || libp) ;
12025 }
12026
12027 static int G__BankClassesDict_257_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12028 G__setnull(result7);
12029 ((RLEP*)(G__getstructoffset()))->Assign((RLEP_PATTERN*)G__int(libp->para[0]));
12030 return(1 || funcname || hash || result7 || libp) ;
12031 }
12032
12033 static int G__BankClassesDict_257_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12034 G__letint(result7,85,(long)RLEP::Class());
12035 return(1 || funcname || hash || result7 || libp) ;
12036 }
12037
12038 static int G__BankClassesDict_257_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12039 G__letint(result7,67,(long)RLEP::Class_Name());
12040 return(1 || funcname || hash || result7 || libp) ;
12041 }
12042
12043 static int G__BankClassesDict_257_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12044 G__letint(result7,115,(long)RLEP::Class_Version());
12045 return(1 || funcname || hash || result7 || libp) ;
12046 }
12047
12048 static int G__BankClassesDict_257_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12049 G__setnull(result7);
12050 RLEP::Dictionary();
12051 return(1 || funcname || hash || result7 || libp) ;
12052 }
12053
12054 static int G__BankClassesDict_257_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12055 G__letint(result7,85,(long)((const RLEP*)(G__getstructoffset()))->IsA());
12056 return(1 || funcname || hash || result7 || libp) ;
12057 }
12058
12059 static int G__BankClassesDict_257_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12060 G__setnull(result7);
12061 ((RLEP*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12062 return(1 || funcname || hash || result7 || libp) ;
12063 }
12064
12065 static int G__BankClassesDict_257_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12066 G__setnull(result7);
12067 ((RLEP*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12068 return(1 || funcname || hash || result7 || libp) ;
12069 }
12070
12071 static int G__BankClassesDict_257_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12072 G__setnull(result7);
12073 ((RLEP*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12074 return(1 || funcname || hash || result7 || libp) ;
12075 }
12076
12077 static int G__BankClassesDict_257_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12078 G__letint(result7,67,(long)RLEP::DeclFileName());
12079 return(1 || funcname || hash || result7 || libp) ;
12080 }
12081
12082 static int G__BankClassesDict_257_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12083 G__letint(result7,105,(long)RLEP::ImplFileLine());
12084 return(1 || funcname || hash || result7 || libp) ;
12085 }
12086
12087 static int G__BankClassesDict_257_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12088 G__letint(result7,67,(long)RLEP::ImplFileName());
12089 return(1 || funcname || hash || result7 || libp) ;
12090 }
12091
12092 static int G__BankClassesDict_257_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12093 G__letint(result7,105,(long)RLEP::DeclFileLine());
12094 return(1 || funcname || hash || result7 || libp) ;
12095 }
12096
12097
12098 static int G__BankClassesDict_257_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12099 {
12100 RLEP *p;
12101 p=new RLEP(*(RLEP*)G__int(libp->para[0]));
12102 result7->obj.i = (long)p;
12103 result7->ref = (long)p;
12104 result7->type = 'u';
12105 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RLEP);
12106 return(1 || funcname || hash || result7 || libp) ;
12107 }
12108
12109
12110 typedef RLEP G__TRLEP;
12111 static int G__BankClassesDict_257_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12112 if(0==G__getstructoffset()) return(1);
12113 if(G__getaryconstruct())
12114 if(G__PVOID==G__getgvp())
12115 delete[] (RLEP *)(G__getstructoffset());
12116 else
12117 for(int i=G__getaryconstruct()-1;i>=0;i--)
12118 delete (RLEP *)((G__getstructoffset())+sizeof(RLEP)*i);
12119 else delete (RLEP *)(G__getstructoffset());
12120 G__setnull(result7);
12121 return(1 || funcname || hash || result7 || libp) ;
12122 }
12123
12124
12125
12126 static int G__BankClassesDict_258_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12127 LFIL *p=NULL;
12128 if(G__getaryconstruct()) p=new LFIL[G__getaryconstruct()];
12129 else p=new LFIL;
12130 result7->obj.i = (long)p;
12131 result7->ref = (long)p;
12132 result7->type = 'u';
12133 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_LFIL);
12134 return(1 || funcname || hash || result7 || libp) ;
12135 }
12136
12137 static int G__BankClassesDict_258_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12138 G__setnull(result7);
12139 ((LFIL*)(G__getstructoffset()))->Assign((LFIL_PATTERN*)G__int(libp->para[0]));
12140 return(1 || funcname || hash || result7 || libp) ;
12141 }
12142
12143 static int G__BankClassesDict_258_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12144 G__letint(result7,85,(long)LFIL::Class());
12145 return(1 || funcname || hash || result7 || libp) ;
12146 }
12147
12148 static int G__BankClassesDict_258_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12149 G__letint(result7,67,(long)LFIL::Class_Name());
12150 return(1 || funcname || hash || result7 || libp) ;
12151 }
12152
12153 static int G__BankClassesDict_258_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12154 G__letint(result7,115,(long)LFIL::Class_Version());
12155 return(1 || funcname || hash || result7 || libp) ;
12156 }
12157
12158 static int G__BankClassesDict_258_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12159 G__setnull(result7);
12160 LFIL::Dictionary();
12161 return(1 || funcname || hash || result7 || libp) ;
12162 }
12163
12164 static int G__BankClassesDict_258_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12165 G__letint(result7,85,(long)((const LFIL*)(G__getstructoffset()))->IsA());
12166 return(1 || funcname || hash || result7 || libp) ;
12167 }
12168
12169 static int G__BankClassesDict_258_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12170 G__setnull(result7);
12171 ((LFIL*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12172 return(1 || funcname || hash || result7 || libp) ;
12173 }
12174
12175 static int G__BankClassesDict_258_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12176 G__setnull(result7);
12177 ((LFIL*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12178 return(1 || funcname || hash || result7 || libp) ;
12179 }
12180
12181 static int G__BankClassesDict_258_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12182 G__setnull(result7);
12183 ((LFIL*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12184 return(1 || funcname || hash || result7 || libp) ;
12185 }
12186
12187 static int G__BankClassesDict_258_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12188 G__letint(result7,67,(long)LFIL::DeclFileName());
12189 return(1 || funcname || hash || result7 || libp) ;
12190 }
12191
12192 static int G__BankClassesDict_258_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12193 G__letint(result7,105,(long)LFIL::ImplFileLine());
12194 return(1 || funcname || hash || result7 || libp) ;
12195 }
12196
12197 static int G__BankClassesDict_258_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12198 G__letint(result7,67,(long)LFIL::ImplFileName());
12199 return(1 || funcname || hash || result7 || libp) ;
12200 }
12201
12202 static int G__BankClassesDict_258_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12203 G__letint(result7,105,(long)LFIL::DeclFileLine());
12204 return(1 || funcname || hash || result7 || libp) ;
12205 }
12206
12207
12208 static int G__BankClassesDict_258_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12209 {
12210 LFIL *p;
12211 p=new LFIL(*(LFIL*)G__int(libp->para[0]));
12212 result7->obj.i = (long)p;
12213 result7->ref = (long)p;
12214 result7->type = 'u';
12215 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_LFIL);
12216 return(1 || funcname || hash || result7 || libp) ;
12217 }
12218
12219
12220 typedef LFIL G__TLFIL;
12221 static int G__BankClassesDict_258_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12222 if(0==G__getstructoffset()) return(1);
12223 if(G__getaryconstruct())
12224 if(G__PVOID==G__getgvp())
12225 delete[] (LFIL *)(G__getstructoffset());
12226 else
12227 for(int i=G__getaryconstruct()-1;i>=0;i--)
12228 delete (LFIL *)((G__getstructoffset())+sizeof(LFIL)*i);
12229 else delete (LFIL *)(G__getstructoffset());
12230 G__setnull(result7);
12231 return(1 || funcname || hash || result7 || libp) ;
12232 }
12233
12234
12235
12236 static int G__BankClassesDict_259_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12237 EVEH *p=NULL;
12238 if(G__getaryconstruct()) p=new EVEH[G__getaryconstruct()];
12239 else p=new EVEH;
12240 result7->obj.i = (long)p;
12241 result7->ref = (long)p;
12242 result7->type = 'u';
12243 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EVEH);
12244 return(1 || funcname || hash || result7 || libp) ;
12245 }
12246
12247 static int G__BankClassesDict_259_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12248 G__setnull(result7);
12249 ((EVEH*)(G__getstructoffset()))->Assign((EVEH_PATTERN*)G__int(libp->para[0]));
12250 return(1 || funcname || hash || result7 || libp) ;
12251 }
12252
12253 static int G__BankClassesDict_259_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12254 G__letint(result7,85,(long)EVEH::Class());
12255 return(1 || funcname || hash || result7 || libp) ;
12256 }
12257
12258 static int G__BankClassesDict_259_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12259 G__letint(result7,67,(long)EVEH::Class_Name());
12260 return(1 || funcname || hash || result7 || libp) ;
12261 }
12262
12263 static int G__BankClassesDict_259_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12264 G__letint(result7,115,(long)EVEH::Class_Version());
12265 return(1 || funcname || hash || result7 || libp) ;
12266 }
12267
12268 static int G__BankClassesDict_259_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12269 G__setnull(result7);
12270 EVEH::Dictionary();
12271 return(1 || funcname || hash || result7 || libp) ;
12272 }
12273
12274 static int G__BankClassesDict_259_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12275 G__letint(result7,85,(long)((const EVEH*)(G__getstructoffset()))->IsA());
12276 return(1 || funcname || hash || result7 || libp) ;
12277 }
12278
12279 static int G__BankClassesDict_259_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12280 G__setnull(result7);
12281 ((EVEH*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12282 return(1 || funcname || hash || result7 || libp) ;
12283 }
12284
12285 static int G__BankClassesDict_259_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12286 G__setnull(result7);
12287 ((EVEH*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12288 return(1 || funcname || hash || result7 || libp) ;
12289 }
12290
12291 static int G__BankClassesDict_259_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12292 G__setnull(result7);
12293 ((EVEH*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12294 return(1 || funcname || hash || result7 || libp) ;
12295 }
12296
12297 static int G__BankClassesDict_259_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12298 G__letint(result7,67,(long)EVEH::DeclFileName());
12299 return(1 || funcname || hash || result7 || libp) ;
12300 }
12301
12302 static int G__BankClassesDict_259_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12303 G__letint(result7,105,(long)EVEH::ImplFileLine());
12304 return(1 || funcname || hash || result7 || libp) ;
12305 }
12306
12307 static int G__BankClassesDict_259_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12308 G__letint(result7,67,(long)EVEH::ImplFileName());
12309 return(1 || funcname || hash || result7 || libp) ;
12310 }
12311
12312 static int G__BankClassesDict_259_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12313 G__letint(result7,105,(long)EVEH::DeclFileLine());
12314 return(1 || funcname || hash || result7 || libp) ;
12315 }
12316
12317
12318 static int G__BankClassesDict_259_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12319 {
12320 EVEH *p;
12321 p=new EVEH(*(EVEH*)G__int(libp->para[0]));
12322 result7->obj.i = (long)p;
12323 result7->ref = (long)p;
12324 result7->type = 'u';
12325 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EVEH);
12326 return(1 || funcname || hash || result7 || libp) ;
12327 }
12328
12329
12330 typedef EVEH G__TEVEH;
12331 static int G__BankClassesDict_259_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12332 if(0==G__getstructoffset()) return(1);
12333 if(G__getaryconstruct())
12334 if(G__PVOID==G__getgvp())
12335 delete[] (EVEH *)(G__getstructoffset());
12336 else
12337 for(int i=G__getaryconstruct()-1;i>=0;i--)
12338 delete (EVEH *)((G__getstructoffset())+sizeof(EVEH)*i);
12339 else delete (EVEH *)(G__getstructoffset());
12340 G__setnull(result7);
12341 return(1 || funcname || hash || result7 || libp) ;
12342 }
12343
12344
12345
12346 static int G__BankClassesDict_260_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12347 KEVH *p=NULL;
12348 if(G__getaryconstruct()) p=new KEVH[G__getaryconstruct()];
12349 else p=new KEVH;
12350 result7->obj.i = (long)p;
12351 result7->ref = (long)p;
12352 result7->type = 'u';
12353 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_KEVH);
12354 return(1 || funcname || hash || result7 || libp) ;
12355 }
12356
12357 static int G__BankClassesDict_260_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12358 G__setnull(result7);
12359 ((KEVH*)(G__getstructoffset()))->Assign((KEVH_PATTERN*)G__int(libp->para[0]));
12360 return(1 || funcname || hash || result7 || libp) ;
12361 }
12362
12363 static int G__BankClassesDict_260_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12364 G__letint(result7,85,(long)KEVH::Class());
12365 return(1 || funcname || hash || result7 || libp) ;
12366 }
12367
12368 static int G__BankClassesDict_260_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12369 G__letint(result7,67,(long)KEVH::Class_Name());
12370 return(1 || funcname || hash || result7 || libp) ;
12371 }
12372
12373 static int G__BankClassesDict_260_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12374 G__letint(result7,115,(long)KEVH::Class_Version());
12375 return(1 || funcname || hash || result7 || libp) ;
12376 }
12377
12378 static int G__BankClassesDict_260_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12379 G__setnull(result7);
12380 KEVH::Dictionary();
12381 return(1 || funcname || hash || result7 || libp) ;
12382 }
12383
12384 static int G__BankClassesDict_260_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12385 G__letint(result7,85,(long)((const KEVH*)(G__getstructoffset()))->IsA());
12386 return(1 || funcname || hash || result7 || libp) ;
12387 }
12388
12389 static int G__BankClassesDict_260_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12390 G__setnull(result7);
12391 ((KEVH*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12392 return(1 || funcname || hash || result7 || libp) ;
12393 }
12394
12395 static int G__BankClassesDict_260_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12396 G__setnull(result7);
12397 ((KEVH*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12398 return(1 || funcname || hash || result7 || libp) ;
12399 }
12400
12401 static int G__BankClassesDict_260_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12402 G__setnull(result7);
12403 ((KEVH*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12404 return(1 || funcname || hash || result7 || libp) ;
12405 }
12406
12407 static int G__BankClassesDict_260_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12408 G__letint(result7,67,(long)KEVH::DeclFileName());
12409 return(1 || funcname || hash || result7 || libp) ;
12410 }
12411
12412 static int G__BankClassesDict_260_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12413 G__letint(result7,105,(long)KEVH::ImplFileLine());
12414 return(1 || funcname || hash || result7 || libp) ;
12415 }
12416
12417 static int G__BankClassesDict_260_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12418 G__letint(result7,67,(long)KEVH::ImplFileName());
12419 return(1 || funcname || hash || result7 || libp) ;
12420 }
12421
12422 static int G__BankClassesDict_260_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12423 G__letint(result7,105,(long)KEVH::DeclFileLine());
12424 return(1 || funcname || hash || result7 || libp) ;
12425 }
12426
12427
12428 static int G__BankClassesDict_260_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12429 {
12430 KEVH *p;
12431 p=new KEVH(*(KEVH*)G__int(libp->para[0]));
12432 result7->obj.i = (long)p;
12433 result7->ref = (long)p;
12434 result7->type = 'u';
12435 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_KEVH);
12436 return(1 || funcname || hash || result7 || libp) ;
12437 }
12438
12439
12440 typedef KEVH G__TKEVH;
12441 static int G__BankClassesDict_260_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12442 if(0==G__getstructoffset()) return(1);
12443 if(G__getaryconstruct())
12444 if(G__PVOID==G__getgvp())
12445 delete[] (KEVH *)(G__getstructoffset());
12446 else
12447 for(int i=G__getaryconstruct()-1;i>=0;i--)
12448 delete (KEVH *)((G__getstructoffset())+sizeof(KEVH)*i);
12449 else delete (KEVH *)(G__getstructoffset());
12450 G__setnull(result7);
12451 return(1 || funcname || hash || result7 || libp) ;
12452 }
12453
12454
12455
12456 static int G__BankClassesDict_261_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12457 REVH *p=NULL;
12458 if(G__getaryconstruct()) p=new REVH[G__getaryconstruct()];
12459 else p=new REVH;
12460 result7->obj.i = (long)p;
12461 result7->ref = (long)p;
12462 result7->type = 'u';
12463 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_REVH);
12464 return(1 || funcname || hash || result7 || libp) ;
12465 }
12466
12467 static int G__BankClassesDict_261_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12468 G__setnull(result7);
12469 ((REVH*)(G__getstructoffset()))->Assign((REVH_PATTERN*)G__int(libp->para[0]));
12470 return(1 || funcname || hash || result7 || libp) ;
12471 }
12472
12473 static int G__BankClassesDict_261_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12474 G__letint(result7,85,(long)REVH::Class());
12475 return(1 || funcname || hash || result7 || libp) ;
12476 }
12477
12478 static int G__BankClassesDict_261_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12479 G__letint(result7,67,(long)REVH::Class_Name());
12480 return(1 || funcname || hash || result7 || libp) ;
12481 }
12482
12483 static int G__BankClassesDict_261_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12484 G__letint(result7,115,(long)REVH::Class_Version());
12485 return(1 || funcname || hash || result7 || libp) ;
12486 }
12487
12488 static int G__BankClassesDict_261_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12489 G__setnull(result7);
12490 REVH::Dictionary();
12491 return(1 || funcname || hash || result7 || libp) ;
12492 }
12493
12494 static int G__BankClassesDict_261_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12495 G__letint(result7,85,(long)((const REVH*)(G__getstructoffset()))->IsA());
12496 return(1 || funcname || hash || result7 || libp) ;
12497 }
12498
12499 static int G__BankClassesDict_261_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12500 G__setnull(result7);
12501 ((REVH*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12502 return(1 || funcname || hash || result7 || libp) ;
12503 }
12504
12505 static int G__BankClassesDict_261_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12506 G__setnull(result7);
12507 ((REVH*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12508 return(1 || funcname || hash || result7 || libp) ;
12509 }
12510
12511 static int G__BankClassesDict_261_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12512 G__setnull(result7);
12513 ((REVH*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12514 return(1 || funcname || hash || result7 || libp) ;
12515 }
12516
12517 static int G__BankClassesDict_261_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12518 G__letint(result7,67,(long)REVH::DeclFileName());
12519 return(1 || funcname || hash || result7 || libp) ;
12520 }
12521
12522 static int G__BankClassesDict_261_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12523 G__letint(result7,105,(long)REVH::ImplFileLine());
12524 return(1 || funcname || hash || result7 || libp) ;
12525 }
12526
12527 static int G__BankClassesDict_261_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12528 G__letint(result7,67,(long)REVH::ImplFileName());
12529 return(1 || funcname || hash || result7 || libp) ;
12530 }
12531
12532 static int G__BankClassesDict_261_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12533 G__letint(result7,105,(long)REVH::DeclFileLine());
12534 return(1 || funcname || hash || result7 || libp) ;
12535 }
12536
12537
12538 static int G__BankClassesDict_261_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12539 {
12540 REVH *p;
12541 p=new REVH(*(REVH*)G__int(libp->para[0]));
12542 result7->obj.i = (long)p;
12543 result7->ref = (long)p;
12544 result7->type = 'u';
12545 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_REVH);
12546 return(1 || funcname || hash || result7 || libp) ;
12547 }
12548
12549
12550 typedef REVH G__TREVH;
12551 static int G__BankClassesDict_261_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12552 if(0==G__getstructoffset()) return(1);
12553 if(G__getaryconstruct())
12554 if(G__PVOID==G__getgvp())
12555 delete[] (REVH *)(G__getstructoffset());
12556 else
12557 for(int i=G__getaryconstruct()-1;i>=0;i--)
12558 delete (REVH *)((G__getstructoffset())+sizeof(REVH)*i);
12559 else delete (REVH *)(G__getstructoffset());
12560 G__setnull(result7);
12561 return(1 || funcname || hash || result7 || libp) ;
12562 }
12563
12564
12565
12566 static int G__BankClassesDict_262_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12567 LOLE *p=NULL;
12568 if(G__getaryconstruct()) p=new LOLE[G__getaryconstruct()];
12569 else p=new LOLE;
12570 result7->obj.i = (long)p;
12571 result7->ref = (long)p;
12572 result7->type = 'u';
12573 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_LOLE);
12574 return(1 || funcname || hash || result7 || libp) ;
12575 }
12576
12577 static int G__BankClassesDict_262_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12578 G__setnull(result7);
12579 ((LOLE*)(G__getstructoffset()))->Assign((LOLE_PATTERN*)G__int(libp->para[0]));
12580 return(1 || funcname || hash || result7 || libp) ;
12581 }
12582
12583 static int G__BankClassesDict_262_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12584 G__letint(result7,85,(long)LOLE::Class());
12585 return(1 || funcname || hash || result7 || libp) ;
12586 }
12587
12588 static int G__BankClassesDict_262_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12589 G__letint(result7,67,(long)LOLE::Class_Name());
12590 return(1 || funcname || hash || result7 || libp) ;
12591 }
12592
12593 static int G__BankClassesDict_262_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12594 G__letint(result7,115,(long)LOLE::Class_Version());
12595 return(1 || funcname || hash || result7 || libp) ;
12596 }
12597
12598 static int G__BankClassesDict_262_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12599 G__setnull(result7);
12600 LOLE::Dictionary();
12601 return(1 || funcname || hash || result7 || libp) ;
12602 }
12603
12604 static int G__BankClassesDict_262_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12605 G__letint(result7,85,(long)((const LOLE*)(G__getstructoffset()))->IsA());
12606 return(1 || funcname || hash || result7 || libp) ;
12607 }
12608
12609 static int G__BankClassesDict_262_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12610 G__setnull(result7);
12611 ((LOLE*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12612 return(1 || funcname || hash || result7 || libp) ;
12613 }
12614
12615 static int G__BankClassesDict_262_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12616 G__setnull(result7);
12617 ((LOLE*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12618 return(1 || funcname || hash || result7 || libp) ;
12619 }
12620
12621 static int G__BankClassesDict_262_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12622 G__setnull(result7);
12623 ((LOLE*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12624 return(1 || funcname || hash || result7 || libp) ;
12625 }
12626
12627 static int G__BankClassesDict_262_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12628 G__letint(result7,67,(long)LOLE::DeclFileName());
12629 return(1 || funcname || hash || result7 || libp) ;
12630 }
12631
12632 static int G__BankClassesDict_262_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12633 G__letint(result7,105,(long)LOLE::ImplFileLine());
12634 return(1 || funcname || hash || result7 || libp) ;
12635 }
12636
12637 static int G__BankClassesDict_262_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12638 G__letint(result7,67,(long)LOLE::ImplFileName());
12639 return(1 || funcname || hash || result7 || libp) ;
12640 }
12641
12642 static int G__BankClassesDict_262_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12643 G__letint(result7,105,(long)LOLE::DeclFileLine());
12644 return(1 || funcname || hash || result7 || libp) ;
12645 }
12646
12647
12648 static int G__BankClassesDict_262_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12649 {
12650 LOLE *p;
12651 p=new LOLE(*(LOLE*)G__int(libp->para[0]));
12652 result7->obj.i = (long)p;
12653 result7->ref = (long)p;
12654 result7->type = 'u';
12655 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_LOLE);
12656 return(1 || funcname || hash || result7 || libp) ;
12657 }
12658
12659
12660 typedef LOLE G__TLOLE;
12661 static int G__BankClassesDict_262_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12662 if(0==G__getstructoffset()) return(1);
12663 if(G__getaryconstruct())
12664 if(G__PVOID==G__getgvp())
12665 delete[] (LOLE *)(G__getstructoffset());
12666 else
12667 for(int i=G__getaryconstruct()-1;i>=0;i--)
12668 delete (LOLE *)((G__getstructoffset())+sizeof(LOLE)*i);
12669 else delete (LOLE *)(G__getstructoffset());
12670 G__setnull(result7);
12671 return(1 || funcname || hash || result7 || libp) ;
12672 }
12673
12674
12675
12676 static int G__BankClassesDict_263_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12677 X1RG *p=NULL;
12678 if(G__getaryconstruct()) p=new X1RG[G__getaryconstruct()];
12679 else p=new X1RG;
12680 result7->obj.i = (long)p;
12681 result7->ref = (long)p;
12682 result7->type = 'u';
12683 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1RG);
12684 return(1 || funcname || hash || result7 || libp) ;
12685 }
12686
12687 static int G__BankClassesDict_263_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12688 G__setnull(result7);
12689 ((X1RG*)(G__getstructoffset()))->Assign((X1RG_PATTERN*)G__int(libp->para[0]));
12690 return(1 || funcname || hash || result7 || libp) ;
12691 }
12692
12693 static int G__BankClassesDict_263_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12694 G__letint(result7,85,(long)X1RG::Class());
12695 return(1 || funcname || hash || result7 || libp) ;
12696 }
12697
12698 static int G__BankClassesDict_263_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12699 G__letint(result7,67,(long)X1RG::Class_Name());
12700 return(1 || funcname || hash || result7 || libp) ;
12701 }
12702
12703 static int G__BankClassesDict_263_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12704 G__letint(result7,115,(long)X1RG::Class_Version());
12705 return(1 || funcname || hash || result7 || libp) ;
12706 }
12707
12708 static int G__BankClassesDict_263_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12709 G__setnull(result7);
12710 X1RG::Dictionary();
12711 return(1 || funcname || hash || result7 || libp) ;
12712 }
12713
12714 static int G__BankClassesDict_263_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12715 G__letint(result7,85,(long)((const X1RG*)(G__getstructoffset()))->IsA());
12716 return(1 || funcname || hash || result7 || libp) ;
12717 }
12718
12719 static int G__BankClassesDict_263_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12720 G__setnull(result7);
12721 ((X1RG*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12722 return(1 || funcname || hash || result7 || libp) ;
12723 }
12724
12725 static int G__BankClassesDict_263_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12726 G__setnull(result7);
12727 ((X1RG*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12728 return(1 || funcname || hash || result7 || libp) ;
12729 }
12730
12731 static int G__BankClassesDict_263_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12732 G__setnull(result7);
12733 ((X1RG*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12734 return(1 || funcname || hash || result7 || libp) ;
12735 }
12736
12737 static int G__BankClassesDict_263_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12738 G__letint(result7,67,(long)X1RG::DeclFileName());
12739 return(1 || funcname || hash || result7 || libp) ;
12740 }
12741
12742 static int G__BankClassesDict_263_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12743 G__letint(result7,105,(long)X1RG::ImplFileLine());
12744 return(1 || funcname || hash || result7 || libp) ;
12745 }
12746
12747 static int G__BankClassesDict_263_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12748 G__letint(result7,67,(long)X1RG::ImplFileName());
12749 return(1 || funcname || hash || result7 || libp) ;
12750 }
12751
12752 static int G__BankClassesDict_263_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12753 G__letint(result7,105,(long)X1RG::DeclFileLine());
12754 return(1 || funcname || hash || result7 || libp) ;
12755 }
12756
12757
12758 static int G__BankClassesDict_263_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12759 {
12760 X1RG *p;
12761 p=new X1RG(*(X1RG*)G__int(libp->para[0]));
12762 result7->obj.i = (long)p;
12763 result7->ref = (long)p;
12764 result7->type = 'u';
12765 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1RG);
12766 return(1 || funcname || hash || result7 || libp) ;
12767 }
12768
12769
12770 typedef X1RG G__TX1RG;
12771 static int G__BankClassesDict_263_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12772 if(0==G__getstructoffset()) return(1);
12773 if(G__getaryconstruct())
12774 if(G__PVOID==G__getgvp())
12775 delete[] (X1RG *)(G__getstructoffset());
12776 else
12777 for(int i=G__getaryconstruct()-1;i>=0;i--)
12778 delete (X1RG *)((G__getstructoffset())+sizeof(X1RG)*i);
12779 else delete (X1RG *)(G__getstructoffset());
12780 G__setnull(result7);
12781 return(1 || funcname || hash || result7 || libp) ;
12782 }
12783
12784
12785
12786 static int G__BankClassesDict_264_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12787 BOMB *p=NULL;
12788 if(G__getaryconstruct()) p=new BOMB[G__getaryconstruct()];
12789 else p=new BOMB;
12790 result7->obj.i = (long)p;
12791 result7->ref = (long)p;
12792 result7->type = 'u';
12793 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_BOMB);
12794 return(1 || funcname || hash || result7 || libp) ;
12795 }
12796
12797 static int G__BankClassesDict_264_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12798 G__setnull(result7);
12799 ((BOMB*)(G__getstructoffset()))->Assign((BOMB_PATTERN*)G__int(libp->para[0]));
12800 return(1 || funcname || hash || result7 || libp) ;
12801 }
12802
12803 static int G__BankClassesDict_264_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12804 G__letint(result7,85,(long)BOMB::Class());
12805 return(1 || funcname || hash || result7 || libp) ;
12806 }
12807
12808 static int G__BankClassesDict_264_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12809 G__letint(result7,67,(long)BOMB::Class_Name());
12810 return(1 || funcname || hash || result7 || libp) ;
12811 }
12812
12813 static int G__BankClassesDict_264_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12814 G__letint(result7,115,(long)BOMB::Class_Version());
12815 return(1 || funcname || hash || result7 || libp) ;
12816 }
12817
12818 static int G__BankClassesDict_264_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12819 G__setnull(result7);
12820 BOMB::Dictionary();
12821 return(1 || funcname || hash || result7 || libp) ;
12822 }
12823
12824 static int G__BankClassesDict_264_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12825 G__letint(result7,85,(long)((const BOMB*)(G__getstructoffset()))->IsA());
12826 return(1 || funcname || hash || result7 || libp) ;
12827 }
12828
12829 static int G__BankClassesDict_264_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12830 G__setnull(result7);
12831 ((BOMB*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12832 return(1 || funcname || hash || result7 || libp) ;
12833 }
12834
12835 static int G__BankClassesDict_264_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12836 G__setnull(result7);
12837 ((BOMB*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12838 return(1 || funcname || hash || result7 || libp) ;
12839 }
12840
12841 static int G__BankClassesDict_264_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12842 G__setnull(result7);
12843 ((BOMB*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12844 return(1 || funcname || hash || result7 || libp) ;
12845 }
12846
12847 static int G__BankClassesDict_264_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12848 G__letint(result7,67,(long)BOMB::DeclFileName());
12849 return(1 || funcname || hash || result7 || libp) ;
12850 }
12851
12852 static int G__BankClassesDict_264_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12853 G__letint(result7,105,(long)BOMB::ImplFileLine());
12854 return(1 || funcname || hash || result7 || libp) ;
12855 }
12856
12857 static int G__BankClassesDict_264_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12858 G__letint(result7,67,(long)BOMB::ImplFileName());
12859 return(1 || funcname || hash || result7 || libp) ;
12860 }
12861
12862 static int G__BankClassesDict_264_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12863 G__letint(result7,105,(long)BOMB::DeclFileLine());
12864 return(1 || funcname || hash || result7 || libp) ;
12865 }
12866
12867
12868 static int G__BankClassesDict_264_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12869 {
12870 BOMB *p;
12871 p=new BOMB(*(BOMB*)G__int(libp->para[0]));
12872 result7->obj.i = (long)p;
12873 result7->ref = (long)p;
12874 result7->type = 'u';
12875 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_BOMB);
12876 return(1 || funcname || hash || result7 || libp) ;
12877 }
12878
12879
12880 typedef BOMB G__TBOMB;
12881 static int G__BankClassesDict_264_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12882 if(0==G__getstructoffset()) return(1);
12883 if(G__getaryconstruct())
12884 if(G__PVOID==G__getgvp())
12885 delete[] (BOMB *)(G__getstructoffset());
12886 else
12887 for(int i=G__getaryconstruct()-1;i>=0;i--)
12888 delete (BOMB *)((G__getstructoffset())+sizeof(BOMB)*i);
12889 else delete (BOMB *)(G__getstructoffset());
12890 G__setnull(result7);
12891 return(1 || funcname || hash || result7 || libp) ;
12892 }
12893
12894
12895
12896 static int G__BankClassesDict_265_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12897 RUNH *p=NULL;
12898 if(G__getaryconstruct()) p=new RUNH[G__getaryconstruct()];
12899 else p=new RUNH;
12900 result7->obj.i = (long)p;
12901 result7->ref = (long)p;
12902 result7->type = 'u';
12903 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RUNH);
12904 return(1 || funcname || hash || result7 || libp) ;
12905 }
12906
12907 static int G__BankClassesDict_265_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12908 G__setnull(result7);
12909 ((RUNH*)(G__getstructoffset()))->Assign((RUNH_PATTERN*)G__int(libp->para[0]));
12910 return(1 || funcname || hash || result7 || libp) ;
12911 }
12912
12913 static int G__BankClassesDict_265_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12914 G__letint(result7,85,(long)RUNH::Class());
12915 return(1 || funcname || hash || result7 || libp) ;
12916 }
12917
12918 static int G__BankClassesDict_265_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12919 G__letint(result7,67,(long)RUNH::Class_Name());
12920 return(1 || funcname || hash || result7 || libp) ;
12921 }
12922
12923 static int G__BankClassesDict_265_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12924 G__letint(result7,115,(long)RUNH::Class_Version());
12925 return(1 || funcname || hash || result7 || libp) ;
12926 }
12927
12928 static int G__BankClassesDict_265_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12929 G__setnull(result7);
12930 RUNH::Dictionary();
12931 return(1 || funcname || hash || result7 || libp) ;
12932 }
12933
12934 static int G__BankClassesDict_265_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12935 G__letint(result7,85,(long)((const RUNH*)(G__getstructoffset()))->IsA());
12936 return(1 || funcname || hash || result7 || libp) ;
12937 }
12938
12939 static int G__BankClassesDict_265_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12940 G__setnull(result7);
12941 ((RUNH*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
12942 return(1 || funcname || hash || result7 || libp) ;
12943 }
12944
12945 static int G__BankClassesDict_265_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12946 G__setnull(result7);
12947 ((RUNH*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
12948 return(1 || funcname || hash || result7 || libp) ;
12949 }
12950
12951 static int G__BankClassesDict_265_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12952 G__setnull(result7);
12953 ((RUNH*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
12954 return(1 || funcname || hash || result7 || libp) ;
12955 }
12956
12957 static int G__BankClassesDict_265_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12958 G__letint(result7,67,(long)RUNH::DeclFileName());
12959 return(1 || funcname || hash || result7 || libp) ;
12960 }
12961
12962 static int G__BankClassesDict_265_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12963 G__letint(result7,105,(long)RUNH::ImplFileLine());
12964 return(1 || funcname || hash || result7 || libp) ;
12965 }
12966
12967 static int G__BankClassesDict_265_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12968 G__letint(result7,67,(long)RUNH::ImplFileName());
12969 return(1 || funcname || hash || result7 || libp) ;
12970 }
12971
12972 static int G__BankClassesDict_265_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12973 G__letint(result7,105,(long)RUNH::DeclFileLine());
12974 return(1 || funcname || hash || result7 || libp) ;
12975 }
12976
12977
12978 static int G__BankClassesDict_265_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
12979 {
12980 RUNH *p;
12981 p=new RUNH(*(RUNH*)G__int(libp->para[0]));
12982 result7->obj.i = (long)p;
12983 result7->ref = (long)p;
12984 result7->type = 'u';
12985 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_RUNH);
12986 return(1 || funcname || hash || result7 || libp) ;
12987 }
12988
12989
12990 typedef RUNH G__TRUNH;
12991 static int G__BankClassesDict_265_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
12992 if(0==G__getstructoffset()) return(1);
12993 if(G__getaryconstruct())
12994 if(G__PVOID==G__getgvp())
12995 delete[] (RUNH *)(G__getstructoffset());
12996 else
12997 for(int i=G__getaryconstruct()-1;i>=0;i--)
12998 delete (RUNH *)((G__getstructoffset())+sizeof(RUNH)*i);
12999 else delete (RUNH *)(G__getstructoffset());
13000 G__setnull(result7);
13001 return(1 || funcname || hash || result7 || libp) ;
13002 }
13003
13004
13005
13006 static int G__BankClassesDict_266_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13007 ASIM *p=NULL;
13008 if(G__getaryconstruct()) p=new ASIM[G__getaryconstruct()];
13009 else p=new ASIM;
13010 result7->obj.i = (long)p;
13011 result7->ref = (long)p;
13012 result7->type = 'u';
13013 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ASIM);
13014 return(1 || funcname || hash || result7 || libp) ;
13015 }
13016
13017 static int G__BankClassesDict_266_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13018 G__setnull(result7);
13019 ((ASIM*)(G__getstructoffset()))->Assign((ASIM_PATTERN*)G__int(libp->para[0]));
13020 return(1 || funcname || hash || result7 || libp) ;
13021 }
13022
13023 static int G__BankClassesDict_266_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13024 G__letint(result7,85,(long)ASIM::Class());
13025 return(1 || funcname || hash || result7 || libp) ;
13026 }
13027
13028 static int G__BankClassesDict_266_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13029 G__letint(result7,67,(long)ASIM::Class_Name());
13030 return(1 || funcname || hash || result7 || libp) ;
13031 }
13032
13033 static int G__BankClassesDict_266_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13034 G__letint(result7,115,(long)ASIM::Class_Version());
13035 return(1 || funcname || hash || result7 || libp) ;
13036 }
13037
13038 static int G__BankClassesDict_266_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13039 G__setnull(result7);
13040 ASIM::Dictionary();
13041 return(1 || funcname || hash || result7 || libp) ;
13042 }
13043
13044 static int G__BankClassesDict_266_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13045 G__letint(result7,85,(long)((const ASIM*)(G__getstructoffset()))->IsA());
13046 return(1 || funcname || hash || result7 || libp) ;
13047 }
13048
13049 static int G__BankClassesDict_266_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13050 G__setnull(result7);
13051 ((ASIM*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13052 return(1 || funcname || hash || result7 || libp) ;
13053 }
13054
13055 static int G__BankClassesDict_266_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13056 G__setnull(result7);
13057 ((ASIM*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13058 return(1 || funcname || hash || result7 || libp) ;
13059 }
13060
13061 static int G__BankClassesDict_266_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13062 G__setnull(result7);
13063 ((ASIM*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13064 return(1 || funcname || hash || result7 || libp) ;
13065 }
13066
13067 static int G__BankClassesDict_266_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13068 G__letint(result7,67,(long)ASIM::DeclFileName());
13069 return(1 || funcname || hash || result7 || libp) ;
13070 }
13071
13072 static int G__BankClassesDict_266_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13073 G__letint(result7,105,(long)ASIM::ImplFileLine());
13074 return(1 || funcname || hash || result7 || libp) ;
13075 }
13076
13077 static int G__BankClassesDict_266_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13078 G__letint(result7,67,(long)ASIM::ImplFileName());
13079 return(1 || funcname || hash || result7 || libp) ;
13080 }
13081
13082 static int G__BankClassesDict_266_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13083 G__letint(result7,105,(long)ASIM::DeclFileLine());
13084 return(1 || funcname || hash || result7 || libp) ;
13085 }
13086
13087
13088 static int G__BankClassesDict_266_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13089 {
13090 ASIM *p;
13091 p=new ASIM(*(ASIM*)G__int(libp->para[0]));
13092 result7->obj.i = (long)p;
13093 result7->ref = (long)p;
13094 result7->type = 'u';
13095 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ASIM);
13096 return(1 || funcname || hash || result7 || libp) ;
13097 }
13098
13099
13100 typedef ASIM G__TASIM;
13101 static int G__BankClassesDict_266_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13102 if(0==G__getstructoffset()) return(1);
13103 if(G__getaryconstruct())
13104 if(G__PVOID==G__getgvp())
13105 delete[] (ASIM *)(G__getstructoffset());
13106 else
13107 for(int i=G__getaryconstruct()-1;i>=0;i--)
13108 delete (ASIM *)((G__getstructoffset())+sizeof(ASIM)*i);
13109 else delete (ASIM *)(G__getstructoffset());
13110 G__setnull(result7);
13111 return(1 || funcname || hash || result7 || libp) ;
13112 }
13113
13114
13115
13116 static int G__BankClassesDict_267_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13117 ADBR *p=NULL;
13118 if(G__getaryconstruct()) p=new ADBR[G__getaryconstruct()];
13119 else p=new ADBR;
13120 result7->obj.i = (long)p;
13121 result7->ref = (long)p;
13122 result7->type = 'u';
13123 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ADBR);
13124 return(1 || funcname || hash || result7 || libp) ;
13125 }
13126
13127 static int G__BankClassesDict_267_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13128 G__setnull(result7);
13129 ((ADBR*)(G__getstructoffset()))->Assign((ADBR_PATTERN*)G__int(libp->para[0]));
13130 return(1 || funcname || hash || result7 || libp) ;
13131 }
13132
13133 static int G__BankClassesDict_267_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13134 G__letint(result7,85,(long)ADBR::Class());
13135 return(1 || funcname || hash || result7 || libp) ;
13136 }
13137
13138 static int G__BankClassesDict_267_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13139 G__letint(result7,67,(long)ADBR::Class_Name());
13140 return(1 || funcname || hash || result7 || libp) ;
13141 }
13142
13143 static int G__BankClassesDict_267_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13144 G__letint(result7,115,(long)ADBR::Class_Version());
13145 return(1 || funcname || hash || result7 || libp) ;
13146 }
13147
13148 static int G__BankClassesDict_267_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13149 G__setnull(result7);
13150 ADBR::Dictionary();
13151 return(1 || funcname || hash || result7 || libp) ;
13152 }
13153
13154 static int G__BankClassesDict_267_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13155 G__letint(result7,85,(long)((const ADBR*)(G__getstructoffset()))->IsA());
13156 return(1 || funcname || hash || result7 || libp) ;
13157 }
13158
13159 static int G__BankClassesDict_267_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13160 G__setnull(result7);
13161 ((ADBR*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13162 return(1 || funcname || hash || result7 || libp) ;
13163 }
13164
13165 static int G__BankClassesDict_267_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13166 G__setnull(result7);
13167 ((ADBR*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13168 return(1 || funcname || hash || result7 || libp) ;
13169 }
13170
13171 static int G__BankClassesDict_267_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13172 G__setnull(result7);
13173 ((ADBR*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13174 return(1 || funcname || hash || result7 || libp) ;
13175 }
13176
13177 static int G__BankClassesDict_267_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13178 G__letint(result7,67,(long)ADBR::DeclFileName());
13179 return(1 || funcname || hash || result7 || libp) ;
13180 }
13181
13182 static int G__BankClassesDict_267_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13183 G__letint(result7,105,(long)ADBR::ImplFileLine());
13184 return(1 || funcname || hash || result7 || libp) ;
13185 }
13186
13187 static int G__BankClassesDict_267_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13188 G__letint(result7,67,(long)ADBR::ImplFileName());
13189 return(1 || funcname || hash || result7 || libp) ;
13190 }
13191
13192 static int G__BankClassesDict_267_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13193 G__letint(result7,105,(long)ADBR::DeclFileLine());
13194 return(1 || funcname || hash || result7 || libp) ;
13195 }
13196
13197
13198 static int G__BankClassesDict_267_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13199 {
13200 ADBR *p;
13201 p=new ADBR(*(ADBR*)G__int(libp->para[0]));
13202 result7->obj.i = (long)p;
13203 result7->ref = (long)p;
13204 result7->type = 'u';
13205 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_ADBR);
13206 return(1 || funcname || hash || result7 || libp) ;
13207 }
13208
13209
13210 typedef ADBR G__TADBR;
13211 static int G__BankClassesDict_267_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13212 if(0==G__getstructoffset()) return(1);
13213 if(G__getaryconstruct())
13214 if(G__PVOID==G__getgvp())
13215 delete[] (ADBR *)(G__getstructoffset());
13216 else
13217 for(int i=G__getaryconstruct()-1;i>=0;i--)
13218 delete (ADBR *)((G__getstructoffset())+sizeof(ADBR)*i);
13219 else delete (ADBR *)(G__getstructoffset());
13220 G__setnull(result7);
13221 return(1 || funcname || hash || result7 || libp) ;
13222 }
13223
13224
13225
13226 static int G__BankClassesDict_268_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13227 XTBN *p=NULL;
13228 if(G__getaryconstruct()) p=new XTBN[G__getaryconstruct()];
13229 else p=new XTBN;
13230 result7->obj.i = (long)p;
13231 result7->ref = (long)p;
13232 result7->type = 'u';
13233 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTBN);
13234 return(1 || funcname || hash || result7 || libp) ;
13235 }
13236
13237 static int G__BankClassesDict_268_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13238 G__setnull(result7);
13239 ((XTBN*)(G__getstructoffset()))->Assign((XTBN_PATTERN*)G__int(libp->para[0]));
13240 return(1 || funcname || hash || result7 || libp) ;
13241 }
13242
13243 static int G__BankClassesDict_268_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13244 G__letint(result7,85,(long)XTBN::Class());
13245 return(1 || funcname || hash || result7 || libp) ;
13246 }
13247
13248 static int G__BankClassesDict_268_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13249 G__letint(result7,67,(long)XTBN::Class_Name());
13250 return(1 || funcname || hash || result7 || libp) ;
13251 }
13252
13253 static int G__BankClassesDict_268_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13254 G__letint(result7,115,(long)XTBN::Class_Version());
13255 return(1 || funcname || hash || result7 || libp) ;
13256 }
13257
13258 static int G__BankClassesDict_268_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13259 G__setnull(result7);
13260 XTBN::Dictionary();
13261 return(1 || funcname || hash || result7 || libp) ;
13262 }
13263
13264 static int G__BankClassesDict_268_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13265 G__letint(result7,85,(long)((const XTBN*)(G__getstructoffset()))->IsA());
13266 return(1 || funcname || hash || result7 || libp) ;
13267 }
13268
13269 static int G__BankClassesDict_268_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13270 G__setnull(result7);
13271 ((XTBN*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13272 return(1 || funcname || hash || result7 || libp) ;
13273 }
13274
13275 static int G__BankClassesDict_268_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13276 G__setnull(result7);
13277 ((XTBN*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13278 return(1 || funcname || hash || result7 || libp) ;
13279 }
13280
13281 static int G__BankClassesDict_268_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13282 G__setnull(result7);
13283 ((XTBN*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13284 return(1 || funcname || hash || result7 || libp) ;
13285 }
13286
13287 static int G__BankClassesDict_268_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13288 G__letint(result7,67,(long)XTBN::DeclFileName());
13289 return(1 || funcname || hash || result7 || libp) ;
13290 }
13291
13292 static int G__BankClassesDict_268_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13293 G__letint(result7,105,(long)XTBN::ImplFileLine());
13294 return(1 || funcname || hash || result7 || libp) ;
13295 }
13296
13297 static int G__BankClassesDict_268_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13298 G__letint(result7,67,(long)XTBN::ImplFileName());
13299 return(1 || funcname || hash || result7 || libp) ;
13300 }
13301
13302 static int G__BankClassesDict_268_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13303 G__letint(result7,105,(long)XTBN::DeclFileLine());
13304 return(1 || funcname || hash || result7 || libp) ;
13305 }
13306
13307
13308 static int G__BankClassesDict_268_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13309 {
13310 XTBN *p;
13311 p=new XTBN(*(XTBN*)G__int(libp->para[0]));
13312 result7->obj.i = (long)p;
13313 result7->ref = (long)p;
13314 result7->type = 'u';
13315 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTBN);
13316 return(1 || funcname || hash || result7 || libp) ;
13317 }
13318
13319
13320 typedef XTBN G__TXTBN;
13321 static int G__BankClassesDict_268_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13322 if(0==G__getstructoffset()) return(1);
13323 if(G__getaryconstruct())
13324 if(G__PVOID==G__getgvp())
13325 delete[] (XTBN *)(G__getstructoffset());
13326 else
13327 for(int i=G__getaryconstruct()-1;i>=0;i--)
13328 delete (XTBN *)((G__getstructoffset())+sizeof(XTBN)*i);
13329 else delete (XTBN *)(G__getstructoffset());
13330 G__setnull(result7);
13331 return(1 || funcname || hash || result7 || libp) ;
13332 }
13333
13334
13335
13336 static int G__BankClassesDict_269_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13337 XTCN *p=NULL;
13338 if(G__getaryconstruct()) p=new XTCN[G__getaryconstruct()];
13339 else p=new XTCN;
13340 result7->obj.i = (long)p;
13341 result7->ref = (long)p;
13342 result7->type = 'u';
13343 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTCN);
13344 return(1 || funcname || hash || result7 || libp) ;
13345 }
13346
13347 static int G__BankClassesDict_269_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13348 G__setnull(result7);
13349 ((XTCN*)(G__getstructoffset()))->Assign((XTCN_PATTERN*)G__int(libp->para[0]));
13350 return(1 || funcname || hash || result7 || libp) ;
13351 }
13352
13353 static int G__BankClassesDict_269_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13354 G__letint(result7,85,(long)XTCN::Class());
13355 return(1 || funcname || hash || result7 || libp) ;
13356 }
13357
13358 static int G__BankClassesDict_269_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13359 G__letint(result7,67,(long)XTCN::Class_Name());
13360 return(1 || funcname || hash || result7 || libp) ;
13361 }
13362
13363 static int G__BankClassesDict_269_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13364 G__letint(result7,115,(long)XTCN::Class_Version());
13365 return(1 || funcname || hash || result7 || libp) ;
13366 }
13367
13368 static int G__BankClassesDict_269_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13369 G__setnull(result7);
13370 XTCN::Dictionary();
13371 return(1 || funcname || hash || result7 || libp) ;
13372 }
13373
13374 static int G__BankClassesDict_269_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13375 G__letint(result7,85,(long)((const XTCN*)(G__getstructoffset()))->IsA());
13376 return(1 || funcname || hash || result7 || libp) ;
13377 }
13378
13379 static int G__BankClassesDict_269_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13380 G__setnull(result7);
13381 ((XTCN*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13382 return(1 || funcname || hash || result7 || libp) ;
13383 }
13384
13385 static int G__BankClassesDict_269_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13386 G__setnull(result7);
13387 ((XTCN*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13388 return(1 || funcname || hash || result7 || libp) ;
13389 }
13390
13391 static int G__BankClassesDict_269_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13392 G__setnull(result7);
13393 ((XTCN*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13394 return(1 || funcname || hash || result7 || libp) ;
13395 }
13396
13397 static int G__BankClassesDict_269_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13398 G__letint(result7,67,(long)XTCN::DeclFileName());
13399 return(1 || funcname || hash || result7 || libp) ;
13400 }
13401
13402 static int G__BankClassesDict_269_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13403 G__letint(result7,105,(long)XTCN::ImplFileLine());
13404 return(1 || funcname || hash || result7 || libp) ;
13405 }
13406
13407 static int G__BankClassesDict_269_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13408 G__letint(result7,67,(long)XTCN::ImplFileName());
13409 return(1 || funcname || hash || result7 || libp) ;
13410 }
13411
13412 static int G__BankClassesDict_269_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13413 G__letint(result7,105,(long)XTCN::DeclFileLine());
13414 return(1 || funcname || hash || result7 || libp) ;
13415 }
13416
13417
13418 static int G__BankClassesDict_269_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13419 {
13420 XTCN *p;
13421 p=new XTCN(*(XTCN*)G__int(libp->para[0]));
13422 result7->obj.i = (long)p;
13423 result7->ref = (long)p;
13424 result7->type = 'u';
13425 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTCN);
13426 return(1 || funcname || hash || result7 || libp) ;
13427 }
13428
13429
13430 typedef XTCN G__TXTCN;
13431 static int G__BankClassesDict_269_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13432 if(0==G__getstructoffset()) return(1);
13433 if(G__getaryconstruct())
13434 if(G__PVOID==G__getgvp())
13435 delete[] (XTCN *)(G__getstructoffset());
13436 else
13437 for(int i=G__getaryconstruct()-1;i>=0;i--)
13438 delete (XTCN *)((G__getstructoffset())+sizeof(XTCN)*i);
13439 else delete (XTCN *)(G__getstructoffset());
13440 G__setnull(result7);
13441 return(1 || funcname || hash || result7 || libp) ;
13442 }
13443
13444
13445
13446 static int G__BankClassesDict_270_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13447 XTOP *p=NULL;
13448 if(G__getaryconstruct()) p=new XTOP[G__getaryconstruct()];
13449 else p=new XTOP;
13450 result7->obj.i = (long)p;
13451 result7->ref = (long)p;
13452 result7->type = 'u';
13453 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTOP);
13454 return(1 || funcname || hash || result7 || libp) ;
13455 }
13456
13457 static int G__BankClassesDict_270_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13458 G__setnull(result7);
13459 ((XTOP*)(G__getstructoffset()))->Assign((XTOP_PATTERN*)G__int(libp->para[0]));
13460 return(1 || funcname || hash || result7 || libp) ;
13461 }
13462
13463 static int G__BankClassesDict_270_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13464 G__letint(result7,85,(long)XTOP::Class());
13465 return(1 || funcname || hash || result7 || libp) ;
13466 }
13467
13468 static int G__BankClassesDict_270_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13469 G__letint(result7,67,(long)XTOP::Class_Name());
13470 return(1 || funcname || hash || result7 || libp) ;
13471 }
13472
13473 static int G__BankClassesDict_270_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13474 G__letint(result7,115,(long)XTOP::Class_Version());
13475 return(1 || funcname || hash || result7 || libp) ;
13476 }
13477
13478 static int G__BankClassesDict_270_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13479 G__setnull(result7);
13480 XTOP::Dictionary();
13481 return(1 || funcname || hash || result7 || libp) ;
13482 }
13483
13484 static int G__BankClassesDict_270_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13485 G__letint(result7,85,(long)((const XTOP*)(G__getstructoffset()))->IsA());
13486 return(1 || funcname || hash || result7 || libp) ;
13487 }
13488
13489 static int G__BankClassesDict_270_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13490 G__setnull(result7);
13491 ((XTOP*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13492 return(1 || funcname || hash || result7 || libp) ;
13493 }
13494
13495 static int G__BankClassesDict_270_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13496 G__setnull(result7);
13497 ((XTOP*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13498 return(1 || funcname || hash || result7 || libp) ;
13499 }
13500
13501 static int G__BankClassesDict_270_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13502 G__setnull(result7);
13503 ((XTOP*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13504 return(1 || funcname || hash || result7 || libp) ;
13505 }
13506
13507 static int G__BankClassesDict_270_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13508 G__letint(result7,67,(long)XTOP::DeclFileName());
13509 return(1 || funcname || hash || result7 || libp) ;
13510 }
13511
13512 static int G__BankClassesDict_270_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13513 G__letint(result7,105,(long)XTOP::ImplFileLine());
13514 return(1 || funcname || hash || result7 || libp) ;
13515 }
13516
13517 static int G__BankClassesDict_270_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13518 G__letint(result7,67,(long)XTOP::ImplFileName());
13519 return(1 || funcname || hash || result7 || libp) ;
13520 }
13521
13522 static int G__BankClassesDict_270_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13523 G__letint(result7,105,(long)XTOP::DeclFileLine());
13524 return(1 || funcname || hash || result7 || libp) ;
13525 }
13526
13527
13528 static int G__BankClassesDict_270_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13529 {
13530 XTOP *p;
13531 p=new XTOP(*(XTOP*)G__int(libp->para[0]));
13532 result7->obj.i = (long)p;
13533 result7->ref = (long)p;
13534 result7->type = 'u';
13535 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTOP);
13536 return(1 || funcname || hash || result7 || libp) ;
13537 }
13538
13539
13540 typedef XTOP G__TXTOP;
13541 static int G__BankClassesDict_270_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13542 if(0==G__getstructoffset()) return(1);
13543 if(G__getaryconstruct())
13544 if(G__PVOID==G__getgvp())
13545 delete[] (XTOP *)(G__getstructoffset());
13546 else
13547 for(int i=G__getaryconstruct()-1;i>=0;i--)
13548 delete (XTOP *)((G__getstructoffset())+sizeof(XTOP)*i);
13549 else delete (XTOP *)(G__getstructoffset());
13550 G__setnull(result7);
13551 return(1 || funcname || hash || result7 || libp) ;
13552 }
13553
13554
13555
13556 static int G__BankClassesDict_271_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13557 LUPA *p=NULL;
13558 if(G__getaryconstruct()) p=new LUPA[G__getaryconstruct()];
13559 else p=new LUPA;
13560 result7->obj.i = (long)p;
13561 result7->ref = (long)p;
13562 result7->type = 'u';
13563 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_LUPA);
13564 return(1 || funcname || hash || result7 || libp) ;
13565 }
13566
13567 static int G__BankClassesDict_271_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13568 G__setnull(result7);
13569 ((LUPA*)(G__getstructoffset()))->Assign((LUPA_PATTERN*)G__int(libp->para[0]));
13570 return(1 || funcname || hash || result7 || libp) ;
13571 }
13572
13573 static int G__BankClassesDict_271_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13574 G__letint(result7,85,(long)LUPA::Class());
13575 return(1 || funcname || hash || result7 || libp) ;
13576 }
13577
13578 static int G__BankClassesDict_271_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13579 G__letint(result7,67,(long)LUPA::Class_Name());
13580 return(1 || funcname || hash || result7 || libp) ;
13581 }
13582
13583 static int G__BankClassesDict_271_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13584 G__letint(result7,115,(long)LUPA::Class_Version());
13585 return(1 || funcname || hash || result7 || libp) ;
13586 }
13587
13588 static int G__BankClassesDict_271_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13589 G__setnull(result7);
13590 LUPA::Dictionary();
13591 return(1 || funcname || hash || result7 || libp) ;
13592 }
13593
13594 static int G__BankClassesDict_271_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13595 G__letint(result7,85,(long)((const LUPA*)(G__getstructoffset()))->IsA());
13596 return(1 || funcname || hash || result7 || libp) ;
13597 }
13598
13599 static int G__BankClassesDict_271_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13600 G__setnull(result7);
13601 ((LUPA*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13602 return(1 || funcname || hash || result7 || libp) ;
13603 }
13604
13605 static int G__BankClassesDict_271_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13606 G__setnull(result7);
13607 ((LUPA*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13608 return(1 || funcname || hash || result7 || libp) ;
13609 }
13610
13611 static int G__BankClassesDict_271_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13612 G__setnull(result7);
13613 ((LUPA*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13614 return(1 || funcname || hash || result7 || libp) ;
13615 }
13616
13617 static int G__BankClassesDict_271_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13618 G__letint(result7,67,(long)LUPA::DeclFileName());
13619 return(1 || funcname || hash || result7 || libp) ;
13620 }
13621
13622 static int G__BankClassesDict_271_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13623 G__letint(result7,105,(long)LUPA::ImplFileLine());
13624 return(1 || funcname || hash || result7 || libp) ;
13625 }
13626
13627 static int G__BankClassesDict_271_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13628 G__letint(result7,67,(long)LUPA::ImplFileName());
13629 return(1 || funcname || hash || result7 || libp) ;
13630 }
13631
13632 static int G__BankClassesDict_271_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13633 G__letint(result7,105,(long)LUPA::DeclFileLine());
13634 return(1 || funcname || hash || result7 || libp) ;
13635 }
13636
13637
13638 static int G__BankClassesDict_271_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13639 {
13640 LUPA *p;
13641 p=new LUPA(*(LUPA*)G__int(libp->para[0]));
13642 result7->obj.i = (long)p;
13643 result7->ref = (long)p;
13644 result7->type = 'u';
13645 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_LUPA);
13646 return(1 || funcname || hash || result7 || libp) ;
13647 }
13648
13649
13650 typedef LUPA G__TLUPA;
13651 static int G__BankClassesDict_271_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13652 if(0==G__getstructoffset()) return(1);
13653 if(G__getaryconstruct())
13654 if(G__PVOID==G__getgvp())
13655 delete[] (LUPA *)(G__getstructoffset());
13656 else
13657 for(int i=G__getaryconstruct()-1;i>=0;i--)
13658 delete (LUPA *)((G__getstructoffset())+sizeof(LUPA)*i);
13659 else delete (LUPA *)(G__getstructoffset());
13660 G__setnull(result7);
13661 return(1 || funcname || hash || result7 || libp) ;
13662 }
13663
13664
13665
13666 static int G__BankClassesDict_272_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13667 SILH *p=NULL;
13668 if(G__getaryconstruct()) p=new SILH[G__getaryconstruct()];
13669 else p=new SILH;
13670 result7->obj.i = (long)p;
13671 result7->ref = (long)p;
13672 result7->type = 'u';
13673 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SILH);
13674 return(1 || funcname || hash || result7 || libp) ;
13675 }
13676
13677 static int G__BankClassesDict_272_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13678 G__setnull(result7);
13679 ((SILH*)(G__getstructoffset()))->Assign((SILH_PATTERN*)G__int(libp->para[0]));
13680 return(1 || funcname || hash || result7 || libp) ;
13681 }
13682
13683 static int G__BankClassesDict_272_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13684 G__letint(result7,85,(long)SILH::Class());
13685 return(1 || funcname || hash || result7 || libp) ;
13686 }
13687
13688 static int G__BankClassesDict_272_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13689 G__letint(result7,67,(long)SILH::Class_Name());
13690 return(1 || funcname || hash || result7 || libp) ;
13691 }
13692
13693 static int G__BankClassesDict_272_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13694 G__letint(result7,115,(long)SILH::Class_Version());
13695 return(1 || funcname || hash || result7 || libp) ;
13696 }
13697
13698 static int G__BankClassesDict_272_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13699 G__setnull(result7);
13700 SILH::Dictionary();
13701 return(1 || funcname || hash || result7 || libp) ;
13702 }
13703
13704 static int G__BankClassesDict_272_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13705 G__letint(result7,85,(long)((const SILH*)(G__getstructoffset()))->IsA());
13706 return(1 || funcname || hash || result7 || libp) ;
13707 }
13708
13709 static int G__BankClassesDict_272_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13710 G__setnull(result7);
13711 ((SILH*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13712 return(1 || funcname || hash || result7 || libp) ;
13713 }
13714
13715 static int G__BankClassesDict_272_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13716 G__setnull(result7);
13717 ((SILH*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13718 return(1 || funcname || hash || result7 || libp) ;
13719 }
13720
13721 static int G__BankClassesDict_272_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13722 G__setnull(result7);
13723 ((SILH*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13724 return(1 || funcname || hash || result7 || libp) ;
13725 }
13726
13727 static int G__BankClassesDict_272_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13728 G__letint(result7,67,(long)SILH::DeclFileName());
13729 return(1 || funcname || hash || result7 || libp) ;
13730 }
13731
13732 static int G__BankClassesDict_272_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13733 G__letint(result7,105,(long)SILH::ImplFileLine());
13734 return(1 || funcname || hash || result7 || libp) ;
13735 }
13736
13737 static int G__BankClassesDict_272_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13738 G__letint(result7,67,(long)SILH::ImplFileName());
13739 return(1 || funcname || hash || result7 || libp) ;
13740 }
13741
13742 static int G__BankClassesDict_272_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13743 G__letint(result7,105,(long)SILH::DeclFileLine());
13744 return(1 || funcname || hash || result7 || libp) ;
13745 }
13746
13747
13748 static int G__BankClassesDict_272_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13749 {
13750 SILH *p;
13751 p=new SILH(*(SILH*)G__int(libp->para[0]));
13752 result7->obj.i = (long)p;
13753 result7->ref = (long)p;
13754 result7->type = 'u';
13755 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SILH);
13756 return(1 || funcname || hash || result7 || libp) ;
13757 }
13758
13759
13760 typedef SILH G__TSILH;
13761 static int G__BankClassesDict_272_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13762 if(0==G__getstructoffset()) return(1);
13763 if(G__getaryconstruct())
13764 if(G__PVOID==G__getgvp())
13765 delete[] (SILH *)(G__getstructoffset());
13766 else
13767 for(int i=G__getaryconstruct()-1;i>=0;i--)
13768 delete (SILH *)((G__getstructoffset())+sizeof(SILH)*i);
13769 else delete (SILH *)(G__getstructoffset());
13770 G__setnull(result7);
13771 return(1 || funcname || hash || result7 || libp) ;
13772 }
13773
13774
13775
13776 static int G__BankClassesDict_273_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13777 XHVB *p=NULL;
13778 if(G__getaryconstruct()) p=new XHVB[G__getaryconstruct()];
13779 else p=new XHVB;
13780 result7->obj.i = (long)p;
13781 result7->ref = (long)p;
13782 result7->type = 'u';
13783 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XHVB);
13784 return(1 || funcname || hash || result7 || libp) ;
13785 }
13786
13787 static int G__BankClassesDict_273_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13788 G__setnull(result7);
13789 ((XHVB*)(G__getstructoffset()))->Assign((XHVB_PATTERN*)G__int(libp->para[0]));
13790 return(1 || funcname || hash || result7 || libp) ;
13791 }
13792
13793 static int G__BankClassesDict_273_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13794 G__letint(result7,85,(long)XHVB::Class());
13795 return(1 || funcname || hash || result7 || libp) ;
13796 }
13797
13798 static int G__BankClassesDict_273_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13799 G__letint(result7,67,(long)XHVB::Class_Name());
13800 return(1 || funcname || hash || result7 || libp) ;
13801 }
13802
13803 static int G__BankClassesDict_273_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13804 G__letint(result7,115,(long)XHVB::Class_Version());
13805 return(1 || funcname || hash || result7 || libp) ;
13806 }
13807
13808 static int G__BankClassesDict_273_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13809 G__setnull(result7);
13810 XHVB::Dictionary();
13811 return(1 || funcname || hash || result7 || libp) ;
13812 }
13813
13814 static int G__BankClassesDict_273_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13815 G__letint(result7,85,(long)((const XHVB*)(G__getstructoffset()))->IsA());
13816 return(1 || funcname || hash || result7 || libp) ;
13817 }
13818
13819 static int G__BankClassesDict_273_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13820 G__setnull(result7);
13821 ((XHVB*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13822 return(1 || funcname || hash || result7 || libp) ;
13823 }
13824
13825 static int G__BankClassesDict_273_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13826 G__setnull(result7);
13827 ((XHVB*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13828 return(1 || funcname || hash || result7 || libp) ;
13829 }
13830
13831 static int G__BankClassesDict_273_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13832 G__setnull(result7);
13833 ((XHVB*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13834 return(1 || funcname || hash || result7 || libp) ;
13835 }
13836
13837 static int G__BankClassesDict_273_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13838 G__letint(result7,67,(long)XHVB::DeclFileName());
13839 return(1 || funcname || hash || result7 || libp) ;
13840 }
13841
13842 static int G__BankClassesDict_273_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13843 G__letint(result7,105,(long)XHVB::ImplFileLine());
13844 return(1 || funcname || hash || result7 || libp) ;
13845 }
13846
13847 static int G__BankClassesDict_273_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13848 G__letint(result7,67,(long)XHVB::ImplFileName());
13849 return(1 || funcname || hash || result7 || libp) ;
13850 }
13851
13852 static int G__BankClassesDict_273_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13853 G__letint(result7,105,(long)XHVB::DeclFileLine());
13854 return(1 || funcname || hash || result7 || libp) ;
13855 }
13856
13857
13858 static int G__BankClassesDict_273_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13859 {
13860 XHVB *p;
13861 p=new XHVB(*(XHVB*)G__int(libp->para[0]));
13862 result7->obj.i = (long)p;
13863 result7->ref = (long)p;
13864 result7->type = 'u';
13865 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XHVB);
13866 return(1 || funcname || hash || result7 || libp) ;
13867 }
13868
13869
13870 typedef XHVB G__TXHVB;
13871 static int G__BankClassesDict_273_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13872 if(0==G__getstructoffset()) return(1);
13873 if(G__getaryconstruct())
13874 if(G__PVOID==G__getgvp())
13875 delete[] (XHVB *)(G__getstructoffset());
13876 else
13877 for(int i=G__getaryconstruct()-1;i>=0;i--)
13878 delete (XHVB *)((G__getstructoffset())+sizeof(XHVB)*i);
13879 else delete (XHVB *)(G__getstructoffset());
13880 G__setnull(result7);
13881 return(1 || funcname || hash || result7 || libp) ;
13882 }
13883
13884
13885
13886 static int G__BankClassesDict_274_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13887 XTEB *p=NULL;
13888 if(G__getaryconstruct()) p=new XTEB[G__getaryconstruct()];
13889 else p=new XTEB;
13890 result7->obj.i = (long)p;
13891 result7->ref = (long)p;
13892 result7->type = 'u';
13893 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTEB);
13894 return(1 || funcname || hash || result7 || libp) ;
13895 }
13896
13897 static int G__BankClassesDict_274_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13898 G__setnull(result7);
13899 ((XTEB*)(G__getstructoffset()))->Assign((XTEB_PATTERN*)G__int(libp->para[0]));
13900 return(1 || funcname || hash || result7 || libp) ;
13901 }
13902
13903 static int G__BankClassesDict_274_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13904 G__letint(result7,85,(long)XTEB::Class());
13905 return(1 || funcname || hash || result7 || libp) ;
13906 }
13907
13908 static int G__BankClassesDict_274_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13909 G__letint(result7,67,(long)XTEB::Class_Name());
13910 return(1 || funcname || hash || result7 || libp) ;
13911 }
13912
13913 static int G__BankClassesDict_274_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13914 G__letint(result7,115,(long)XTEB::Class_Version());
13915 return(1 || funcname || hash || result7 || libp) ;
13916 }
13917
13918 static int G__BankClassesDict_274_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13919 G__setnull(result7);
13920 XTEB::Dictionary();
13921 return(1 || funcname || hash || result7 || libp) ;
13922 }
13923
13924 static int G__BankClassesDict_274_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13925 G__letint(result7,85,(long)((const XTEB*)(G__getstructoffset()))->IsA());
13926 return(1 || funcname || hash || result7 || libp) ;
13927 }
13928
13929 static int G__BankClassesDict_274_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13930 G__setnull(result7);
13931 ((XTEB*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
13932 return(1 || funcname || hash || result7 || libp) ;
13933 }
13934
13935 static int G__BankClassesDict_274_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13936 G__setnull(result7);
13937 ((XTEB*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
13938 return(1 || funcname || hash || result7 || libp) ;
13939 }
13940
13941 static int G__BankClassesDict_274_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13942 G__setnull(result7);
13943 ((XTEB*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
13944 return(1 || funcname || hash || result7 || libp) ;
13945 }
13946
13947 static int G__BankClassesDict_274_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13948 G__letint(result7,67,(long)XTEB::DeclFileName());
13949 return(1 || funcname || hash || result7 || libp) ;
13950 }
13951
13952 static int G__BankClassesDict_274_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13953 G__letint(result7,105,(long)XTEB::ImplFileLine());
13954 return(1 || funcname || hash || result7 || libp) ;
13955 }
13956
13957 static int G__BankClassesDict_274_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13958 G__letint(result7,67,(long)XTEB::ImplFileName());
13959 return(1 || funcname || hash || result7 || libp) ;
13960 }
13961
13962 static int G__BankClassesDict_274_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13963 G__letint(result7,105,(long)XTEB::DeclFileLine());
13964 return(1 || funcname || hash || result7 || libp) ;
13965 }
13966
13967
13968 static int G__BankClassesDict_274_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
13969 {
13970 XTEB *p;
13971 p=new XTEB(*(XTEB*)G__int(libp->para[0]));
13972 result7->obj.i = (long)p;
13973 result7->ref = (long)p;
13974 result7->type = 'u';
13975 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTEB);
13976 return(1 || funcname || hash || result7 || libp) ;
13977 }
13978
13979
13980 typedef XTEB G__TXTEB;
13981 static int G__BankClassesDict_274_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13982 if(0==G__getstructoffset()) return(1);
13983 if(G__getaryconstruct())
13984 if(G__PVOID==G__getgvp())
13985 delete[] (XTEB *)(G__getstructoffset());
13986 else
13987 for(int i=G__getaryconstruct()-1;i>=0;i--)
13988 delete (XTEB *)((G__getstructoffset())+sizeof(XTEB)*i);
13989 else delete (XTEB *)(G__getstructoffset());
13990 G__setnull(result7);
13991 return(1 || funcname || hash || result7 || libp) ;
13992 }
13993
13994
13995
13996 static int G__BankClassesDict_275_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
13997 XTRB *p=NULL;
13998 if(G__getaryconstruct()) p=new XTRB[G__getaryconstruct()];
13999 else p=new XTRB;
14000 result7->obj.i = (long)p;
14001 result7->ref = (long)p;
14002 result7->type = 'u';
14003 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTRB);
14004 return(1 || funcname || hash || result7 || libp) ;
14005 }
14006
14007 static int G__BankClassesDict_275_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14008 G__setnull(result7);
14009 ((XTRB*)(G__getstructoffset()))->Assign((XTRB_PATTERN*)G__int(libp->para[0]));
14010 return(1 || funcname || hash || result7 || libp) ;
14011 }
14012
14013 static int G__BankClassesDict_275_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14014 G__letint(result7,85,(long)XTRB::Class());
14015 return(1 || funcname || hash || result7 || libp) ;
14016 }
14017
14018 static int G__BankClassesDict_275_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14019 G__letint(result7,67,(long)XTRB::Class_Name());
14020 return(1 || funcname || hash || result7 || libp) ;
14021 }
14022
14023 static int G__BankClassesDict_275_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14024 G__letint(result7,115,(long)XTRB::Class_Version());
14025 return(1 || funcname || hash || result7 || libp) ;
14026 }
14027
14028 static int G__BankClassesDict_275_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14029 G__setnull(result7);
14030 XTRB::Dictionary();
14031 return(1 || funcname || hash || result7 || libp) ;
14032 }
14033
14034 static int G__BankClassesDict_275_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14035 G__letint(result7,85,(long)((const XTRB*)(G__getstructoffset()))->IsA());
14036 return(1 || funcname || hash || result7 || libp) ;
14037 }
14038
14039 static int G__BankClassesDict_275_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14040 G__setnull(result7);
14041 ((XTRB*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14042 return(1 || funcname || hash || result7 || libp) ;
14043 }
14044
14045 static int G__BankClassesDict_275_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14046 G__setnull(result7);
14047 ((XTRB*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14048 return(1 || funcname || hash || result7 || libp) ;
14049 }
14050
14051 static int G__BankClassesDict_275_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14052 G__setnull(result7);
14053 ((XTRB*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14054 return(1 || funcname || hash || result7 || libp) ;
14055 }
14056
14057 static int G__BankClassesDict_275_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14058 G__letint(result7,67,(long)XTRB::DeclFileName());
14059 return(1 || funcname || hash || result7 || libp) ;
14060 }
14061
14062 static int G__BankClassesDict_275_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14063 G__letint(result7,105,(long)XTRB::ImplFileLine());
14064 return(1 || funcname || hash || result7 || libp) ;
14065 }
14066
14067 static int G__BankClassesDict_275_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14068 G__letint(result7,67,(long)XTRB::ImplFileName());
14069 return(1 || funcname || hash || result7 || libp) ;
14070 }
14071
14072 static int G__BankClassesDict_275_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14073 G__letint(result7,105,(long)XTRB::DeclFileLine());
14074 return(1 || funcname || hash || result7 || libp) ;
14075 }
14076
14077
14078 static int G__BankClassesDict_275_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14079 {
14080 XTRB *p;
14081 p=new XTRB(*(XTRB*)G__int(libp->para[0]));
14082 result7->obj.i = (long)p;
14083 result7->ref = (long)p;
14084 result7->type = 'u';
14085 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_XTRB);
14086 return(1 || funcname || hash || result7 || libp) ;
14087 }
14088
14089
14090 typedef XTRB G__TXTRB;
14091 static int G__BankClassesDict_275_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14092 if(0==G__getstructoffset()) return(1);
14093 if(G__getaryconstruct())
14094 if(G__PVOID==G__getgvp())
14095 delete[] (XTRB *)(G__getstructoffset());
14096 else
14097 for(int i=G__getaryconstruct()-1;i>=0;i--)
14098 delete (XTRB *)((G__getstructoffset())+sizeof(XTRB)*i);
14099 else delete (XTRB *)(G__getstructoffset());
14100 G__setnull(result7);
14101 return(1 || funcname || hash || result7 || libp) ;
14102 }
14103
14104
14105
14106 static int G__BankClassesDict_276_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14107 DTBP *p=NULL;
14108 if(G__getaryconstruct()) p=new DTBP[G__getaryconstruct()];
14109 else p=new DTBP;
14110 result7->obj.i = (long)p;
14111 result7->ref = (long)p;
14112 result7->type = 'u';
14113 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_DTBP);
14114 return(1 || funcname || hash || result7 || libp) ;
14115 }
14116
14117 static int G__BankClassesDict_276_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14118 G__setnull(result7);
14119 ((DTBP*)(G__getstructoffset()))->Assign((DTBP_PATTERN*)G__int(libp->para[0]));
14120 return(1 || funcname || hash || result7 || libp) ;
14121 }
14122
14123 static int G__BankClassesDict_276_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14124 G__letint(result7,85,(long)DTBP::Class());
14125 return(1 || funcname || hash || result7 || libp) ;
14126 }
14127
14128 static int G__BankClassesDict_276_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14129 G__letint(result7,67,(long)DTBP::Class_Name());
14130 return(1 || funcname || hash || result7 || libp) ;
14131 }
14132
14133 static int G__BankClassesDict_276_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14134 G__letint(result7,115,(long)DTBP::Class_Version());
14135 return(1 || funcname || hash || result7 || libp) ;
14136 }
14137
14138 static int G__BankClassesDict_276_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14139 G__setnull(result7);
14140 DTBP::Dictionary();
14141 return(1 || funcname || hash || result7 || libp) ;
14142 }
14143
14144 static int G__BankClassesDict_276_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14145 G__letint(result7,85,(long)((const DTBP*)(G__getstructoffset()))->IsA());
14146 return(1 || funcname || hash || result7 || libp) ;
14147 }
14148
14149 static int G__BankClassesDict_276_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14150 G__setnull(result7);
14151 ((DTBP*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14152 return(1 || funcname || hash || result7 || libp) ;
14153 }
14154
14155 static int G__BankClassesDict_276_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14156 G__setnull(result7);
14157 ((DTBP*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14158 return(1 || funcname || hash || result7 || libp) ;
14159 }
14160
14161 static int G__BankClassesDict_276_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14162 G__setnull(result7);
14163 ((DTBP*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14164 return(1 || funcname || hash || result7 || libp) ;
14165 }
14166
14167 static int G__BankClassesDict_276_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14168 G__letint(result7,67,(long)DTBP::DeclFileName());
14169 return(1 || funcname || hash || result7 || libp) ;
14170 }
14171
14172 static int G__BankClassesDict_276_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14173 G__letint(result7,105,(long)DTBP::ImplFileLine());
14174 return(1 || funcname || hash || result7 || libp) ;
14175 }
14176
14177 static int G__BankClassesDict_276_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14178 G__letint(result7,67,(long)DTBP::ImplFileName());
14179 return(1 || funcname || hash || result7 || libp) ;
14180 }
14181
14182 static int G__BankClassesDict_276_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14183 G__letint(result7,105,(long)DTBP::DeclFileLine());
14184 return(1 || funcname || hash || result7 || libp) ;
14185 }
14186
14187
14188 static int G__BankClassesDict_276_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14189 {
14190 DTBP *p;
14191 p=new DTBP(*(DTBP*)G__int(libp->para[0]));
14192 result7->obj.i = (long)p;
14193 result7->ref = (long)p;
14194 result7->type = 'u';
14195 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_DTBP);
14196 return(1 || funcname || hash || result7 || libp) ;
14197 }
14198
14199
14200 typedef DTBP G__TDTBP;
14201 static int G__BankClassesDict_276_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14202 if(0==G__getstructoffset()) return(1);
14203 if(G__getaryconstruct())
14204 if(G__PVOID==G__getgvp())
14205 delete[] (DTBP *)(G__getstructoffset());
14206 else
14207 for(int i=G__getaryconstruct()-1;i>=0;i--)
14208 delete (DTBP *)((G__getstructoffset())+sizeof(DTBP)*i);
14209 else delete (DTBP *)(G__getstructoffset());
14210 G__setnull(result7);
14211 return(1 || funcname || hash || result7 || libp) ;
14212 }
14213
14214
14215
14216 static int G__BankClassesDict_277_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14217 VHBV *p=NULL;
14218 if(G__getaryconstruct()) p=new VHBV[G__getaryconstruct()];
14219 else p=new VHBV;
14220 result7->obj.i = (long)p;
14221 result7->ref = (long)p;
14222 result7->type = 'u';
14223 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_VHBV);
14224 return(1 || funcname || hash || result7 || libp) ;
14225 }
14226
14227 static int G__BankClassesDict_277_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14228 G__setnull(result7);
14229 ((VHBV*)(G__getstructoffset()))->Assign((VHBV_PATTERN*)G__int(libp->para[0]));
14230 return(1 || funcname || hash || result7 || libp) ;
14231 }
14232
14233 static int G__BankClassesDict_277_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14234 G__letint(result7,85,(long)VHBV::Class());
14235 return(1 || funcname || hash || result7 || libp) ;
14236 }
14237
14238 static int G__BankClassesDict_277_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14239 G__letint(result7,67,(long)VHBV::Class_Name());
14240 return(1 || funcname || hash || result7 || libp) ;
14241 }
14242
14243 static int G__BankClassesDict_277_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14244 G__letint(result7,115,(long)VHBV::Class_Version());
14245 return(1 || funcname || hash || result7 || libp) ;
14246 }
14247
14248 static int G__BankClassesDict_277_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14249 G__setnull(result7);
14250 VHBV::Dictionary();
14251 return(1 || funcname || hash || result7 || libp) ;
14252 }
14253
14254 static int G__BankClassesDict_277_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14255 G__letint(result7,85,(long)((const VHBV*)(G__getstructoffset()))->IsA());
14256 return(1 || funcname || hash || result7 || libp) ;
14257 }
14258
14259 static int G__BankClassesDict_277_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14260 G__setnull(result7);
14261 ((VHBV*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14262 return(1 || funcname || hash || result7 || libp) ;
14263 }
14264
14265 static int G__BankClassesDict_277_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14266 G__setnull(result7);
14267 ((VHBV*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14268 return(1 || funcname || hash || result7 || libp) ;
14269 }
14270
14271 static int G__BankClassesDict_277_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14272 G__setnull(result7);
14273 ((VHBV*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14274 return(1 || funcname || hash || result7 || libp) ;
14275 }
14276
14277 static int G__BankClassesDict_277_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14278 G__letint(result7,67,(long)VHBV::DeclFileName());
14279 return(1 || funcname || hash || result7 || libp) ;
14280 }
14281
14282 static int G__BankClassesDict_277_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14283 G__letint(result7,105,(long)VHBV::ImplFileLine());
14284 return(1 || funcname || hash || result7 || libp) ;
14285 }
14286
14287 static int G__BankClassesDict_277_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14288 G__letint(result7,67,(long)VHBV::ImplFileName());
14289 return(1 || funcname || hash || result7 || libp) ;
14290 }
14291
14292 static int G__BankClassesDict_277_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14293 G__letint(result7,105,(long)VHBV::DeclFileLine());
14294 return(1 || funcname || hash || result7 || libp) ;
14295 }
14296
14297
14298 static int G__BankClassesDict_277_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14299 {
14300 VHBV *p;
14301 p=new VHBV(*(VHBV*)G__int(libp->para[0]));
14302 result7->obj.i = (long)p;
14303 result7->ref = (long)p;
14304 result7->type = 'u';
14305 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_VHBV);
14306 return(1 || funcname || hash || result7 || libp) ;
14307 }
14308
14309
14310 typedef VHBV G__TVHBV;
14311 static int G__BankClassesDict_277_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14312 if(0==G__getstructoffset()) return(1);
14313 if(G__getaryconstruct())
14314 if(G__PVOID==G__getgvp())
14315 delete[] (VHBV *)(G__getstructoffset());
14316 else
14317 for(int i=G__getaryconstruct()-1;i>=0;i--)
14318 delete (VHBV *)((G__getstructoffset())+sizeof(VHBV)*i);
14319 else delete (VHBV *)(G__getstructoffset());
14320 G__setnull(result7);
14321 return(1 || funcname || hash || result7 || libp) ;
14322 }
14323
14324
14325
14326 static int G__BankClassesDict_278_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14327 VHPV *p=NULL;
14328 if(G__getaryconstruct()) p=new VHPV[G__getaryconstruct()];
14329 else p=new VHPV;
14330 result7->obj.i = (long)p;
14331 result7->ref = (long)p;
14332 result7->type = 'u';
14333 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_VHPV);
14334 return(1 || funcname || hash || result7 || libp) ;
14335 }
14336
14337 static int G__BankClassesDict_278_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14338 G__setnull(result7);
14339 ((VHPV*)(G__getstructoffset()))->Assign((VHPV_PATTERN*)G__int(libp->para[0]));
14340 return(1 || funcname || hash || result7 || libp) ;
14341 }
14342
14343 static int G__BankClassesDict_278_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14344 G__letint(result7,85,(long)VHPV::Class());
14345 return(1 || funcname || hash || result7 || libp) ;
14346 }
14347
14348 static int G__BankClassesDict_278_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14349 G__letint(result7,67,(long)VHPV::Class_Name());
14350 return(1 || funcname || hash || result7 || libp) ;
14351 }
14352
14353 static int G__BankClassesDict_278_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14354 G__letint(result7,115,(long)VHPV::Class_Version());
14355 return(1 || funcname || hash || result7 || libp) ;
14356 }
14357
14358 static int G__BankClassesDict_278_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14359 G__setnull(result7);
14360 VHPV::Dictionary();
14361 return(1 || funcname || hash || result7 || libp) ;
14362 }
14363
14364 static int G__BankClassesDict_278_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14365 G__letint(result7,85,(long)((const VHPV*)(G__getstructoffset()))->IsA());
14366 return(1 || funcname || hash || result7 || libp) ;
14367 }
14368
14369 static int G__BankClassesDict_278_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14370 G__setnull(result7);
14371 ((VHPV*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14372 return(1 || funcname || hash || result7 || libp) ;
14373 }
14374
14375 static int G__BankClassesDict_278_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14376 G__setnull(result7);
14377 ((VHPV*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14378 return(1 || funcname || hash || result7 || libp) ;
14379 }
14380
14381 static int G__BankClassesDict_278_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14382 G__setnull(result7);
14383 ((VHPV*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14384 return(1 || funcname || hash || result7 || libp) ;
14385 }
14386
14387 static int G__BankClassesDict_278_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14388 G__letint(result7,67,(long)VHPV::DeclFileName());
14389 return(1 || funcname || hash || result7 || libp) ;
14390 }
14391
14392 static int G__BankClassesDict_278_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14393 G__letint(result7,105,(long)VHPV::ImplFileLine());
14394 return(1 || funcname || hash || result7 || libp) ;
14395 }
14396
14397 static int G__BankClassesDict_278_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14398 G__letint(result7,67,(long)VHPV::ImplFileName());
14399 return(1 || funcname || hash || result7 || libp) ;
14400 }
14401
14402 static int G__BankClassesDict_278_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14403 G__letint(result7,105,(long)VHPV::DeclFileLine());
14404 return(1 || funcname || hash || result7 || libp) ;
14405 }
14406
14407
14408 static int G__BankClassesDict_278_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14409 {
14410 VHPV *p;
14411 p=new VHPV(*(VHPV*)G__int(libp->para[0]));
14412 result7->obj.i = (long)p;
14413 result7->ref = (long)p;
14414 result7->type = 'u';
14415 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_VHPV);
14416 return(1 || funcname || hash || result7 || libp) ;
14417 }
14418
14419
14420 typedef VHPV G__TVHPV;
14421 static int G__BankClassesDict_278_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14422 if(0==G__getstructoffset()) return(1);
14423 if(G__getaryconstruct())
14424 if(G__PVOID==G__getgvp())
14425 delete[] (VHPV *)(G__getstructoffset());
14426 else
14427 for(int i=G__getaryconstruct()-1;i>=0;i--)
14428 delete (VHPV *)((G__getstructoffset())+sizeof(VHPV)*i);
14429 else delete (VHPV *)(G__getstructoffset());
14430 G__setnull(result7);
14431 return(1 || funcname || hash || result7 || libp) ;
14432 }
14433
14434
14435
14436 static int G__BankClassesDict_279_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14437 EAUX *p=NULL;
14438 if(G__getaryconstruct()) p=new EAUX[G__getaryconstruct()];
14439 else p=new EAUX;
14440 result7->obj.i = (long)p;
14441 result7->ref = (long)p;
14442 result7->type = 'u';
14443 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EAUX);
14444 return(1 || funcname || hash || result7 || libp) ;
14445 }
14446
14447 static int G__BankClassesDict_279_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14448 G__setnull(result7);
14449 ((EAUX*)(G__getstructoffset()))->Assign((EAUX_PATTERN*)G__int(libp->para[0]));
14450 return(1 || funcname || hash || result7 || libp) ;
14451 }
14452
14453 static int G__BankClassesDict_279_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14454 G__letint(result7,85,(long)EAUX::Class());
14455 return(1 || funcname || hash || result7 || libp) ;
14456 }
14457
14458 static int G__BankClassesDict_279_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14459 G__letint(result7,67,(long)EAUX::Class_Name());
14460 return(1 || funcname || hash || result7 || libp) ;
14461 }
14462
14463 static int G__BankClassesDict_279_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14464 G__letint(result7,115,(long)EAUX::Class_Version());
14465 return(1 || funcname || hash || result7 || libp) ;
14466 }
14467
14468 static int G__BankClassesDict_279_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14469 G__setnull(result7);
14470 EAUX::Dictionary();
14471 return(1 || funcname || hash || result7 || libp) ;
14472 }
14473
14474 static int G__BankClassesDict_279_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14475 G__letint(result7,85,(long)((const EAUX*)(G__getstructoffset()))->IsA());
14476 return(1 || funcname || hash || result7 || libp) ;
14477 }
14478
14479 static int G__BankClassesDict_279_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14480 G__setnull(result7);
14481 ((EAUX*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14482 return(1 || funcname || hash || result7 || libp) ;
14483 }
14484
14485 static int G__BankClassesDict_279_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14486 G__setnull(result7);
14487 ((EAUX*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14488 return(1 || funcname || hash || result7 || libp) ;
14489 }
14490
14491 static int G__BankClassesDict_279_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14492 G__setnull(result7);
14493 ((EAUX*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14494 return(1 || funcname || hash || result7 || libp) ;
14495 }
14496
14497 static int G__BankClassesDict_279_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14498 G__letint(result7,67,(long)EAUX::DeclFileName());
14499 return(1 || funcname || hash || result7 || libp) ;
14500 }
14501
14502 static int G__BankClassesDict_279_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14503 G__letint(result7,105,(long)EAUX::ImplFileLine());
14504 return(1 || funcname || hash || result7 || libp) ;
14505 }
14506
14507 static int G__BankClassesDict_279_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14508 G__letint(result7,67,(long)EAUX::ImplFileName());
14509 return(1 || funcname || hash || result7 || libp) ;
14510 }
14511
14512 static int G__BankClassesDict_279_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14513 G__letint(result7,105,(long)EAUX::DeclFileLine());
14514 return(1 || funcname || hash || result7 || libp) ;
14515 }
14516
14517
14518 static int G__BankClassesDict_279_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14519 {
14520 EAUX *p;
14521 p=new EAUX(*(EAUX*)G__int(libp->para[0]));
14522 result7->obj.i = (long)p;
14523 result7->ref = (long)p;
14524 result7->type = 'u';
14525 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_EAUX);
14526 return(1 || funcname || hash || result7 || libp) ;
14527 }
14528
14529
14530 typedef EAUX G__TEAUX;
14531 static int G__BankClassesDict_279_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14532 if(0==G__getstructoffset()) return(1);
14533 if(G__getaryconstruct())
14534 if(G__PVOID==G__getgvp())
14535 delete[] (EAUX *)(G__getstructoffset());
14536 else
14537 for(int i=G__getaryconstruct()-1;i>=0;i--)
14538 delete (EAUX *)((G__getstructoffset())+sizeof(EAUX)*i);
14539 else delete (EAUX *)(G__getstructoffset());
14540 G__setnull(result7);
14541 return(1 || funcname || hash || result7 || libp) ;
14542 }
14543
14544
14545
14546 static int G__BankClassesDict_280_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14547 SIX2 *p=NULL;
14548 if(G__getaryconstruct()) p=new SIX2[G__getaryconstruct()];
14549 else p=new SIX2;
14550 result7->obj.i = (long)p;
14551 result7->ref = (long)p;
14552 result7->type = 'u';
14553 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SIX2);
14554 return(1 || funcname || hash || result7 || libp) ;
14555 }
14556
14557 static int G__BankClassesDict_280_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14558 G__setnull(result7);
14559 ((SIX2*)(G__getstructoffset()))->Assign((SIX2_PATTERN*)G__int(libp->para[0]));
14560 return(1 || funcname || hash || result7 || libp) ;
14561 }
14562
14563 static int G__BankClassesDict_280_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14564 G__letint(result7,85,(long)SIX2::Class());
14565 return(1 || funcname || hash || result7 || libp) ;
14566 }
14567
14568 static int G__BankClassesDict_280_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14569 G__letint(result7,67,(long)SIX2::Class_Name());
14570 return(1 || funcname || hash || result7 || libp) ;
14571 }
14572
14573 static int G__BankClassesDict_280_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14574 G__letint(result7,115,(long)SIX2::Class_Version());
14575 return(1 || funcname || hash || result7 || libp) ;
14576 }
14577
14578 static int G__BankClassesDict_280_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14579 G__setnull(result7);
14580 SIX2::Dictionary();
14581 return(1 || funcname || hash || result7 || libp) ;
14582 }
14583
14584 static int G__BankClassesDict_280_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14585 G__letint(result7,85,(long)((const SIX2*)(G__getstructoffset()))->IsA());
14586 return(1 || funcname || hash || result7 || libp) ;
14587 }
14588
14589 static int G__BankClassesDict_280_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14590 G__setnull(result7);
14591 ((SIX2*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14592 return(1 || funcname || hash || result7 || libp) ;
14593 }
14594
14595 static int G__BankClassesDict_280_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14596 G__setnull(result7);
14597 ((SIX2*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14598 return(1 || funcname || hash || result7 || libp) ;
14599 }
14600
14601 static int G__BankClassesDict_280_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14602 G__setnull(result7);
14603 ((SIX2*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14604 return(1 || funcname || hash || result7 || libp) ;
14605 }
14606
14607 static int G__BankClassesDict_280_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14608 G__letint(result7,67,(long)SIX2::DeclFileName());
14609 return(1 || funcname || hash || result7 || libp) ;
14610 }
14611
14612 static int G__BankClassesDict_280_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14613 G__letint(result7,105,(long)SIX2::ImplFileLine());
14614 return(1 || funcname || hash || result7 || libp) ;
14615 }
14616
14617 static int G__BankClassesDict_280_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14618 G__letint(result7,67,(long)SIX2::ImplFileName());
14619 return(1 || funcname || hash || result7 || libp) ;
14620 }
14621
14622 static int G__BankClassesDict_280_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14623 G__letint(result7,105,(long)SIX2::DeclFileLine());
14624 return(1 || funcname || hash || result7 || libp) ;
14625 }
14626
14627
14628 static int G__BankClassesDict_280_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14629 {
14630 SIX2 *p;
14631 p=new SIX2(*(SIX2*)G__int(libp->para[0]));
14632 result7->obj.i = (long)p;
14633 result7->ref = (long)p;
14634 result7->type = 'u';
14635 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SIX2);
14636 return(1 || funcname || hash || result7 || libp) ;
14637 }
14638
14639
14640 typedef SIX2 G__TSIX2;
14641 static int G__BankClassesDict_280_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14642 if(0==G__getstructoffset()) return(1);
14643 if(G__getaryconstruct())
14644 if(G__PVOID==G__getgvp())
14645 delete[] (SIX2 *)(G__getstructoffset());
14646 else
14647 for(int i=G__getaryconstruct()-1;i>=0;i--)
14648 delete (SIX2 *)((G__getstructoffset())+sizeof(SIX2)*i);
14649 else delete (SIX2 *)(G__getstructoffset());
14650 G__setnull(result7);
14651 return(1 || funcname || hash || result7 || libp) ;
14652 }
14653
14654
14655
14656 static int G__BankClassesDict_281_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14657 X1TV *p=NULL;
14658 if(G__getaryconstruct()) p=new X1TV[G__getaryconstruct()];
14659 else p=new X1TV;
14660 result7->obj.i = (long)p;
14661 result7->ref = (long)p;
14662 result7->type = 'u';
14663 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1TV);
14664 return(1 || funcname || hash || result7 || libp) ;
14665 }
14666
14667 static int G__BankClassesDict_281_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14668 G__setnull(result7);
14669 ((X1TV*)(G__getstructoffset()))->Assign((X1TV_PATTERN*)G__int(libp->para[0]));
14670 return(1 || funcname || hash || result7 || libp) ;
14671 }
14672
14673 static int G__BankClassesDict_281_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14674 G__letint(result7,85,(long)X1TV::Class());
14675 return(1 || funcname || hash || result7 || libp) ;
14676 }
14677
14678 static int G__BankClassesDict_281_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14679 G__letint(result7,67,(long)X1TV::Class_Name());
14680 return(1 || funcname || hash || result7 || libp) ;
14681 }
14682
14683 static int G__BankClassesDict_281_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14684 G__letint(result7,115,(long)X1TV::Class_Version());
14685 return(1 || funcname || hash || result7 || libp) ;
14686 }
14687
14688 static int G__BankClassesDict_281_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14689 G__setnull(result7);
14690 X1TV::Dictionary();
14691 return(1 || funcname || hash || result7 || libp) ;
14692 }
14693
14694 static int G__BankClassesDict_281_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14695 G__letint(result7,85,(long)((const X1TV*)(G__getstructoffset()))->IsA());
14696 return(1 || funcname || hash || result7 || libp) ;
14697 }
14698
14699 static int G__BankClassesDict_281_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14700 G__setnull(result7);
14701 ((X1TV*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14702 return(1 || funcname || hash || result7 || libp) ;
14703 }
14704
14705 static int G__BankClassesDict_281_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14706 G__setnull(result7);
14707 ((X1TV*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14708 return(1 || funcname || hash || result7 || libp) ;
14709 }
14710
14711 static int G__BankClassesDict_281_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14712 G__setnull(result7);
14713 ((X1TV*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14714 return(1 || funcname || hash || result7 || libp) ;
14715 }
14716
14717 static int G__BankClassesDict_281_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14718 G__letint(result7,67,(long)X1TV::DeclFileName());
14719 return(1 || funcname || hash || result7 || libp) ;
14720 }
14721
14722 static int G__BankClassesDict_281_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14723 G__letint(result7,105,(long)X1TV::ImplFileLine());
14724 return(1 || funcname || hash || result7 || libp) ;
14725 }
14726
14727 static int G__BankClassesDict_281_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14728 G__letint(result7,67,(long)X1TV::ImplFileName());
14729 return(1 || funcname || hash || result7 || libp) ;
14730 }
14731
14732 static int G__BankClassesDict_281_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14733 G__letint(result7,105,(long)X1TV::DeclFileLine());
14734 return(1 || funcname || hash || result7 || libp) ;
14735 }
14736
14737
14738 static int G__BankClassesDict_281_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14739 {
14740 X1TV *p;
14741 p=new X1TV(*(X1TV*)G__int(libp->para[0]));
14742 result7->obj.i = (long)p;
14743 result7->ref = (long)p;
14744 result7->type = 'u';
14745 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1TV);
14746 return(1 || funcname || hash || result7 || libp) ;
14747 }
14748
14749
14750 typedef X1TV G__TX1TV;
14751 static int G__BankClassesDict_281_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14752 if(0==G__getstructoffset()) return(1);
14753 if(G__getaryconstruct())
14754 if(G__PVOID==G__getgvp())
14755 delete[] (X1TV *)(G__getstructoffset());
14756 else
14757 for(int i=G__getaryconstruct()-1;i>=0;i--)
14758 delete (X1TV *)((G__getstructoffset())+sizeof(X1TV)*i);
14759 else delete (X1TV *)(G__getstructoffset());
14760 G__setnull(result7);
14761 return(1 || funcname || hash || result7 || libp) ;
14762 }
14763
14764
14765
14766 static int G__BankClassesDict_282_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14767 KWGT *p=NULL;
14768 if(G__getaryconstruct()) p=new KWGT[G__getaryconstruct()];
14769 else p=new KWGT;
14770 result7->obj.i = (long)p;
14771 result7->ref = (long)p;
14772 result7->type = 'u';
14773 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_KWGT);
14774 return(1 || funcname || hash || result7 || libp) ;
14775 }
14776
14777 static int G__BankClassesDict_282_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14778 G__setnull(result7);
14779 ((KWGT*)(G__getstructoffset()))->Assign((KWGT_PATTERN*)G__int(libp->para[0]));
14780 return(1 || funcname || hash || result7 || libp) ;
14781 }
14782
14783 static int G__BankClassesDict_282_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14784 G__letint(result7,85,(long)KWGT::Class());
14785 return(1 || funcname || hash || result7 || libp) ;
14786 }
14787
14788 static int G__BankClassesDict_282_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14789 G__letint(result7,67,(long)KWGT::Class_Name());
14790 return(1 || funcname || hash || result7 || libp) ;
14791 }
14792
14793 static int G__BankClassesDict_282_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14794 G__letint(result7,115,(long)KWGT::Class_Version());
14795 return(1 || funcname || hash || result7 || libp) ;
14796 }
14797
14798 static int G__BankClassesDict_282_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14799 G__setnull(result7);
14800 KWGT::Dictionary();
14801 return(1 || funcname || hash || result7 || libp) ;
14802 }
14803
14804 static int G__BankClassesDict_282_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14805 G__letint(result7,85,(long)((const KWGT*)(G__getstructoffset()))->IsA());
14806 return(1 || funcname || hash || result7 || libp) ;
14807 }
14808
14809 static int G__BankClassesDict_282_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14810 G__setnull(result7);
14811 ((KWGT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14812 return(1 || funcname || hash || result7 || libp) ;
14813 }
14814
14815 static int G__BankClassesDict_282_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14816 G__setnull(result7);
14817 ((KWGT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14818 return(1 || funcname || hash || result7 || libp) ;
14819 }
14820
14821 static int G__BankClassesDict_282_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14822 G__setnull(result7);
14823 ((KWGT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14824 return(1 || funcname || hash || result7 || libp) ;
14825 }
14826
14827 static int G__BankClassesDict_282_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14828 G__letint(result7,67,(long)KWGT::DeclFileName());
14829 return(1 || funcname || hash || result7 || libp) ;
14830 }
14831
14832 static int G__BankClassesDict_282_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14833 G__letint(result7,105,(long)KWGT::ImplFileLine());
14834 return(1 || funcname || hash || result7 || libp) ;
14835 }
14836
14837 static int G__BankClassesDict_282_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14838 G__letint(result7,67,(long)KWGT::ImplFileName());
14839 return(1 || funcname || hash || result7 || libp) ;
14840 }
14841
14842 static int G__BankClassesDict_282_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14843 G__letint(result7,105,(long)KWGT::DeclFileLine());
14844 return(1 || funcname || hash || result7 || libp) ;
14845 }
14846
14847
14848 static int G__BankClassesDict_282_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14849 {
14850 KWGT *p;
14851 p=new KWGT(*(KWGT*)G__int(libp->para[0]));
14852 result7->obj.i = (long)p;
14853 result7->ref = (long)p;
14854 result7->type = 'u';
14855 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_KWGT);
14856 return(1 || funcname || hash || result7 || libp) ;
14857 }
14858
14859
14860 typedef KWGT G__TKWGT;
14861 static int G__BankClassesDict_282_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14862 if(0==G__getstructoffset()) return(1);
14863 if(G__getaryconstruct())
14864 if(G__PVOID==G__getgvp())
14865 delete[] (KWGT *)(G__getstructoffset());
14866 else
14867 for(int i=G__getaryconstruct()-1;i>=0;i--)
14868 delete (KWGT *)((G__getstructoffset())+sizeof(KWGT)*i);
14869 else delete (KWGT *)(G__getstructoffset());
14870 G__setnull(result7);
14871 return(1 || funcname || hash || result7 || libp) ;
14872 }
14873
14874
14875
14876 static int G__BankClassesDict_283_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14877 X1IP *p=NULL;
14878 if(G__getaryconstruct()) p=new X1IP[G__getaryconstruct()];
14879 else p=new X1IP;
14880 result7->obj.i = (long)p;
14881 result7->ref = (long)p;
14882 result7->type = 'u';
14883 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1IP);
14884 return(1 || funcname || hash || result7 || libp) ;
14885 }
14886
14887 static int G__BankClassesDict_283_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14888 G__setnull(result7);
14889 ((X1IP*)(G__getstructoffset()))->Assign((X1IP_PATTERN*)G__int(libp->para[0]));
14890 return(1 || funcname || hash || result7 || libp) ;
14891 }
14892
14893 static int G__BankClassesDict_283_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14894 G__letint(result7,85,(long)X1IP::Class());
14895 return(1 || funcname || hash || result7 || libp) ;
14896 }
14897
14898 static int G__BankClassesDict_283_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14899 G__letint(result7,67,(long)X1IP::Class_Name());
14900 return(1 || funcname || hash || result7 || libp) ;
14901 }
14902
14903 static int G__BankClassesDict_283_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14904 G__letint(result7,115,(long)X1IP::Class_Version());
14905 return(1 || funcname || hash || result7 || libp) ;
14906 }
14907
14908 static int G__BankClassesDict_283_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14909 G__setnull(result7);
14910 X1IP::Dictionary();
14911 return(1 || funcname || hash || result7 || libp) ;
14912 }
14913
14914 static int G__BankClassesDict_283_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14915 G__letint(result7,85,(long)((const X1IP*)(G__getstructoffset()))->IsA());
14916 return(1 || funcname || hash || result7 || libp) ;
14917 }
14918
14919 static int G__BankClassesDict_283_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14920 G__setnull(result7);
14921 ((X1IP*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
14922 return(1 || funcname || hash || result7 || libp) ;
14923 }
14924
14925 static int G__BankClassesDict_283_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14926 G__setnull(result7);
14927 ((X1IP*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
14928 return(1 || funcname || hash || result7 || libp) ;
14929 }
14930
14931 static int G__BankClassesDict_283_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14932 G__setnull(result7);
14933 ((X1IP*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
14934 return(1 || funcname || hash || result7 || libp) ;
14935 }
14936
14937 static int G__BankClassesDict_283_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14938 G__letint(result7,67,(long)X1IP::DeclFileName());
14939 return(1 || funcname || hash || result7 || libp) ;
14940 }
14941
14942 static int G__BankClassesDict_283_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14943 G__letint(result7,105,(long)X1IP::ImplFileLine());
14944 return(1 || funcname || hash || result7 || libp) ;
14945 }
14946
14947 static int G__BankClassesDict_283_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14948 G__letint(result7,67,(long)X1IP::ImplFileName());
14949 return(1 || funcname || hash || result7 || libp) ;
14950 }
14951
14952 static int G__BankClassesDict_283_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14953 G__letint(result7,105,(long)X1IP::DeclFileLine());
14954 return(1 || funcname || hash || result7 || libp) ;
14955 }
14956
14957
14958 static int G__BankClassesDict_283_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
14959 {
14960 X1IP *p;
14961 p=new X1IP(*(X1IP*)G__int(libp->para[0]));
14962 result7->obj.i = (long)p;
14963 result7->ref = (long)p;
14964 result7->type = 'u';
14965 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1IP);
14966 return(1 || funcname || hash || result7 || libp) ;
14967 }
14968
14969
14970 typedef X1IP G__TX1IP;
14971 static int G__BankClassesDict_283_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14972 if(0==G__getstructoffset()) return(1);
14973 if(G__getaryconstruct())
14974 if(G__PVOID==G__getgvp())
14975 delete[] (X1IP *)(G__getstructoffset());
14976 else
14977 for(int i=G__getaryconstruct()-1;i>=0;i--)
14978 delete (X1IP *)((G__getstructoffset())+sizeof(X1IP)*i);
14979 else delete (X1IP *)(G__getstructoffset());
14980 G__setnull(result7);
14981 return(1 || funcname || hash || result7 || libp) ;
14982 }
14983
14984
14985
14986 static int G__BankClassesDict_284_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14987 SIXA *p=NULL;
14988 if(G__getaryconstruct()) p=new SIXA[G__getaryconstruct()];
14989 else p=new SIXA;
14990 result7->obj.i = (long)p;
14991 result7->ref = (long)p;
14992 result7->type = 'u';
14993 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SIXA);
14994 return(1 || funcname || hash || result7 || libp) ;
14995 }
14996
14997 static int G__BankClassesDict_284_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
14998 G__setnull(result7);
14999 ((SIXA*)(G__getstructoffset()))->Assign((SIXA_PATTERN*)G__int(libp->para[0]));
15000 return(1 || funcname || hash || result7 || libp) ;
15001 }
15002
15003 static int G__BankClassesDict_284_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15004 G__letint(result7,85,(long)SIXA::Class());
15005 return(1 || funcname || hash || result7 || libp) ;
15006 }
15007
15008 static int G__BankClassesDict_284_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15009 G__letint(result7,67,(long)SIXA::Class_Name());
15010 return(1 || funcname || hash || result7 || libp) ;
15011 }
15012
15013 static int G__BankClassesDict_284_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15014 G__letint(result7,115,(long)SIXA::Class_Version());
15015 return(1 || funcname || hash || result7 || libp) ;
15016 }
15017
15018 static int G__BankClassesDict_284_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15019 G__setnull(result7);
15020 SIXA::Dictionary();
15021 return(1 || funcname || hash || result7 || libp) ;
15022 }
15023
15024 static int G__BankClassesDict_284_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15025 G__letint(result7,85,(long)((const SIXA*)(G__getstructoffset()))->IsA());
15026 return(1 || funcname || hash || result7 || libp) ;
15027 }
15028
15029 static int G__BankClassesDict_284_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15030 G__setnull(result7);
15031 ((SIXA*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15032 return(1 || funcname || hash || result7 || libp) ;
15033 }
15034
15035 static int G__BankClassesDict_284_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15036 G__setnull(result7);
15037 ((SIXA*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15038 return(1 || funcname || hash || result7 || libp) ;
15039 }
15040
15041 static int G__BankClassesDict_284_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15042 G__setnull(result7);
15043 ((SIXA*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15044 return(1 || funcname || hash || result7 || libp) ;
15045 }
15046
15047 static int G__BankClassesDict_284_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15048 G__letint(result7,67,(long)SIXA::DeclFileName());
15049 return(1 || funcname || hash || result7 || libp) ;
15050 }
15051
15052 static int G__BankClassesDict_284_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15053 G__letint(result7,105,(long)SIXA::ImplFileLine());
15054 return(1 || funcname || hash || result7 || libp) ;
15055 }
15056
15057 static int G__BankClassesDict_284_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15058 G__letint(result7,67,(long)SIXA::ImplFileName());
15059 return(1 || funcname || hash || result7 || libp) ;
15060 }
15061
15062 static int G__BankClassesDict_284_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15063 G__letint(result7,105,(long)SIXA::DeclFileLine());
15064 return(1 || funcname || hash || result7 || libp) ;
15065 }
15066
15067
15068 static int G__BankClassesDict_284_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15069 {
15070 SIXA *p;
15071 p=new SIXA(*(SIXA*)G__int(libp->para[0]));
15072 result7->obj.i = (long)p;
15073 result7->ref = (long)p;
15074 result7->type = 'u';
15075 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SIXA);
15076 return(1 || funcname || hash || result7 || libp) ;
15077 }
15078
15079
15080 typedef SIXA G__TSIXA;
15081 static int G__BankClassesDict_284_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15082 if(0==G__getstructoffset()) return(1);
15083 if(G__getaryconstruct())
15084 if(G__PVOID==G__getgvp())
15085 delete[] (SIXA *)(G__getstructoffset());
15086 else
15087 for(int i=G__getaryconstruct()-1;i>=0;i--)
15088 delete (SIXA *)((G__getstructoffset())+sizeof(SIXA)*i);
15089 else delete (SIXA *)(G__getstructoffset());
15090 G__setnull(result7);
15091 return(1 || funcname || hash || result7 || libp) ;
15092 }
15093
15094
15095
15096 static int G__BankClassesDict_285_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15097 SITC *p=NULL;
15098 if(G__getaryconstruct()) p=new SITC[G__getaryconstruct()];
15099 else p=new SITC;
15100 result7->obj.i = (long)p;
15101 result7->ref = (long)p;
15102 result7->type = 'u';
15103 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SITC);
15104 return(1 || funcname || hash || result7 || libp) ;
15105 }
15106
15107 static int G__BankClassesDict_285_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15108 G__setnull(result7);
15109 ((SITC*)(G__getstructoffset()))->Assign((SITC_PATTERN*)G__int(libp->para[0]));
15110 return(1 || funcname || hash || result7 || libp) ;
15111 }
15112
15113 static int G__BankClassesDict_285_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15114 G__letint(result7,85,(long)SITC::Class());
15115 return(1 || funcname || hash || result7 || libp) ;
15116 }
15117
15118 static int G__BankClassesDict_285_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15119 G__letint(result7,67,(long)SITC::Class_Name());
15120 return(1 || funcname || hash || result7 || libp) ;
15121 }
15122
15123 static int G__BankClassesDict_285_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15124 G__letint(result7,115,(long)SITC::Class_Version());
15125 return(1 || funcname || hash || result7 || libp) ;
15126 }
15127
15128 static int G__BankClassesDict_285_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15129 G__setnull(result7);
15130 SITC::Dictionary();
15131 return(1 || funcname || hash || result7 || libp) ;
15132 }
15133
15134 static int G__BankClassesDict_285_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15135 G__letint(result7,85,(long)((const SITC*)(G__getstructoffset()))->IsA());
15136 return(1 || funcname || hash || result7 || libp) ;
15137 }
15138
15139 static int G__BankClassesDict_285_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15140 G__setnull(result7);
15141 ((SITC*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15142 return(1 || funcname || hash || result7 || libp) ;
15143 }
15144
15145 static int G__BankClassesDict_285_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15146 G__setnull(result7);
15147 ((SITC*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15148 return(1 || funcname || hash || result7 || libp) ;
15149 }
15150
15151 static int G__BankClassesDict_285_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15152 G__setnull(result7);
15153 ((SITC*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15154 return(1 || funcname || hash || result7 || libp) ;
15155 }
15156
15157 static int G__BankClassesDict_285_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15158 G__letint(result7,67,(long)SITC::DeclFileName());
15159 return(1 || funcname || hash || result7 || libp) ;
15160 }
15161
15162 static int G__BankClassesDict_285_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15163 G__letint(result7,105,(long)SITC::ImplFileLine());
15164 return(1 || funcname || hash || result7 || libp) ;
15165 }
15166
15167 static int G__BankClassesDict_285_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15168 G__letint(result7,67,(long)SITC::ImplFileName());
15169 return(1 || funcname || hash || result7 || libp) ;
15170 }
15171
15172 static int G__BankClassesDict_285_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15173 G__letint(result7,105,(long)SITC::DeclFileLine());
15174 return(1 || funcname || hash || result7 || libp) ;
15175 }
15176
15177
15178 static int G__BankClassesDict_285_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15179 {
15180 SITC *p;
15181 p=new SITC(*(SITC*)G__int(libp->para[0]));
15182 result7->obj.i = (long)p;
15183 result7->ref = (long)p;
15184 result7->type = 'u';
15185 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SITC);
15186 return(1 || funcname || hash || result7 || libp) ;
15187 }
15188
15189
15190 typedef SITC G__TSITC;
15191 static int G__BankClassesDict_285_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15192 if(0==G__getstructoffset()) return(1);
15193 if(G__getaryconstruct())
15194 if(G__PVOID==G__getgvp())
15195 delete[] (SITC *)(G__getstructoffset());
15196 else
15197 for(int i=G__getaryconstruct()-1;i>=0;i--)
15198 delete (SITC *)((G__getstructoffset())+sizeof(SITC)*i);
15199 else delete (SITC *)(G__getstructoffset());
15200 G__setnull(result7);
15201 return(1 || funcname || hash || result7 || libp) ;
15202 }
15203
15204
15205
15206 static int G__BankClassesDict_286_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15207 SRCO *p=NULL;
15208 if(G__getaryconstruct()) p=new SRCO[G__getaryconstruct()];
15209 else p=new SRCO;
15210 result7->obj.i = (long)p;
15211 result7->ref = (long)p;
15212 result7->type = 'u';
15213 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SRCO);
15214 return(1 || funcname || hash || result7 || libp) ;
15215 }
15216
15217 static int G__BankClassesDict_286_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15218 G__setnull(result7);
15219 ((SRCO*)(G__getstructoffset()))->Assign((SRCO_PATTERN*)G__int(libp->para[0]));
15220 return(1 || funcname || hash || result7 || libp) ;
15221 }
15222
15223 static int G__BankClassesDict_286_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15224 G__letint(result7,85,(long)SRCO::Class());
15225 return(1 || funcname || hash || result7 || libp) ;
15226 }
15227
15228 static int G__BankClassesDict_286_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15229 G__letint(result7,67,(long)SRCO::Class_Name());
15230 return(1 || funcname || hash || result7 || libp) ;
15231 }
15232
15233 static int G__BankClassesDict_286_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15234 G__letint(result7,115,(long)SRCO::Class_Version());
15235 return(1 || funcname || hash || result7 || libp) ;
15236 }
15237
15238 static int G__BankClassesDict_286_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15239 G__setnull(result7);
15240 SRCO::Dictionary();
15241 return(1 || funcname || hash || result7 || libp) ;
15242 }
15243
15244 static int G__BankClassesDict_286_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15245 G__letint(result7,85,(long)((const SRCO*)(G__getstructoffset()))->IsA());
15246 return(1 || funcname || hash || result7 || libp) ;
15247 }
15248
15249 static int G__BankClassesDict_286_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15250 G__setnull(result7);
15251 ((SRCO*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15252 return(1 || funcname || hash || result7 || libp) ;
15253 }
15254
15255 static int G__BankClassesDict_286_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15256 G__setnull(result7);
15257 ((SRCO*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15258 return(1 || funcname || hash || result7 || libp) ;
15259 }
15260
15261 static int G__BankClassesDict_286_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15262 G__setnull(result7);
15263 ((SRCO*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15264 return(1 || funcname || hash || result7 || libp) ;
15265 }
15266
15267 static int G__BankClassesDict_286_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15268 G__letint(result7,67,(long)SRCO::DeclFileName());
15269 return(1 || funcname || hash || result7 || libp) ;
15270 }
15271
15272 static int G__BankClassesDict_286_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15273 G__letint(result7,105,(long)SRCO::ImplFileLine());
15274 return(1 || funcname || hash || result7 || libp) ;
15275 }
15276
15277 static int G__BankClassesDict_286_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15278 G__letint(result7,67,(long)SRCO::ImplFileName());
15279 return(1 || funcname || hash || result7 || libp) ;
15280 }
15281
15282 static int G__BankClassesDict_286_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15283 G__letint(result7,105,(long)SRCO::DeclFileLine());
15284 return(1 || funcname || hash || result7 || libp) ;
15285 }
15286
15287
15288 static int G__BankClassesDict_286_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15289 {
15290 SRCO *p;
15291 p=new SRCO(*(SRCO*)G__int(libp->para[0]));
15292 result7->obj.i = (long)p;
15293 result7->ref = (long)p;
15294 result7->type = 'u';
15295 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_SRCO);
15296 return(1 || funcname || hash || result7 || libp) ;
15297 }
15298
15299
15300 typedef SRCO G__TSRCO;
15301 static int G__BankClassesDict_286_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15302 if(0==G__getstructoffset()) return(1);
15303 if(G__getaryconstruct())
15304 if(G__PVOID==G__getgvp())
15305 delete[] (SRCO *)(G__getstructoffset());
15306 else
15307 for(int i=G__getaryconstruct()-1;i>=0;i--)
15308 delete (SRCO *)((G__getstructoffset())+sizeof(SRCO)*i);
15309 else delete (SRCO *)(G__getstructoffset());
15310 G__setnull(result7);
15311 return(1 || funcname || hash || result7 || libp) ;
15312 }
15313
15314
15315
15316 static int G__BankClassesDict_287_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15317 X1TH *p=NULL;
15318 if(G__getaryconstruct()) p=new X1TH[G__getaryconstruct()];
15319 else p=new X1TH;
15320 result7->obj.i = (long)p;
15321 result7->ref = (long)p;
15322 result7->type = 'u';
15323 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1TH);
15324 return(1 || funcname || hash || result7 || libp) ;
15325 }
15326
15327 static int G__BankClassesDict_287_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15328 G__setnull(result7);
15329 ((X1TH*)(G__getstructoffset()))->Assign((X1TH_PATTERN*)G__int(libp->para[0]));
15330 return(1 || funcname || hash || result7 || libp) ;
15331 }
15332
15333 static int G__BankClassesDict_287_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15334 G__letint(result7,85,(long)X1TH::Class());
15335 return(1 || funcname || hash || result7 || libp) ;
15336 }
15337
15338 static int G__BankClassesDict_287_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15339 G__letint(result7,67,(long)X1TH::Class_Name());
15340 return(1 || funcname || hash || result7 || libp) ;
15341 }
15342
15343 static int G__BankClassesDict_287_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15344 G__letint(result7,115,(long)X1TH::Class_Version());
15345 return(1 || funcname || hash || result7 || libp) ;
15346 }
15347
15348 static int G__BankClassesDict_287_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15349 G__setnull(result7);
15350 X1TH::Dictionary();
15351 return(1 || funcname || hash || result7 || libp) ;
15352 }
15353
15354 static int G__BankClassesDict_287_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15355 G__letint(result7,85,(long)((const X1TH*)(G__getstructoffset()))->IsA());
15356 return(1 || funcname || hash || result7 || libp) ;
15357 }
15358
15359 static int G__BankClassesDict_287_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15360 G__setnull(result7);
15361 ((X1TH*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15362 return(1 || funcname || hash || result7 || libp) ;
15363 }
15364
15365 static int G__BankClassesDict_287_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15366 G__setnull(result7);
15367 ((X1TH*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15368 return(1 || funcname || hash || result7 || libp) ;
15369 }
15370
15371 static int G__BankClassesDict_287_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15372 G__setnull(result7);
15373 ((X1TH*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15374 return(1 || funcname || hash || result7 || libp) ;
15375 }
15376
15377 static int G__BankClassesDict_287_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15378 G__letint(result7,67,(long)X1TH::DeclFileName());
15379 return(1 || funcname || hash || result7 || libp) ;
15380 }
15381
15382 static int G__BankClassesDict_287_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15383 G__letint(result7,105,(long)X1TH::ImplFileLine());
15384 return(1 || funcname || hash || result7 || libp) ;
15385 }
15386
15387 static int G__BankClassesDict_287_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15388 G__letint(result7,67,(long)X1TH::ImplFileName());
15389 return(1 || funcname || hash || result7 || libp) ;
15390 }
15391
15392 static int G__BankClassesDict_287_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15393 G__letint(result7,105,(long)X1TH::DeclFileLine());
15394 return(1 || funcname || hash || result7 || libp) ;
15395 }
15396
15397
15398 static int G__BankClassesDict_287_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15399 {
15400 X1TH *p;
15401 p=new X1TH(*(X1TH*)G__int(libp->para[0]));
15402 result7->obj.i = (long)p;
15403 result7->ref = (long)p;
15404 result7->type = 'u';
15405 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1TH);
15406 return(1 || funcname || hash || result7 || libp) ;
15407 }
15408
15409
15410 typedef X1TH G__TX1TH;
15411 static int G__BankClassesDict_287_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15412 if(0==G__getstructoffset()) return(1);
15413 if(G__getaryconstruct())
15414 if(G__PVOID==G__getgvp())
15415 delete[] (X1TH *)(G__getstructoffset());
15416 else
15417 for(int i=G__getaryconstruct()-1;i>=0;i--)
15418 delete (X1TH *)((G__getstructoffset())+sizeof(X1TH)*i);
15419 else delete (X1TH *)(G__getstructoffset());
15420 G__setnull(result7);
15421 return(1 || funcname || hash || result7 || libp) ;
15422 }
15423
15424
15425
15426 static int G__BankClassesDict_288_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15427 X1AD *p=NULL;
15428 if(G__getaryconstruct()) p=new X1AD[G__getaryconstruct()];
15429 else p=new X1AD;
15430 result7->obj.i = (long)p;
15431 result7->ref = (long)p;
15432 result7->type = 'u';
15433 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1AD);
15434 return(1 || funcname || hash || result7 || libp) ;
15435 }
15436
15437 static int G__BankClassesDict_288_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15438 G__setnull(result7);
15439 ((X1AD*)(G__getstructoffset()))->Assign((X1AD_PATTERN*)G__int(libp->para[0]));
15440 return(1 || funcname || hash || result7 || libp) ;
15441 }
15442
15443 static int G__BankClassesDict_288_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15444 G__letint(result7,85,(long)X1AD::Class());
15445 return(1 || funcname || hash || result7 || libp) ;
15446 }
15447
15448 static int G__BankClassesDict_288_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15449 G__letint(result7,67,(long)X1AD::Class_Name());
15450 return(1 || funcname || hash || result7 || libp) ;
15451 }
15452
15453 static int G__BankClassesDict_288_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15454 G__letint(result7,115,(long)X1AD::Class_Version());
15455 return(1 || funcname || hash || result7 || libp) ;
15456 }
15457
15458 static int G__BankClassesDict_288_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15459 G__setnull(result7);
15460 X1AD::Dictionary();
15461 return(1 || funcname || hash || result7 || libp) ;
15462 }
15463
15464 static int G__BankClassesDict_288_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15465 G__letint(result7,85,(long)((const X1AD*)(G__getstructoffset()))->IsA());
15466 return(1 || funcname || hash || result7 || libp) ;
15467 }
15468
15469 static int G__BankClassesDict_288_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15470 G__setnull(result7);
15471 ((X1AD*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15472 return(1 || funcname || hash || result7 || libp) ;
15473 }
15474
15475 static int G__BankClassesDict_288_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15476 G__setnull(result7);
15477 ((X1AD*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15478 return(1 || funcname || hash || result7 || libp) ;
15479 }
15480
15481 static int G__BankClassesDict_288_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15482 G__setnull(result7);
15483 ((X1AD*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15484 return(1 || funcname || hash || result7 || libp) ;
15485 }
15486
15487 static int G__BankClassesDict_288_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15488 G__letint(result7,67,(long)X1AD::DeclFileName());
15489 return(1 || funcname || hash || result7 || libp) ;
15490 }
15491
15492 static int G__BankClassesDict_288_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15493 G__letint(result7,105,(long)X1AD::ImplFileLine());
15494 return(1 || funcname || hash || result7 || libp) ;
15495 }
15496
15497 static int G__BankClassesDict_288_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15498 G__letint(result7,67,(long)X1AD::ImplFileName());
15499 return(1 || funcname || hash || result7 || libp) ;
15500 }
15501
15502 static int G__BankClassesDict_288_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15503 G__letint(result7,105,(long)X1AD::DeclFileLine());
15504 return(1 || funcname || hash || result7 || libp) ;
15505 }
15506
15507
15508 static int G__BankClassesDict_288_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15509 {
15510 X1AD *p;
15511 p=new X1AD(*(X1AD*)G__int(libp->para[0]));
15512 result7->obj.i = (long)p;
15513 result7->ref = (long)p;
15514 result7->type = 'u';
15515 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_X1AD);
15516 return(1 || funcname || hash || result7 || libp) ;
15517 }
15518
15519
15520 typedef X1AD G__TX1AD;
15521 static int G__BankClassesDict_288_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15522 if(0==G__getstructoffset()) return(1);
15523 if(G__getaryconstruct())
15524 if(G__PVOID==G__getgvp())
15525 delete[] (X1AD *)(G__getstructoffset());
15526 else
15527 for(int i=G__getaryconstruct()-1;i>=0;i--)
15528 delete (X1AD *)((G__getstructoffset())+sizeof(X1AD)*i);
15529 else delete (X1AD *)(G__getstructoffset());
15530 G__setnull(result7);
15531 return(1 || funcname || hash || result7 || libp) ;
15532 }
15533
15534
15535
15536 static int G__BankClassesDict_289_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15537 QEXT *p=NULL;
15538 if(G__getaryconstruct()) p=new QEXT[G__getaryconstruct()];
15539 else p=new QEXT;
15540 result7->obj.i = (long)p;
15541 result7->ref = (long)p;
15542 result7->type = 'u';
15543 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QEXT);
15544 return(1 || funcname || hash || result7 || libp) ;
15545 }
15546
15547 static int G__BankClassesDict_289_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15548 G__letint(result7,85,(long)QEXT::Class());
15549 return(1 || funcname || hash || result7 || libp) ;
15550 }
15551
15552 static int G__BankClassesDict_289_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15553 G__letint(result7,67,(long)QEXT::Class_Name());
15554 return(1 || funcname || hash || result7 || libp) ;
15555 }
15556
15557 static int G__BankClassesDict_289_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15558 G__letint(result7,115,(long)QEXT::Class_Version());
15559 return(1 || funcname || hash || result7 || libp) ;
15560 }
15561
15562 static int G__BankClassesDict_289_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15563 G__setnull(result7);
15564 QEXT::Dictionary();
15565 return(1 || funcname || hash || result7 || libp) ;
15566 }
15567
15568 static int G__BankClassesDict_289_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15569 G__letint(result7,85,(long)((const QEXT*)(G__getstructoffset()))->IsA());
15570 return(1 || funcname || hash || result7 || libp) ;
15571 }
15572
15573 static int G__BankClassesDict_289_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15574 G__setnull(result7);
15575 ((QEXT*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15576 return(1 || funcname || hash || result7 || libp) ;
15577 }
15578
15579 static int G__BankClassesDict_289_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15580 G__setnull(result7);
15581 ((QEXT*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15582 return(1 || funcname || hash || result7 || libp) ;
15583 }
15584
15585 static int G__BankClassesDict_289_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15586 G__setnull(result7);
15587 ((QEXT*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15588 return(1 || funcname || hash || result7 || libp) ;
15589 }
15590
15591 static int G__BankClassesDict_289_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15592 G__letint(result7,67,(long)QEXT::DeclFileName());
15593 return(1 || funcname || hash || result7 || libp) ;
15594 }
15595
15596 static int G__BankClassesDict_289_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15597 G__letint(result7,105,(long)QEXT::ImplFileLine());
15598 return(1 || funcname || hash || result7 || libp) ;
15599 }
15600
15601 static int G__BankClassesDict_289_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15602 G__letint(result7,67,(long)QEXT::ImplFileName());
15603 return(1 || funcname || hash || result7 || libp) ;
15604 }
15605
15606 static int G__BankClassesDict_289_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15607 G__letint(result7,105,(long)QEXT::DeclFileLine());
15608 return(1 || funcname || hash || result7 || libp) ;
15609 }
15610
15611
15612 static int G__BankClassesDict_289_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15613 {
15614 QEXT *p;
15615 p=new QEXT(*(QEXT*)G__int(libp->para[0]));
15616 result7->obj.i = (long)p;
15617 result7->ref = (long)p;
15618 result7->type = 'u';
15619 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QEXT);
15620 return(1 || funcname || hash || result7 || libp) ;
15621 }
15622
15623
15624 typedef QEXT G__TQEXT;
15625 static int G__BankClassesDict_289_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15626 if(0==G__getstructoffset()) return(1);
15627 if(G__getaryconstruct())
15628 if(G__PVOID==G__getgvp())
15629 delete[] (QEXT *)(G__getstructoffset());
15630 else
15631 for(int i=G__getaryconstruct()-1;i>=0;i--)
15632 delete (QEXT *)((G__getstructoffset())+sizeof(QEXT)*i);
15633 else delete (QEXT *)(G__getstructoffset());
15634 G__setnull(result7);
15635 return(1 || funcname || hash || result7 || libp) ;
15636 }
15637
15638
15639
15640 static int G__BankClassesDict_290_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15641 QHAC *p=NULL;
15642 if(G__getaryconstruct()) p=new QHAC[G__getaryconstruct()];
15643 else p=new QHAC;
15644 result7->obj.i = (long)p;
15645 result7->ref = (long)p;
15646 result7->type = 'u';
15647 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QHAC);
15648 return(1 || funcname || hash || result7 || libp) ;
15649 }
15650
15651 static int G__BankClassesDict_290_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15652 G__letint(result7,85,(long)QHAC::Class());
15653 return(1 || funcname || hash || result7 || libp) ;
15654 }
15655
15656 static int G__BankClassesDict_290_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15657 G__letint(result7,67,(long)QHAC::Class_Name());
15658 return(1 || funcname || hash || result7 || libp) ;
15659 }
15660
15661 static int G__BankClassesDict_290_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15662 G__letint(result7,115,(long)QHAC::Class_Version());
15663 return(1 || funcname || hash || result7 || libp) ;
15664 }
15665
15666 static int G__BankClassesDict_290_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15667 G__setnull(result7);
15668 QHAC::Dictionary();
15669 return(1 || funcname || hash || result7 || libp) ;
15670 }
15671
15672 static int G__BankClassesDict_290_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15673 G__letint(result7,85,(long)((const QHAC*)(G__getstructoffset()))->IsA());
15674 return(1 || funcname || hash || result7 || libp) ;
15675 }
15676
15677 static int G__BankClassesDict_290_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15678 G__setnull(result7);
15679 ((QHAC*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
15680 return(1 || funcname || hash || result7 || libp) ;
15681 }
15682
15683 static int G__BankClassesDict_290_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15684 G__setnull(result7);
15685 ((QHAC*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
15686 return(1 || funcname || hash || result7 || libp) ;
15687 }
15688
15689 static int G__BankClassesDict_290_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15690 G__setnull(result7);
15691 ((QHAC*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
15692 return(1 || funcname || hash || result7 || libp) ;
15693 }
15694
15695 static int G__BankClassesDict_290_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15696 G__letint(result7,67,(long)QHAC::DeclFileName());
15697 return(1 || funcname || hash || result7 || libp) ;
15698 }
15699
15700 static int G__BankClassesDict_290_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15701 G__letint(result7,105,(long)QHAC::ImplFileLine());
15702 return(1 || funcname || hash || result7 || libp) ;
15703 }
15704
15705 static int G__BankClassesDict_290_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15706 G__letint(result7,67,(long)QHAC::ImplFileName());
15707 return(1 || funcname || hash || result7 || libp) ;
15708 }
15709
15710 static int G__BankClassesDict_290_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15711 G__letint(result7,105,(long)QHAC::DeclFileLine());
15712 return(1 || funcname || hash || result7 || libp) ;
15713 }
15714
15715
15716 static int G__BankClassesDict_290_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
15717 {
15718 QHAC *p;
15719 p=new QHAC(*(QHAC*)G__int(libp->para[0]));
15720 result7->obj.i = (long)p;
15721 result7->ref = (long)p;
15722 result7->type = 'u';
15723 result7->tagnum = G__get_linked_tagnum(&G__BankClassesDictLN_QHAC);
15724 return(1 || funcname || hash || result7 || libp) ;
15725 }
15726
15727
15728 typedef QHAC G__TQHAC;
15729 static int G__BankClassesDict_290_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
15730 if(0==G__getstructoffset()) return(1);
15731 if(G__getaryconstruct())
15732 if(G__PVOID==G__getgvp())
15733 delete[] (QHAC *)(G__getstructoffset());
15734 else
15735 for(int i=G__getaryconstruct()-1;i>=0;i--)
15736 delete (QHAC *)((G__getstructoffset())+sizeof(QHAC)*i);
15737 else delete (QHAC *)(G__getstructoffset());
15738 G__setnull(result7);
15739 return(1 || funcname || hash || result7 || libp) ;
15740 }
15741
15742
15743
15744
15745
15746
15747
15748
15749
15750
15751
15752
15753
15754
15755
15756
15757
15758
15759
15760
15761
15762
15763
15764
15765
15766
15767
15768
15769
15770
15771
15772
15773
15774
15775
15776
15777
15778
15779
15780
15781
15782
15783
15784
15785
15786
15787
15788
15789
15790
15791
15792
15793
15794
15795
15796
15797
15798
15799
15800
15801
15802
15803
15804
15805
15806
15807
15808
15809
15810
15811
15812
15813
15814
15815
15816
15817
15818
15819
15820
15821
15822
15823
15824
15825
15826
15827
15828
15829
15830
15831
15832
15833
15834
15835
15836
15837
15838
15839
15840
15841
15842
15843
15844
15845
15846
15847
15848
15849
15850
15851
15852
15853
15854
15855
15856
15857
15858
15859
15860
15861
15862
15863
15864
15865
15866
15867
15868
15869
15870
15871
15872
15873
15874
15875
15876
15877
15878
15879
15880
15881
15882
15883
15884
15885
15886
15887
15888 class G__Sizep2memfuncBankClassesDict {
15889 public:
15890 G__Sizep2memfuncBankClassesDict() {p=&G__Sizep2memfuncBankClassesDict::sizep2memfunc;}
15891 size_t sizep2memfunc() { return(sizeof(p)); }
15892 private:
15893 size_t (G__Sizep2memfuncBankClassesDict::*p)();
15894 };
15895
15896 size_t G__get_sizep2memfuncBankClassesDict()
15897 {
15898 G__Sizep2memfuncBankClassesDict a;
15899 G__setsizep2memfunc((int)a.sizep2memfunc());
15900 return((size_t)a.sizep2memfunc());
15901 }
15902
15903
15904
15905
15906
15907
15908
15909
15910
15911
15912
15913 extern "C" void G__cpp_setup_inheritanceBankClassesDict() {
15914
15915
15916 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QLIN))) {
15917 QLIN *G__Lderived;
15918 G__Lderived=(QLIN*)0x1000;
15919 {
15920 TObject *G__Lpbase=(TObject*)G__Lderived;
15921 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QLIN),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15922 }
15923 }
15924 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QMTL))) {
15925 QMTL *G__Lderived;
15926 G__Lderived=(QMTL*)0x1000;
15927 {
15928 TObject *G__Lpbase=(TObject*)G__Lderived;
15929 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTL),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15930 }
15931 }
15932 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QMTS))) {
15933 QMTS *G__Lderived;
15934 G__Lderived=(QMTS*)0x1000;
15935 {
15936 TObject *G__Lpbase=(TObject*)G__Lderived;
15937 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTS),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15938 }
15939 }
15940 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_FRFT))) {
15941 FRFT *G__Lderived;
15942 G__Lderived=(FRFT*)0x1000;
15943 {
15944 TObject *G__Lpbase=(TObject*)G__Lderived;
15945 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRFT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15946 }
15947 }
15948 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_FRTL))) {
15949 FRTL *G__Lderived;
15950 G__Lderived=(FRTL*)0x1000;
15951 {
15952 TObject *G__Lpbase=(TObject*)G__Lderived;
15953 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRTL),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15954 }
15955 }
15956 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_TEXS))) {
15957 TEXS *G__Lderived;
15958 G__Lderived=(TEXS*)0x1000;
15959 {
15960 TObject *G__Lpbase=(TObject*)G__Lderived;
15961 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_TEXS),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15962 }
15963 }
15964 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_HMAD))) {
15965 HMAD *G__Lderived;
15966 G__Lderived=(HMAD*)0x1000;
15967 {
15968 TObject *G__Lpbase=(TObject*)G__Lderived;
15969 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_HMAD),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15970 }
15971 }
15972 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_MCAD))) {
15973 MCAD *G__Lderived;
15974 G__Lderived=(MCAD*)0x1000;
15975 {
15976 TObject *G__Lpbase=(TObject*)G__Lderived;
15977 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MCAD),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15978 }
15979 }
15980 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PECO))) {
15981 PECO *G__Lderived;
15982 G__Lderived=(PECO*)0x1000;
15983 {
15984 TObject *G__Lpbase=(TObject*)G__Lderived;
15985 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PECO),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15986 }
15987 }
15988 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_EIDT))) {
15989 EIDT *G__Lderived;
15990 G__Lderived=(EIDT*)0x1000;
15991 {
15992 TObject *G__Lpbase=(TObject*)G__Lderived;
15993 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EIDT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15994 }
15995 }
15996 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PHCO))) {
15997 PHCO *G__Lderived;
15998 G__Lderived=(PHCO*)0x1000;
15999 {
16000 TObject *G__Lpbase=(TObject*)G__Lderived;
16001 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PHCO),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16002 }
16003 }
16004 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PEPT))) {
16005 PEPT *G__Lderived;
16006 G__Lderived=(PEPT*)0x1000;
16007 {
16008 TObject *G__Lpbase=(TObject*)G__Lderived;
16009 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PEPT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16010 }
16011 }
16012 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_FRID))) {
16013 FRID *G__Lderived;
16014 G__Lderived=(FRID*)0x1000;
16015 {
16016 TObject *G__Lpbase=(TObject*)G__Lderived;
16017 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRID),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16018 }
16019 }
16020 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_EFOL))) {
16021 EFOL *G__Lderived;
16022 G__Lderived=(EFOL*)0x1000;
16023 {
16024 TObject *G__Lpbase=(TObject*)G__Lderived;
16025 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EFOL),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16026 }
16027 }
16028 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PCQA))) {
16029 PCQA *G__Lderived;
16030 G__Lderived=(PCQA*)0x1000;
16031 {
16032 TObject *G__Lpbase=(TObject*)G__Lderived;
16033 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PCQA),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16034 }
16035 }
16036 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_EGPC))) {
16037 EGPC *G__Lderived;
16038 G__Lderived=(EGPC*)0x1000;
16039 {
16040 TObject *G__Lpbase=(TObject*)G__Lderived;
16041 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EGPC),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16042 }
16043 }
16044 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_MUID))) {
16045 MUID *G__Lderived;
16046 G__Lderived=(MUID*)0x1000;
16047 {
16048 TObject *G__Lpbase=(TObject*)G__Lderived;
16049 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MUID),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16050 }
16051 }
16052 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PGPC))) {
16053 PGPC *G__Lderived;
16054 G__Lderived=(PGPC*)0x1000;
16055 {
16056 TObject *G__Lpbase=(TObject*)G__Lderived;
16057 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGPC),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16058 }
16059 }
16060 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PGAC))) {
16061 PGAC *G__Lderived;
16062 G__Lderived=(PGAC*)0x1000;
16063 {
16064 TObject *G__Lpbase=(TObject*)G__Lderived;
16065 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGAC),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16066 }
16067 }
16068 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PDLT))) {
16069 PDLT *G__Lderived;
16070 G__Lderived=(PDLT*)0x1000;
16071 {
16072 TObject *G__Lpbase=(TObject*)G__Lderived;
16073 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PDLT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16074 }
16075 }
16076 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_PMLT))) {
16077 PMLT *G__Lderived;
16078 G__Lderived=(PMLT*)0x1000;
16079 {
16080 TObject *G__Lpbase=(TObject*)G__Lderived;
16081 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PMLT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16082 }
16083 }
16084 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QDET))) {
16085 QDET *G__Lderived;
16086 G__Lderived=(QDET*)0x1000;
16087 {
16088 TObject *G__Lpbase=(TObject*)G__Lderived;
16089 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QDET),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16090 }
16091 }
16092 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QVEC))) {
16093 QVEC *G__Lderived;
16094 G__Lderived=(QVEC*)0x1000;
16095 {
16096 TObject *G__Lpbase=(TObject*)G__Lderived;
16097 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVEC),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16098 }
16099 }
16100 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_YV0V))) {
16101 YV0V *G__Lderived;
16102 G__Lderived=(YV0V*)0x1000;
16103 {
16104 TObject *G__Lpbase=(TObject*)G__Lderived;
16105 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_YV0V),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16106 }
16107 }
16108 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_FKIN))) {
16109 FKIN *G__Lderived;
16110 G__Lderived=(FKIN*)0x1000;
16111 {
16112 TObject *G__Lpbase=(TObject*)G__Lderived;
16113 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FKIN),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16114 }
16115 }
16116 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_FVER))) {
16117 FVER *G__Lderived;
16118 G__Lderived=(FVER*)0x1000;
16119 {
16120 TObject *G__Lpbase=(TObject*)G__Lderived;
16121 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FVER),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16122 }
16123 }
16124 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QVRT))) {
16125 QVRT *G__Lderived;
16126 G__Lderived=(QVRT*)0x1000;
16127 {
16128 TObject *G__Lpbase=(TObject*)G__Lderived;
16129 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVRT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16130 }
16131 }
16132 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_ALPB))) {
16133 ALPB *G__Lderived;
16134 G__Lderived=(ALPB*)0x1000;
16135 {
16136 TObject *G__Lpbase=(TObject*)G__Lderived;
16137 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALPB),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16138 }
16139 }
16140 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_ALRP))) {
16141 ALRP *G__Lderived;
16142 G__Lderived=(ALRP*)0x1000;
16143 {
16144 TObject *G__Lpbase=(TObject*)G__Lderived;
16145 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALRP),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16146 }
16147 }
16148 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_RNL2))) {
16149 RNL2 *G__Lderived;
16150 G__Lderived=(RNL2*)0x1000;
16151 {
16152 TObject *G__Lpbase=(TObject*)G__Lderived;
16153 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNL2),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16154 }
16155 }
16156 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_RNF2))) {
16157 RNF2 *G__Lderived;
16158 G__Lderived=(RNF2*)0x1000;
16159 {
16160 TObject *G__Lpbase=(TObject*)G__Lderived;
16161 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNF2),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16162 }
16163 }
16164 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_RNR2))) {
16165 RNR2 *G__Lderived;
16166 G__Lderived=(RNR2*)0x1000;
16167 {
16168 TObject *G__Lpbase=(TObject*)G__Lderived;
16169 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNR2),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16170 }
16171 }
16172 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_RLEP))) {
16173 RLEP *G__Lderived;
16174 G__Lderived=(RLEP*)0x1000;
16175 {
16176 TObject *G__Lpbase=(TObject*)G__Lderived;
16177 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RLEP),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16178 }
16179 }
16180 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_LFIL))) {
16181 LFIL *G__Lderived;
16182 G__Lderived=(LFIL*)0x1000;
16183 {
16184 TObject *G__Lpbase=(TObject*)G__Lderived;
16185 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LFIL),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16186 }
16187 }
16188 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_EVEH))) {
16189 EVEH *G__Lderived;
16190 G__Lderived=(EVEH*)0x1000;
16191 {
16192 TObject *G__Lpbase=(TObject*)G__Lderived;
16193 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EVEH),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16194 }
16195 }
16196 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_KEVH))) {
16197 KEVH *G__Lderived;
16198 G__Lderived=(KEVH*)0x1000;
16199 {
16200 TObject *G__Lpbase=(TObject*)G__Lderived;
16201 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KEVH),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16202 }
16203 }
16204 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_REVH))) {
16205 REVH *G__Lderived;
16206 G__Lderived=(REVH*)0x1000;
16207 {
16208 TObject *G__Lpbase=(TObject*)G__Lderived;
16209 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_REVH),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16210 }
16211 }
16212 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_LOLE))) {
16213 LOLE *G__Lderived;
16214 G__Lderived=(LOLE*)0x1000;
16215 {
16216 TObject *G__Lpbase=(TObject*)G__Lderived;
16217 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LOLE),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16218 }
16219 }
16220 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_X1RG))) {
16221 X1RG *G__Lderived;
16222 G__Lderived=(X1RG*)0x1000;
16223 {
16224 TObject *G__Lpbase=(TObject*)G__Lderived;
16225 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1RG),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16226 }
16227 }
16228 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_BOMB))) {
16229 BOMB *G__Lderived;
16230 G__Lderived=(BOMB*)0x1000;
16231 {
16232 TObject *G__Lpbase=(TObject*)G__Lderived;
16233 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_BOMB),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16234 }
16235 }
16236 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_RUNH))) {
16237 RUNH *G__Lderived;
16238 G__Lderived=(RUNH*)0x1000;
16239 {
16240 TObject *G__Lpbase=(TObject*)G__Lderived;
16241 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RUNH),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16242 }
16243 }
16244 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_ASIM))) {
16245 ASIM *G__Lderived;
16246 G__Lderived=(ASIM*)0x1000;
16247 {
16248 TObject *G__Lpbase=(TObject*)G__Lderived;
16249 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ASIM),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16250 }
16251 }
16252 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_ADBR))) {
16253 ADBR *G__Lderived;
16254 G__Lderived=(ADBR*)0x1000;
16255 {
16256 TObject *G__Lpbase=(TObject*)G__Lderived;
16257 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ADBR),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16258 }
16259 }
16260 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_XTBN))) {
16261 XTBN *G__Lderived;
16262 G__Lderived=(XTBN*)0x1000;
16263 {
16264 TObject *G__Lpbase=(TObject*)G__Lderived;
16265 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTBN),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16266 }
16267 }
16268 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_XTCN))) {
16269 XTCN *G__Lderived;
16270 G__Lderived=(XTCN*)0x1000;
16271 {
16272 TObject *G__Lpbase=(TObject*)G__Lderived;
16273 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTCN),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16274 }
16275 }
16276 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_XTOP))) {
16277 XTOP *G__Lderived;
16278 G__Lderived=(XTOP*)0x1000;
16279 {
16280 TObject *G__Lpbase=(TObject*)G__Lderived;
16281 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTOP),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16282 }
16283 }
16284 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_LUPA))) {
16285 LUPA *G__Lderived;
16286 G__Lderived=(LUPA*)0x1000;
16287 {
16288 TObject *G__Lpbase=(TObject*)G__Lderived;
16289 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LUPA),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16290 }
16291 }
16292 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_SILH))) {
16293 SILH *G__Lderived;
16294 G__Lderived=(SILH*)0x1000;
16295 {
16296 TObject *G__Lpbase=(TObject*)G__Lderived;
16297 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SILH),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16298 }
16299 }
16300 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_XHVB))) {
16301 XHVB *G__Lderived;
16302 G__Lderived=(XHVB*)0x1000;
16303 {
16304 TObject *G__Lpbase=(TObject*)G__Lderived;
16305 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XHVB),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16306 }
16307 }
16308 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_XTEB))) {
16309 XTEB *G__Lderived;
16310 G__Lderived=(XTEB*)0x1000;
16311 {
16312 TObject *G__Lpbase=(TObject*)G__Lderived;
16313 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTEB),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16314 }
16315 }
16316 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_XTRB))) {
16317 XTRB *G__Lderived;
16318 G__Lderived=(XTRB*)0x1000;
16319 {
16320 TObject *G__Lpbase=(TObject*)G__Lderived;
16321 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTRB),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16322 }
16323 }
16324 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_DTBP))) {
16325 DTBP *G__Lderived;
16326 G__Lderived=(DTBP*)0x1000;
16327 {
16328 TObject *G__Lpbase=(TObject*)G__Lderived;
16329 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_DTBP),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16330 }
16331 }
16332 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_VHBV))) {
16333 VHBV *G__Lderived;
16334 G__Lderived=(VHBV*)0x1000;
16335 {
16336 TObject *G__Lpbase=(TObject*)G__Lderived;
16337 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHBV),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16338 }
16339 }
16340 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_VHPV))) {
16341 VHPV *G__Lderived;
16342 G__Lderived=(VHPV*)0x1000;
16343 {
16344 TObject *G__Lpbase=(TObject*)G__Lderived;
16345 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHPV),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16346 }
16347 }
16348 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_EAUX))) {
16349 EAUX *G__Lderived;
16350 G__Lderived=(EAUX*)0x1000;
16351 {
16352 TObject *G__Lpbase=(TObject*)G__Lderived;
16353 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EAUX),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16354 }
16355 }
16356 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_SIX2))) {
16357 SIX2 *G__Lderived;
16358 G__Lderived=(SIX2*)0x1000;
16359 {
16360 TObject *G__Lpbase=(TObject*)G__Lderived;
16361 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIX2),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16362 }
16363 }
16364 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_X1TV))) {
16365 X1TV *G__Lderived;
16366 G__Lderived=(X1TV*)0x1000;
16367 {
16368 TObject *G__Lpbase=(TObject*)G__Lderived;
16369 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TV),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16370 }
16371 }
16372 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_KWGT))) {
16373 KWGT *G__Lderived;
16374 G__Lderived=(KWGT*)0x1000;
16375 {
16376 TObject *G__Lpbase=(TObject*)G__Lderived;
16377 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KWGT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16378 }
16379 }
16380 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_X1IP))) {
16381 X1IP *G__Lderived;
16382 G__Lderived=(X1IP*)0x1000;
16383 {
16384 TObject *G__Lpbase=(TObject*)G__Lderived;
16385 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1IP),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16386 }
16387 }
16388 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_SIXA))) {
16389 SIXA *G__Lderived;
16390 G__Lderived=(SIXA*)0x1000;
16391 {
16392 TObject *G__Lpbase=(TObject*)G__Lderived;
16393 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIXA),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16394 }
16395 }
16396 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_SITC))) {
16397 SITC *G__Lderived;
16398 G__Lderived=(SITC*)0x1000;
16399 {
16400 TObject *G__Lpbase=(TObject*)G__Lderived;
16401 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SITC),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16402 }
16403 }
16404 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_SRCO))) {
16405 SRCO *G__Lderived;
16406 G__Lderived=(SRCO*)0x1000;
16407 {
16408 TObject *G__Lpbase=(TObject*)G__Lderived;
16409 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SRCO),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16410 }
16411 }
16412 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_X1TH))) {
16413 X1TH *G__Lderived;
16414 G__Lderived=(X1TH*)0x1000;
16415 {
16416 TObject *G__Lpbase=(TObject*)G__Lderived;
16417 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TH),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16418 }
16419 }
16420 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_X1AD))) {
16421 X1AD *G__Lderived;
16422 G__Lderived=(X1AD*)0x1000;
16423 {
16424 TObject *G__Lpbase=(TObject*)G__Lderived;
16425 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1AD),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16426 }
16427 }
16428 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QEXT))) {
16429 QEXT *G__Lderived;
16430 G__Lderived=(QEXT*)0x1000;
16431 {
16432 TObject *G__Lpbase=(TObject*)G__Lderived;
16433 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QEXT),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16434 }
16435 }
16436 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__BankClassesDictLN_QHAC))) {
16437 QHAC *G__Lderived;
16438 G__Lderived=(QHAC*)0x1000;
16439 {
16440 TObject *G__Lpbase=(TObject*)G__Lderived;
16441 G__inheritance_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QHAC),G__get_linked_tagnum(&G__BankClassesDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
16442 }
16443 }
16444 }
16445
16446
16447
16448
16449 extern "C" void G__cpp_setup_typetableBankClassesDict() {
16450
16451
16452 G__search_typename2("Version_t",115,-1,0,
16453 -1);
16454 G__setnewtype(-1,"Class version identifier (short)",0);
16455 G__search_typename2("vector<unsigned short>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),0,-1);
16456 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16457 G__search_typename2("random_access_iterator<unsigned short,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEunsignedsPshortcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR));
16458 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16459 G__search_typename2("vector<FKIN*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEFKINmUcOallocatorlEFKINmUgRsPgR),0,-1);
16460 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16461 G__search_typename2("random_access_iterator<FKIN*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEFKINmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEFKINmUcOallocatorlEFKINmUgRsPgR));
16462 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16463 G__search_typename2("vector<LOLE*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlELOLEmUcOallocatorlELOLEmUgRsPgR),0,-1);
16464 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16465 G__search_typename2("random_access_iterator<LOLE*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlELOLEmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlELOLEmUcOallocatorlELOLEmUgRsPgR));
16466 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16467 G__search_typename2("vector<X1RG*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1RGmUcOallocatorlEX1RGmUgRsPgR),0,-1);
16468 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16469 G__search_typename2("random_access_iterator<X1RG*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1RGmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1RGmUcOallocatorlEX1RGmUgRsPgR));
16470 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16471 G__search_typename2("vector<XTBN*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXTBNmUcOallocatorlEXTBNmUgRsPgR),0,-1);
16472 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16473 G__search_typename2("random_access_iterator<XTBN*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEXTBNmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXTBNmUcOallocatorlEXTBNmUgRsPgR));
16474 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16475 G__search_typename2("vector<XHVB*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXHVBmUcOallocatorlEXHVBmUgRsPgR),0,-1);
16476 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16477 G__search_typename2("random_access_iterator<XHVB*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEXHVBmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXHVBmUcOallocatorlEXHVBmUgRsPgR));
16478 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16479 G__search_typename2("vector<VHPV*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHPVmUcOallocatorlEVHPVmUgRsPgR),0,-1);
16480 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16481 G__search_typename2("random_access_iterator<VHPV*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEVHPVmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHPVmUcOallocatorlEVHPVmUgRsPgR));
16482 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16483 G__search_typename2("vector<VHBV*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHBVmUcOallocatorlEVHBVmUgRsPgR),0,-1);
16484 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16485 G__search_typename2("random_access_iterator<VHBV*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEVHBVmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHBVmUcOallocatorlEVHBVmUgRsPgR));
16486 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16487 G__search_typename2("vector<X1TV*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1TVmUcOallocatorlEX1TVmUgRsPgR),0,-1);
16488 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16489 G__search_typename2("random_access_iterator<X1TV*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1TVmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1TVmUcOallocatorlEX1TVmUgRsPgR));
16490 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16491 G__search_typename2("vector<KWGT*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEKWGTmUcOallocatorlEKWGTmUgRsPgR),0,-1);
16492 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16493 G__search_typename2("random_access_iterator<KWGT*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEKWGTmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEKWGTmUcOallocatorlEKWGTmUgRsPgR));
16494 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16495 G__search_typename2("vector<X1IP*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1IPmUcOallocatorlEX1IPmUgRsPgR),0,-1);
16496 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16497 G__search_typename2("random_access_iterator<X1IP*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1IPmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1IPmUcOallocatorlEX1IPmUgRsPgR));
16498 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16499 G__search_typename2("vector<SIXA*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESIXAmUcOallocatorlESIXAmUgRsPgR),0,-1);
16500 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16501 G__search_typename2("random_access_iterator<SIXA*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlESIXAmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESIXAmUcOallocatorlESIXAmUgRsPgR));
16502 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16503 G__search_typename2("vector<SRCO*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESRCOmUcOallocatorlESRCOmUgRsPgR),0,-1);
16504 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16505 G__search_typename2("random_access_iterator<SRCO*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlESRCOmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESRCOmUcOallocatorlESRCOmUgRsPgR));
16506 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16507 G__search_typename2("vector<X1TH*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1THmUcOallocatorlEX1THmUgRsPgR),0,-1);
16508 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16509 G__search_typename2("random_access_iterator<X1TH*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1THmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1THmUcOallocatorlEX1THmUgRsPgR));
16510 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16511 G__search_typename2("vector<X1AD*>",117,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1ADmUcOallocatorlEX1ADmUgRsPgR),0,-1);
16512 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16513 G__search_typename2("random_access_iterator<X1AD*,difference_type>",117,G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1ADmUcOintgR),0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1ADmUcOallocatorlEX1ADmUgRsPgR));
16514 G__setnewtype(-1,"# 1 \"/tmp/fileCAl338_cint.cxx\"",0);
16515 }
16516
16517
16518
16519
16520
16521
16522
16523
16524 static void G__setup_memvarQLIN(void) {
16525 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QLIN));
16526 { QLIN *p; p=(QLIN*)0x1000; if (p) { }
16527 G__memvar_setup((void*)((long)(&p->I)-(long)(p)),114,0,0,-1,-1,-1,1,"I=",0,(char*)NULL);
16528 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16529 }
16530 G__tag_memvar_reset();
16531 }
16532
16533
16534
16535 static void G__setup_memvarQMTL(void) {
16536 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTL));
16537 { QMTL *p; p=(QMTL*)0x1000; if (p) { }
16538 G__memvar_setup((void*)((long)(&p->I)-(long)(p)),114,0,0,-1,-1,-1,1,"I=",0,(char*)NULL);
16539 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16540 }
16541 G__tag_memvar_reset();
16542 }
16543
16544
16545
16546 static void G__setup_memvarQMTS(void) {
16547 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTS));
16548 { QMTS *p; p=(QMTS*)0x1000; if (p) { }
16549 G__memvar_setup((void*)((long)(&p->I)-(long)(p)),114,0,0,-1,-1,-1,1,"I=",0,(char*)NULL);
16550 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16551 }
16552 G__tag_memvar_reset();
16553 }
16554
16555
16556
16557 static void G__setup_memvarFRFT(void) {
16558 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRFT));
16559 { FRFT *p; p=(FRFT*)0x1000; if (p) { }
16560 G__memvar_setup((void*)((long)(&p->IR)-(long)(p)),102,0,0,-1,-1,-1,1,"IR=",0,(char*)NULL);
16561 G__memvar_setup((void*)((long)(&p->TL)-(long)(p)),102,0,0,-1,-1,-1,1,"TL=",0,(char*)NULL);
16562 G__memvar_setup((void*)((long)(&p->P0)-(long)(p)),102,0,0,-1,-1,-1,1,"P0=",0,(char*)NULL);
16563 G__memvar_setup((void*)((long)(&p->D0)-(long)(p)),102,0,0,-1,-1,-1,1,"D0=",0,(char*)NULL);
16564 G__memvar_setup((void*)((long)(&p->Z0)-(long)(p)),102,0,0,-1,-1,-1,1,"Z0=",0,(char*)NULL);
16565 G__memvar_setup((void*)((long)(&p->AL)-(long)(p)),102,0,0,-1,-1,-1,1,"AL=",0,(char*)NULL);
16566 G__memvar_setup((void*)((long)(&p->EM)-(long)(p)),102,0,0,-1,-1,-1,1,"EM[20]=",0,(char*)NULL);
16567 G__memvar_setup((void*)((long)(&p->C2)-(long)(p)),102,0,0,-1,-1,-1,1,"C2=",0,(char*)NULL);
16568 G__memvar_setup((void*)((long)(&p->DF)-(long)(p)),114,0,0,-1,-1,-1,1,"DF=",0,(char*)NULL);
16569 G__memvar_setup((void*)((long)(&p->NO)-(long)(p)),114,0,0,-1,-1,-1,1,"NO=",0,(char*)NULL);
16570 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16571 }
16572 G__tag_memvar_reset();
16573 }
16574
16575
16576
16577 static void G__setup_memvarFRTL(void) {
16578 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRTL));
16579 { FRTL *p; p=(FRTL*)0x1000; if (p) { }
16580 G__memvar_setup((void*)((long)(&p->IV)-(long)(p)),114,0,0,-1,-1,-1,1,"IV=",0,(char*)NULL);
16581 G__memvar_setup((void*)((long)(&p->NV)-(long)(p)),114,0,0,-1,-1,-1,1,"NV=",0,(char*)NULL);
16582 G__memvar_setup((void*)((long)(&p->II)-(long)(p)),114,0,0,-1,-1,-1,1,"II=",0,(char*)NULL);
16583 G__memvar_setup((void*)((long)(&p->NI)-(long)(p)),114,0,0,-1,-1,-1,1,"NI=",0,(char*)NULL);
16584 G__memvar_setup((void*)((long)(&p->NE)-(long)(p)),114,0,0,-1,-1,-1,1,"NE=",0,(char*)NULL);
16585 G__memvar_setup((void*)((long)(&p->IT)-(long)(p)),114,0,0,-1,-1,-1,1,"IT=",0,(char*)NULL);
16586 G__memvar_setup((void*)((long)(&p->NT)-(long)(p)),114,0,0,-1,-1,-1,1,"NT=",0,(char*)NULL);
16587 G__memvar_setup((void*)((long)(&p->NR)-(long)(p)),114,0,0,-1,-1,-1,1,"NR=",0,(char*)NULL);
16588 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16589 }
16590 G__tag_memvar_reset();
16591 }
16592
16593
16594
16595 static void G__setup_memvarTEXS(void) {
16596 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_TEXS));
16597 { TEXS *p; p=(TEXS*)0x1000; if (p) { }
16598 G__memvar_setup((void*)((long)(&p->SI)-(long)(p)),114,0,0,-1,-1,-1,1,"SI=",0,(char*)NULL);
16599 G__memvar_setup((void*)((long)(&p->TM)-(long)(p)),102,0,0,-1,-1,-1,1,"TM=",0,(char*)NULL);
16600 G__memvar_setup((void*)((long)(&p->TL)-(long)(p)),102,0,0,-1,-1,-1,1,"TL=",0,(char*)NULL);
16601 G__memvar_setup((void*)((long)(&p->NS)-(long)(p)),114,0,0,-1,-1,-1,1,"NS=",0,(char*)NULL);
16602 G__memvar_setup((void*)((long)(&p->AD)-(long)(p)),102,0,0,-1,-1,-1,1,"AD=",0,(char*)NULL);
16603 G__memvar_setup((void*)((long)(&p->TN)-(long)(p)),114,0,0,-1,-1,-1,1,"TN=",0,(char*)NULL);
16604 G__memvar_setup((void*)((long)(&p->SF)-(long)(p)),114,0,0,-1,-1,-1,1,"SF=",0,(char*)NULL);
16605 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16606 }
16607 G__tag_memvar_reset();
16608 }
16609
16610
16611
16612 static void G__setup_memvarHMAD(void) {
16613 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_HMAD));
16614 { HMAD *p; p=(HMAD*)0x1000; if (p) { }
16615 G__memvar_setup((void*)((long)(&p->NplaFired)-(long)(p)),114,0,0,-1,-1,-1,1,"NplaFired=",0,(char*)NULL);
16616 G__memvar_setup((void*)((long)(&p->NplaExp)-(long)(p)),114,0,0,-1,-1,-1,1,"NplaExp=",0,(char*)NULL);
16617 G__memvar_setup((void*)((long)(&p->NplaLast)-(long)(p)),114,0,0,-1,-1,-1,1,"NplaLast=",0,(char*)NULL);
16618 G__memvar_setup((void*)((long)(&p->MultHits)-(long)(p)),114,0,0,-1,-1,-1,1,"MultHits=",0,(char*)NULL);
16619 G__memvar_setup((void*)((long)(&p->IGeomflag)-(long)(p)),115,0,0,-1,-1,-1,1,"IGeomflag=",0,(char*)NULL);
16620 G__memvar_setup((void*)((long)(&p->EnerDep)-(long)(p)),102,0,0,-1,-1,-1,1,"EnerDep=",0,(char*)NULL);
16621 G__memvar_setup((void*)((long)(&p->ChiSquare)-(long)(p)),102,0,0,-1,-1,-1,1,"ChiSquare=",0,(char*)NULL);
16622 G__memvar_setup((void*)((long)(&p->NumbDeg)-(long)(p)),115,0,0,-1,-1,-1,1,"NumbDeg=",0,(char*)NULL);
16623 G__memvar_setup((void*)((long)(&p->IExpbmap)-(long)(p)),105,0,0,-1,-1,-1,1,"IExpbmap=",0,(char*)NULL);
16624 G__memvar_setup((void*)((long)(&p->ITruebmap)-(long)(p)),105,0,0,-1,-1,-1,1,"ITruebmap=",0,(char*)NULL);
16625 G__memvar_setup((void*)((long)(&p->IdenFlag)-(long)(p)),115,0,0,-1,-1,-1,1,"IdenFlag=",0,(char*)NULL);
16626 G__memvar_setup((void*)((long)(&p->TrackNo)-(long)(p)),114,0,0,-1,-1,-1,1,"TrackNo=",0,(char*)NULL);
16627 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16628 }
16629 G__tag_memvar_reset();
16630 }
16631
16632
16633
16634 static void G__setup_memvarMCAD(void) {
16635 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MCAD));
16636 { MCAD *p; p=(MCAD*)0x1000; if (p) { }
16637 G__memvar_setup((void*)((long)(&p->NH)-(long)(p)),114,0,0,-1,-1,-1,1,"NH[2]=",0,(char*)NULL);
16638 G__memvar_setup((void*)((long)(&p->DH)-(long)(p)),102,0,0,-1,-1,-1,1,"DH[2]=",0,(char*)NULL);
16639 G__memvar_setup((void*)((long)(&p->DC)-(long)(p)),102,0,0,-1,-1,-1,1,"DC[2]=",0,(char*)NULL);
16640 G__memvar_setup((void*)((long)(&p->AM)-(long)(p)),102,0,0,-1,-1,-1,1,"AM=",0,(char*)NULL);
16641 G__memvar_setup((void*)((long)(&p->AC)-(long)(p)),102,0,0,-1,-1,-1,1,"AC=",0,(char*)NULL);
16642 G__memvar_setup((void*)((long)(&p->TN)-(long)(p)),114,0,0,-1,-1,-1,1,"TN=",0,(char*)NULL);
16643 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16644 }
16645 G__tag_memvar_reset();
16646 }
16647
16648
16649
16650 static void G__setup_memvarPECO(void) {
16651 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PECO));
16652 { PECO *p; p=(PECO*)0x1000; if (p) { }
16653 G__memvar_setup((void*)((long)(&p->ER)-(long)(p)),102,0,0,-1,-1,-1,1,"ER=",0,(char*)NULL);
16654 G__memvar_setup((void*)((long)(&p->E1)-(long)(p)),102,0,0,-1,-1,-1,1,"E1=",0,(char*)NULL);
16655 G__memvar_setup((void*)((long)(&p->E2)-(long)(p)),102,0,0,-1,-1,-1,1,"E2=",0,(char*)NULL);
16656 G__memvar_setup((void*)((long)(&p->TH)-(long)(p)),102,0,0,-1,-1,-1,1,"TH=",0,(char*)NULL);
16657 G__memvar_setup((void*)((long)(&p->PH)-(long)(p)),102,0,0,-1,-1,-1,1,"PH=",0,(char*)NULL);
16658 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),102,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
16659 G__memvar_setup((void*)((long)(&p->KD)-(long)(p)),114,0,0,-1,-1,-1,1,"KD=",0,(char*)NULL);
16660 G__memvar_setup((void*)((long)(&p->CC)-(long)(p)),114,0,0,-1,-1,-1,1,"CC=",0,(char*)NULL);
16661 G__memvar_setup((void*)((long)(&p->RB)-(long)(p)),114,0,0,-1,-1,-1,1,"RB=",0,(char*)NULL);
16662 G__memvar_setup((void*)((long)(&p->PC)-(long)(p)),114,0,0,-1,-1,-1,1,"PC=",0,(char*)NULL);
16663 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16664 }
16665 G__tag_memvar_reset();
16666 }
16667
16668
16669
16670 static void G__setup_memvarEIDT(void) {
16671 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EIDT));
16672 { EIDT *p; p=(EIDT*)0x1000; if (p) { }
16673 G__memvar_setup((void*)((long)(&p->IF)-(long)(p)),114,0,0,-1,-1,-1,1,"IF=",0,(char*)NULL);
16674 G__memvar_setup((void*)((long)(&p->R1)-(long)(p)),102,0,0,-1,-1,-1,1,"R1=",0,(char*)NULL);
16675 G__memvar_setup((void*)((long)(&p->R2)-(long)(p)),102,0,0,-1,-1,-1,1,"R2=",0,(char*)NULL);
16676 G__memvar_setup((void*)((long)(&p->R3)-(long)(p)),102,0,0,-1,-1,-1,1,"R3=",0,(char*)NULL);
16677 G__memvar_setup((void*)((long)(&p->R4)-(long)(p)),102,0,0,-1,-1,-1,1,"R4=",0,(char*)NULL);
16678 G__memvar_setup((void*)((long)(&p->R5)-(long)(p)),102,0,0,-1,-1,-1,1,"R5=",0,(char*)NULL);
16679 G__memvar_setup((void*)((long)(&p->R6)-(long)(p)),102,0,0,-1,-1,-1,1,"R6=",0,(char*)NULL);
16680 G__memvar_setup((void*)((long)(&p->R7)-(long)(p)),102,0,0,-1,-1,-1,1,"R7=",0,(char*)NULL);
16681 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),102,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
16682 G__memvar_setup((void*)((long)(&p->IP)-(long)(p)),114,0,0,-1,-1,-1,1,"IP=",0,(char*)NULL);
16683 G__memvar_setup((void*)((long)(&p->E1)-(long)(p)),102,0,0,-1,-1,-1,1,"E1=",0,(char*)NULL);
16684 G__memvar_setup((void*)((long)(&p->E2)-(long)(p)),102,0,0,-1,-1,-1,1,"E2=",0,(char*)NULL);
16685 G__memvar_setup((void*)((long)(&p->E3)-(long)(p)),102,0,0,-1,-1,-1,1,"E3=",0,(char*)NULL);
16686 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),114,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
16687 G__memvar_setup((void*)((long)(&p->PE)-(long)(p)),105,0,0,-1,-1,-1,1,"PE=",0,(char*)NULL);
16688 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16689 }
16690 G__tag_memvar_reset();
16691 }
16692
16693
16694
16695 static void G__setup_memvarPHCO(void) {
16696 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PHCO));
16697 { PHCO *p; p=(PHCO*)0x1000; if (p) { }
16698 G__memvar_setup((void*)((long)(&p->ER)-(long)(p)),102,0,0,-1,-1,-1,1,"ER=",0,(char*)NULL);
16699 G__memvar_setup((void*)((long)(&p->TH)-(long)(p)),102,0,0,-1,-1,-1,1,"TH=",0,(char*)NULL);
16700 G__memvar_setup((void*)((long)(&p->PH)-(long)(p)),102,0,0,-1,-1,-1,1,"PH=",0,(char*)NULL);
16701 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),102,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
16702 G__memvar_setup((void*)((long)(&p->KD)-(long)(p)),114,0,0,-1,-1,-1,1,"KD=",0,(char*)NULL);
16703 G__memvar_setup((void*)((long)(&p->CC)-(long)(p)),114,0,0,-1,-1,-1,1,"CC=",0,(char*)NULL);
16704 G__memvar_setup((void*)((long)(&p->RB)-(long)(p)),114,0,0,-1,-1,-1,1,"RB=",0,(char*)NULL);
16705 G__memvar_setup((void*)((long)(&p->NF)-(long)(p)),114,0,0,-1,-1,-1,1,"NF=",0,(char*)NULL);
16706 G__memvar_setup((void*)((long)(&p->PC)-(long)(p)),114,0,0,-1,-1,-1,1,"PC=",0,(char*)NULL);
16707 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16708 }
16709 G__tag_memvar_reset();
16710 }
16711
16712
16713
16714 static void G__setup_memvarPEPT(void) {
16715 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PEPT));
16716 { PEPT *p; p=(PEPT*)0x1000; if (p) { }
16717 G__memvar_setup((void*)((long)(&p->T1)-(long)(p)),102,0,0,-1,-1,-1,1,"T1=",0,(char*)NULL);
16718 G__memvar_setup((void*)((long)(&p->P1)-(long)(p)),102,0,0,-1,-1,-1,1,"P1=",0,(char*)NULL);
16719 G__memvar_setup((void*)((long)(&p->T3)-(long)(p)),102,0,0,-1,-1,-1,1,"T3=",0,(char*)NULL);
16720 G__memvar_setup((void*)((long)(&p->P3)-(long)(p)),102,0,0,-1,-1,-1,1,"P3=",0,(char*)NULL);
16721 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16722 }
16723 G__tag_memvar_reset();
16724 }
16725
16726
16727
16728 static void G__setup_memvarFRID(void) {
16729 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRID));
16730 { FRID *p; p=(FRID*)0x1000; if (p) { }
16731 G__memvar_setup((void*)((long)(&p->BP)-(long)(p)),105,0,0,-1,-1,-1,1,"BP=",0,(char*)NULL);
16732 G__memvar_setup((void*)((long)(&p->DZ)-(long)(p)),105,0,0,-1,-1,-1,1,"DZ=",0,(char*)NULL);
16733 G__memvar_setup((void*)((long)(&p->BC)-(long)(p)),105,0,0,-1,-1,-1,1,"BC=",0,(char*)NULL);
16734 G__memvar_setup((void*)((long)(&p->DC)-(long)(p)),105,0,0,-1,-1,-1,1,"DC=",0,(char*)NULL);
16735 G__memvar_setup((void*)((long)(&p->PE)-(long)(p)),102,0,0,-1,-1,-1,1,"PE=",0,(char*)NULL);
16736 G__memvar_setup((void*)((long)(&p->PM)-(long)(p)),102,0,0,-1,-1,-1,1,"PM=",0,(char*)NULL);
16737 G__memvar_setup((void*)((long)(&p->PI)-(long)(p)),102,0,0,-1,-1,-1,1,"PI=",0,(char*)NULL);
16738 G__memvar_setup((void*)((long)(&p->PK)-(long)(p)),102,0,0,-1,-1,-1,1,"PK=",0,(char*)NULL);
16739 G__memvar_setup((void*)((long)(&p->PP)-(long)(p)),102,0,0,-1,-1,-1,1,"PP=",0,(char*)NULL);
16740 G__memvar_setup((void*)((long)(&p->NK)-(long)(p)),102,0,0,-1,-1,-1,1,"NK=",0,(char*)NULL);
16741 G__memvar_setup((void*)((long)(&p->QF)-(long)(p)),105,0,0,-1,-1,-1,1,"QF=",0,(char*)NULL);
16742 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16743 }
16744 G__tag_memvar_reset();
16745 }
16746
16747
16748
16749 static void G__setup_memvarEFOL(void) {
16750 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EFOL));
16751 { EFOL *p; p=(EFOL*)0x1000; if (p) { }
16752 G__memvar_setup((void*)((long)(&p->PX)-(long)(p)),102,0,0,-1,-1,-1,1,"PX=",0,(char*)NULL);
16753 G__memvar_setup((void*)((long)(&p->PY)-(long)(p)),102,0,0,-1,-1,-1,1,"PY=",0,(char*)NULL);
16754 G__memvar_setup((void*)((long)(&p->PZ)-(long)(p)),102,0,0,-1,-1,-1,1,"PZ=",0,(char*)NULL);
16755 G__memvar_setup((void*)((long)(&p->EW)-(long)(p)),102,0,0,-1,-1,-1,1,"EW=",0,(char*)NULL);
16756 G__memvar_setup((void*)((long)(&p->WE)-(long)(p)),102,0,0,-1,-1,-1,1,"WE=",0,(char*)NULL);
16757 G__memvar_setup((void*)((long)(&p->TY)-(long)(p)),114,0,0,-1,-1,-1,1,"TY=",0,(char*)NULL);
16758 G__memvar_setup((void*)((long)(&p->LE)-(long)(p)),115,0,0,-1,-1,-1,1,"LE=",0,(char*)NULL);
16759 G__memvar_setup((void*)((long)(&p->LT)-(long)(p)),115,0,0,-1,-1,-1,1,"LT=",0,(char*)NULL);
16760 G__memvar_setup((void*)((long)(&p->LH)-(long)(p)),115,0,0,-1,-1,-1,1,"LH=",0,(char*)NULL);
16761 G__memvar_setup((void*)((long)(&p->LC)-(long)(p)),115,0,0,-1,-1,-1,1,"LC=",0,(char*)NULL);
16762 G__memvar_setup((void*)((long)(&p->LJ)-(long)(p)),115,0,0,-1,-1,-1,1,"LJ=",0,(char*)NULL);
16763 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16764 }
16765 G__tag_memvar_reset();
16766 }
16767
16768
16769
16770 static void G__setup_memvarPCQA(void) {
16771 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PCQA));
16772 { PCQA *p; p=(PCQA*)0x1000; if (p) { }
16773 G__memvar_setup((void*)((long)(&p->NA)-(long)(p)),114,0,0,-1,-1,-1,1,"NA=",0,(char*)NULL);
16774 G__memvar_setup((void*)((long)(&p->PX)-(long)(p)),102,0,0,-1,-1,-1,1,"PX=",0,(char*)NULL);
16775 G__memvar_setup((void*)((long)(&p->PY)-(long)(p)),102,0,0,-1,-1,-1,1,"PY=",0,(char*)NULL);
16776 G__memvar_setup((void*)((long)(&p->PZ)-(long)(p)),102,0,0,-1,-1,-1,1,"PZ=",0,(char*)NULL);
16777 G__memvar_setup((void*)((long)(&p->EN)-(long)(p)),102,0,0,-1,-1,-1,1,"EN=",0,(char*)NULL);
16778 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16779 }
16780 G__tag_memvar_reset();
16781 }
16782
16783
16784
16785 static void G__setup_memvarEGPC(void) {
16786 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EGPC));
16787 { EGPC *p; p=(EGPC*)0x1000; if (p) { }
16788 G__memvar_setup((void*)((long)(&p->PX)-(long)(p)),102,0,0,-1,-1,-1,1,"PX=",0,(char*)NULL);
16789 G__memvar_setup((void*)((long)(&p->PY)-(long)(p)),102,0,0,-1,-1,-1,1,"PY=",0,(char*)NULL);
16790 G__memvar_setup((void*)((long)(&p->PZ)-(long)(p)),102,0,0,-1,-1,-1,1,"PZ=",0,(char*)NULL);
16791 G__memvar_setup((void*)((long)(&p->R1)-(long)(p)),102,0,0,-1,-1,-1,1,"R1=",0,(char*)NULL);
16792 G__memvar_setup((void*)((long)(&p->R2)-(long)(p)),102,0,0,-1,-1,-1,1,"R2=",0,(char*)NULL);
16793 G__memvar_setup((void*)((long)(&p->F4)-(long)(p)),102,0,0,-1,-1,-1,1,"F4=",0,(char*)NULL);
16794 G__memvar_setup((void*)((long)(&p->DM)-(long)(p)),102,0,0,-1,-1,-1,1,"DM=",0,(char*)NULL);
16795 G__memvar_setup((void*)((long)(&p->ST)-(long)(p)),105,0,0,-1,-1,-1,1,"ST=",0,(char*)NULL);
16796 G__memvar_setup((void*)((long)(&p->QU)-(long)(p)),114,0,0,-1,-1,-1,1,"QU=",0,(char*)NULL);
16797 G__memvar_setup((void*)((long)(&p->PE)-(long)(p)),114,0,0,-1,-1,-1,1,"PE=",0,(char*)NULL);
16798 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16799 }
16800 G__tag_memvar_reset();
16801 }
16802
16803
16804
16805 static void G__setup_memvarMUID(void) {
16806 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MUID));
16807 { MUID *p; p=(MUID*)0x1000; if (p) { }
16808 G__memvar_setup((void*)((long)(&p->IF)-(long)(p)),115,0,0,-1,-1,-1,1,"IF=",0,(char*)NULL);
16809 G__memvar_setup((void*)((long)(&p->SR)-(long)(p)),102,0,0,-1,-1,-1,1,"SR=",0,(char*)NULL);
16810 G__memvar_setup((void*)((long)(&p->DM)-(long)(p)),102,0,0,-1,-1,-1,1,"DM=",0,(char*)NULL);
16811 G__memvar_setup((void*)((long)(&p->ST)-(long)(p)),114,0,0,-1,-1,-1,1,"ST=",0,(char*)NULL);
16812 G__memvar_setup((void*)((long)(&p->TN)-(long)(p)),114,0,0,-1,-1,-1,1,"TN=",0,(char*)NULL);
16813 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16814 }
16815 G__tag_memvar_reset();
16816 }
16817
16818
16819
16820 static void G__setup_memvarPGPC(void) {
16821 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGPC));
16822 { PGPC *p; p=(PGPC*)0x1000; if (p) { }
16823 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),102,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
16824 G__memvar_setup((void*)((long)(&p->TC)-(long)(p)),102,0,0,-1,-1,-1,1,"TC=",0,(char*)NULL);
16825 G__memvar_setup((void*)((long)(&p->PC)-(long)(p)),102,0,0,-1,-1,-1,1,"PC=",0,(char*)NULL);
16826 G__memvar_setup((void*)((long)(&p->R1)-(long)(p)),102,0,0,-1,-1,-1,1,"R1=",0,(char*)NULL);
16827 G__memvar_setup((void*)((long)(&p->R2)-(long)(p)),102,0,0,-1,-1,-1,1,"R2=",0,(char*)NULL);
16828 G__memvar_setup((void*)((long)(&p->F4)-(long)(p)),102,0,0,-1,-1,-1,1,"F4=",0,(char*)NULL);
16829 G__memvar_setup((void*)((long)(&p->DM)-(long)(p)),102,0,0,-1,-1,-1,1,"DM=",0,(char*)NULL);
16830 G__memvar_setup((void*)((long)(&p->ST)-(long)(p)),102,0,0,-1,-1,-1,1,"ST=",0,(char*)NULL);
16831 G__memvar_setup((void*)((long)(&p->QU)-(long)(p)),114,0,0,-1,-1,-1,1,"QU=",0,(char*)NULL);
16832 G__memvar_setup((void*)((long)(&p->Q1)-(long)(p)),102,0,0,-1,-1,-1,1,"Q1=",0,(char*)NULL);
16833 G__memvar_setup((void*)((long)(&p->Q2)-(long)(p)),102,0,0,-1,-1,-1,1,"Q2=",0,(char*)NULL);
16834 G__memvar_setup((void*)((long)(&p->M1)-(long)(p)),102,0,0,-1,-1,-1,1,"M1=",0,(char*)NULL);
16835 G__memvar_setup((void*)((long)(&p->M2)-(long)(p)),102,0,0,-1,-1,-1,1,"M2=",0,(char*)NULL);
16836 G__memvar_setup((void*)((long)(&p->MA)-(long)(p)),102,0,0,-1,-1,-1,1,"MA=",0,(char*)NULL);
16837 G__memvar_setup((void*)((long)(&p->ER)-(long)(p)),102,0,0,-1,-1,-1,1,"ER=",0,(char*)NULL);
16838 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),102,0,0,-1,-1,-1,1,"TR=",0,(char*)NULL);
16839 G__memvar_setup((void*)((long)(&p->PR)-(long)(p)),102,0,0,-1,-1,-1,1,"PR=",0,(char*)NULL);
16840 G__memvar_setup((void*)((long)(&p->PE)-(long)(p)),114,0,0,-1,-1,-1,1,"PE=",0,(char*)NULL);
16841 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16842 }
16843 G__tag_memvar_reset();
16844 }
16845
16846
16847
16848 static void G__setup_memvarPGAC(void) {
16849 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGAC));
16850 { PGAC *p; p=(PGAC*)0x1000; if (p) { }
16851 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),102,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
16852 G__memvar_setup((void*)((long)(&p->TC)-(long)(p)),102,0,0,-1,-1,-1,1,"TC=",0,(char*)NULL);
16853 G__memvar_setup((void*)((long)(&p->PC)-(long)(p)),102,0,0,-1,-1,-1,1,"PC=",0,(char*)NULL);
16854 G__memvar_setup((void*)((long)(&p->R1)-(long)(p)),102,0,0,-1,-1,-1,1,"R1=",0,(char*)NULL);
16855 G__memvar_setup((void*)((long)(&p->R2)-(long)(p)),102,0,0,-1,-1,-1,1,"R2=",0,(char*)NULL);
16856 G__memvar_setup((void*)((long)(&p->F4)-(long)(p)),102,0,0,-1,-1,-1,1,"F4=",0,(char*)NULL);
16857 G__memvar_setup((void*)((long)(&p->DM)-(long)(p)),102,0,0,-1,-1,-1,1,"DM=",0,(char*)NULL);
16858 G__memvar_setup((void*)((long)(&p->ST)-(long)(p)),105,0,0,-1,-1,-1,1,"ST=",0,(char*)NULL);
16859 G__memvar_setup((void*)((long)(&p->QU)-(long)(p)),114,0,0,-1,-1,-1,1,"QU=",0,(char*)NULL);
16860 G__memvar_setup((void*)((long)(&p->Q1)-(long)(p)),102,0,0,-1,-1,-1,1,"Q1=",0,(char*)NULL);
16861 G__memvar_setup((void*)((long)(&p->Q2)-(long)(p)),102,0,0,-1,-1,-1,1,"Q2=",0,(char*)NULL);
16862 G__memvar_setup((void*)((long)(&p->M1)-(long)(p)),102,0,0,-1,-1,-1,1,"M1=",0,(char*)NULL);
16863 G__memvar_setup((void*)((long)(&p->M2)-(long)(p)),102,0,0,-1,-1,-1,1,"M2=",0,(char*)NULL);
16864 G__memvar_setup((void*)((long)(&p->MA)-(long)(p)),102,0,0,-1,-1,-1,1,"MA=",0,(char*)NULL);
16865 G__memvar_setup((void*)((long)(&p->ER)-(long)(p)),102,0,0,-1,-1,-1,1,"ER=",0,(char*)NULL);
16866 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),102,0,0,-1,-1,-1,1,"TR=",0,(char*)NULL);
16867 G__memvar_setup((void*)((long)(&p->PR)-(long)(p)),102,0,0,-1,-1,-1,1,"PR=",0,(char*)NULL);
16868 G__memvar_setup((void*)((long)(&p->EF)-(long)(p)),102,0,0,-1,-1,-1,1,"EF=",0,(char*)NULL);
16869 G__memvar_setup((void*)((long)(&p->GC)-(long)(p)),102,0,0,-1,-1,-1,1,"GC=",0,(char*)NULL);
16870 G__memvar_setup((void*)((long)(&p->ZS)-(long)(p)),102,0,0,-1,-1,-1,1,"ZS=",0,(char*)NULL);
16871 G__memvar_setup((void*)((long)(&p->PL)-(long)(p)),102,0,0,-1,-1,-1,1,"PL=",0,(char*)NULL);
16872 G__memvar_setup((void*)((long)(&p->PH)-(long)(p)),102,0,0,-1,-1,-1,1,"PH=",0,(char*)NULL);
16873 G__memvar_setup((void*)((long)(&p->PN)-(long)(p)),114,0,0,-1,-1,-1,1,"PN=",0,(char*)NULL);
16874 G__memvar_setup((void*)((long)(&p->FA)-(long)(p)),114,0,0,-1,-1,-1,1,"FA=",0,(char*)NULL);
16875 G__memvar_setup((void*)((long)(&p->PE)-(long)(p)),114,0,0,-1,-1,-1,1,"PE=",0,(char*)NULL);
16876 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16877 }
16878 G__tag_memvar_reset();
16879 }
16880
16881
16882
16883 static void G__setup_memvarPDLT(void) {
16884 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PDLT));
16885 { PDLT *p; p=(PDLT*)0x1000; if (p) { }
16886 G__memvar_setup((void*)((long)(&p->PA)-(long)(p)),114,0,0,-1,-1,-1,1,"PA=",0,(char*)NULL);
16887 G__memvar_setup((void*)((long)(&p->JT)-(long)(p)),114,0,0,-1,-1,-1,1,"JT=",0,(char*)NULL);
16888 G__memvar_setup((void*)((long)(&p->PI)-(long)(p)),102,0,0,-1,-1,-1,1,"PI=",0,(char*)NULL);
16889 G__memvar_setup((void*)((long)(&p->PE)-(long)(p)),102,0,0,-1,-1,-1,1,"PE=",0,(char*)NULL);
16890 G__memvar_setup((void*)((long)(&p->VP)-(long)(p)),114,0,0,-1,-1,-1,1,"VP=",0,(char*)NULL);
16891 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),114,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
16892 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16893 }
16894 G__tag_memvar_reset();
16895 }
16896
16897
16898
16899 static void G__setup_memvarPMLT(void) {
16900 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PMLT));
16901 { PMLT *p; p=(PMLT*)0x1000; if (p) { }
16902 G__memvar_setup((void*)((long)(&p->FL)-(long)(p)),114,0,0,-1,-1,-1,1,"FL=",0,(char*)NULL);
16903 G__memvar_setup((void*)((long)(&p->PO)-(long)(p)),114,0,0,-1,-1,-1,1,"PO=",0,(char*)NULL);
16904 G__memvar_setup((void*)((long)(&p->CH)-(long)(p)),114,0,0,-1,-1,-1,1,"CH=",0,(char*)NULL);
16905 G__memvar_setup((void*)((long)(&p->SP)-(long)(p)),114,0,0,-1,-1,-1,1,"SP=",0,(char*)NULL);
16906 G__memvar_setup((void*)((long)(&p->LE)-(long)(p)),114,0,0,-1,-1,-1,1,"LE=",0,(char*)NULL);
16907 G__memvar_setup((void*)((long)(&p->ME)-(long)(p)),115,0,0,-1,-1,-1,1,"ME=",0,(char*)NULL);
16908 G__memvar_setup((void*)((long)(&p->KT)-(long)(p)),114,0,0,-1,-1,-1,1,"KT=",0,(char*)NULL);
16909 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),114,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
16910 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16911 }
16912 G__tag_memvar_reset();
16913 }
16914
16915
16916
16917 static void G__setup_memvarQDET(void) {
16918 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QDET));
16919 { QDET *p; p=(QDET*)0x1000; if (p) { }
16920 G__memvar_setup((void*)((long)(&p->AF)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_FRFT),-1,-1,1,"AF=",0,(char*)NULL);
16921 G__memvar_setup((void*)((long)(&p->AL)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_FRTL),-1,-1,1,"AL=",0,(char*)NULL);
16922 G__memvar_setup((void*)((long)(&p->NT)-(long)(p)),114,0,0,-1,-1,-1,1,"NT=",0,(char*)NULL);
16923 G__memvar_setup((void*)((long)(&p->AT)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TEXS),-1,-1,1,"AT[4]=",0,(char*)NULL);
16924 G__memvar_setup((void*)((long)(&p->LT)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TEXS),-1,-1,1,"LT=",0,(char*)NULL);
16925 G__memvar_setup((void*)((long)(&p->AE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_EIDT),-1,-1,1,"AE=",0,(char*)NULL);
16926 G__memvar_setup((void*)((long)(&p->AH)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_HMAD),-1,-1,1,"AH=",0,(char*)NULL);
16927 G__memvar_setup((void*)((long)(&p->AM)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_MCAD),-1,-1,1,"AM=",0,"!");
16928 G__memvar_setup((void*)((long)(&p->CF)-(long)(p)),115,0,0,-1,-1,-1,1,"CF=",0,(char*)NULL);
16929 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PECO),-1,-1,1,"EC=",0,(char*)NULL);
16930 G__memvar_setup((void*)((long)(&p->HC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PHCO),-1,-1,1,"HC=",0,(char*)NULL);
16931 G__memvar_setup((void*)((long)(&p->ET)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PEPT),-1,-1,1,"ET=",0,(char*)NULL);
16932 G__memvar_setup((void*)((long)(&p->FI)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_FRID),-1,-1,1,"FI=",0,"!");
16933 G__memvar_setup((void*)((long)(&p->NF)-(long)(p)),114,0,0,-1,-1,-1,1,"NF=",0,(char*)NULL);
16934 G__memvar_setup((void*)((long)(&p->NE)-(long)(p)),114,0,0,-1,-1,-1,1,"NE=",0,(char*)NULL);
16935 G__memvar_setup((void*)((long)(&p->NH)-(long)(p)),114,0,0,-1,-1,-1,1,"NH=",0,(char*)NULL);
16936 G__memvar_setup((void*)((long)(&p->LH)-(long)(p)),115,0,0,-1,-1,-1,1,"LH=",0,(char*)NULL);
16937 G__memvar_setup((void*)((long)(&p->EF)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_EFOL),-1,-1,1,"EF=",0,(char*)NULL);
16938 G__memvar_setup((void*)((long)(&p->PC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PCQA),-1,-1,1,"PC=",0,(char*)NULL);
16939 G__memvar_setup((void*)((long)(&p->EG)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_EGPC),-1,-1,1,"EG=",0,(char*)NULL);
16940 G__memvar_setup((void*)((long)(&p->MU)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_MUID),-1,-1,1,"MU=",0,(char*)NULL);
16941 G__memvar_setup((void*)((long)(&p->DX)-(long)(p)),114,0,0,-1,-1,-1,1,"DX=",0,(char*)NULL);
16942 G__memvar_setup((void*)((long)(&p->PG)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PGAC),-1,-1,1,"PG=",0,(char*)NULL);
16943 G__memvar_setup((void*)((long)(&p->PD)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PDLT),-1,-1,1,"PD=",0,"!");
16944 G__memvar_setup((void*)((long)(&p->PM)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_PMLT),-1,-1,1,"PM=",0,"!");
16945 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16946 }
16947 G__tag_memvar_reset();
16948 }
16949
16950
16951
16952 static void G__setup_memvarQVEC(void) {
16953 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVEC));
16954 { QVEC *p; p=(QVEC*)0x1000; if (p) { }
16955 G__memvar_setup((void*)((long)(&p->QX)-(long)(p)),102,0,0,-1,-1,-1,1,"QX=",0,(char*)NULL);
16956 G__memvar_setup((void*)((long)(&p->QY)-(long)(p)),102,0,0,-1,-1,-1,1,"QY=",0,(char*)NULL);
16957 G__memvar_setup((void*)((long)(&p->QZ)-(long)(p)),102,0,0,-1,-1,-1,1,"QZ=",0,(char*)NULL);
16958 G__memvar_setup((void*)((long)(&p->QE)-(long)(p)),102,0,0,-1,-1,-1,1,"QE=",0,(char*)NULL);
16959 G__memvar_setup((void*)((long)(&p->QM)-(long)(p)),102,0,0,-1,-1,-1,1,"QM=",0,(char*)NULL);
16960 G__memvar_setup((void*)((long)(&p->QP)-(long)(p)),102,0,0,-1,-1,-1,1,"QP=",0,(char*)NULL);
16961 G__memvar_setup((void*)((long)(&p->QCH)-(long)(p)),102,0,0,-1,-1,-1,1,"QCH=",0,(char*)NULL);
16962 G__memvar_setup((void*)((long)(&p->TN)-(long)(p)),114,0,0,-1,-1,-1,1,"TN=",0,(char*)NULL);
16963 G__memvar_setup((void*)((long)(&p->SC)-(long)(p)),105,0,0,-1,-1,-1,1,"SC=",0,(char*)NULL);
16964 G__memvar_setup((void*)((long)(&p->KS)-(long)(p)),105,0,0,-1,-1,-1,1,"KS=",0,(char*)NULL);
16965 G__memvar_setup((void*)((long)(&p->CL)-(long)(p)),105,0,0,-1,-1,-1,1,"CL=",0,(char*)NULL);
16966 G__memvar_setup((void*)((long)(&p->PA)-(long)(p)),114,0,0,-1,-1,-1,1,"PA=",0,(char*)NULL);
16967 G__memvar_setup((void*)((long)(&p->QD)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_QDET),-1,-1,1,"QD=",0,(char*)NULL);
16968 G__memvar_setup((void*)((long)(&p->NP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_QVEC),-1,-1,1,"NP=",0,(char*)NULL);
16969 G__memvar_setup((void*)((long)(&p->SP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_QVEC),-1,-1,1,"SP=",0,(char*)NULL);
16970 G__memvar_setup((void*)((long)(&p->OV)-(long)(p)),114,0,0,-1,-1,-1,1,"OV=",0,(char*)NULL);
16971 G__memvar_setup((void*)((long)(&p->EV)-(long)(p)),114,0,0,-1,-1,-1,1,"EV=",0,(char*)NULL);
16972 G__memvar_setup((void*)((long)(&p->ND)-(long)(p)),114,0,0,-1,-1,-1,1,"ND=",0,(char*)NULL);
16973 G__memvar_setup((void*)((long)(&p->DL)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),G__defined_typename("vector<unsigned short>"),-1,1,"DL=",0,(char*)NULL);
16974 G__memvar_setup((void*)((long)(&p->NO)-(long)(p)),114,0,0,-1,-1,-1,1,"NO=",0,(char*)NULL);
16975 G__memvar_setup((void*)((long)(&p->OL)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),G__defined_typename("vector<unsigned short>"),-1,1,"OL=",0,(char*)NULL);
16976 G__memvar_setup((void*)((long)(&p->NM)-(long)(p)),114,0,0,-1,-1,-1,1,"NM=",0,(char*)NULL);
16977 G__memvar_setup((void*)((long)(&p->ML)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),G__defined_typename("vector<unsigned short>"),-1,1,"ML=",0,(char*)NULL);
16978 G__memvar_setup((void*)((long)(&p->BM)-(long)(p)),105,0,0,-1,-1,-1,1,"BM[14]=",0,(char*)NULL);
16979 G__memvar_setup((void*)((long)(&p->LK)-(long)(p)),105,0,0,-1,-1,-1,1,"LK=",0,(char*)NULL);
16980 G__memvar_setup((void*)((long)(&p->DB)-(long)(p)),102,0,0,-1,-1,-1,1,"DB=",0,(char*)NULL);
16981 G__memvar_setup((void*)((long)(&p->ZB)-(long)(p)),102,0,0,-1,-1,-1,1,"ZB=",0,(char*)NULL);
16982 G__memvar_setup((void*)((long)(&p->SD)-(long)(p)),102,0,0,-1,-1,-1,1,"SD=",0,(char*)NULL);
16983 G__memvar_setup((void*)((long)(&p->SZ)-(long)(p)),102,0,0,-1,-1,-1,1,"SZ=",0,(char*)NULL);
16984 G__memvar_setup((void*)((long)(&p->CB)-(long)(p)),102,0,0,-1,-1,-1,1,"CB=",0,(char*)NULL);
16985 G__memvar_setup((void*)((long)(&p->EM)-(long)(p)),102,0,0,-1,-1,-1,1,"EM[10]=",0,(char*)NULL);
16986 G__memvar_setup((void*)((long)(&p->CF)-(long)(p)),102,0,0,-1,-1,-1,1,"CF=",0,(char*)NULL);
16987 G__memvar_setup((void*)((long)(&p->EW)-(long)(p)),102,0,0,-1,-1,-1,1,"EW=",0,(char*)NULL);
16988 G__memvar_setup((void*)((long)(&p->US)-(long)(p)),102,0,0,-1,-1,-1,1,"US[18]=",0,(char*)NULL);
16989 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16990 }
16991 G__tag_memvar_reset();
16992 }
16993
16994
16995
16996 static void G__setup_memvarYV0V(void) {
16997 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_YV0V));
16998 { YV0V *p; p=(YV0V*)0x1000; if (p) { }
16999 G__memvar_setup((void*)((long)(&p->K1)-(long)(p)),114,0,0,-1,-1,-1,1,"K1=",0,(char*)NULL);
17000 G__memvar_setup((void*)((long)(&p->K2)-(long)(p)),114,0,0,-1,-1,-1,1,"K2=",0,(char*)NULL);
17001 G__memvar_setup((void*)((long)(&p->VX)-(long)(p)),102,0,0,-1,-1,-1,1,"VX=",0,(char*)NULL);
17002 G__memvar_setup((void*)((long)(&p->VY)-(long)(p)),102,0,0,-1,-1,-1,1,"VY=",0,(char*)NULL);
17003 G__memvar_setup((void*)((long)(&p->VZ)-(long)(p)),102,0,0,-1,-1,-1,1,"VZ=",0,(char*)NULL);
17004 G__memvar_setup((void*)((long)(&p->VM)-(long)(p)),102,0,0,-1,-1,-1,1,"VM[6]=",0,(char*)NULL);
17005 G__memvar_setup((void*)((long)(&p->PX)-(long)(p)),102,0,0,-1,-1,-1,1,"PX=",0,(char*)NULL);
17006 G__memvar_setup((void*)((long)(&p->PY)-(long)(p)),102,0,0,-1,-1,-1,1,"PY=",0,(char*)NULL);
17007 G__memvar_setup((void*)((long)(&p->PZ)-(long)(p)),102,0,0,-1,-1,-1,1,"PZ=",0,(char*)NULL);
17008 G__memvar_setup((void*)((long)(&p->PM)-(long)(p)),102,0,0,-1,-1,-1,1,"PM[6]=",0,(char*)NULL);
17009 G__memvar_setup((void*)((long)(&p->X1)-(long)(p)),102,0,0,-1,-1,-1,1,"X1=",0,(char*)NULL);
17010 G__memvar_setup((void*)((long)(&p->X2)-(long)(p)),102,0,0,-1,-1,-1,1,"X2=",0,(char*)NULL);
17011 G__memvar_setup((void*)((long)(&p->XM)-(long)(p)),102,0,0,-1,-1,-1,1,"XM[3]=",0,(char*)NULL);
17012 G__memvar_setup((void*)((long)(&p->C2)-(long)(p)),102,0,0,-1,-1,-1,1,"C2=",0,(char*)NULL);
17013 G__memvar_setup((void*)((long)(&p->IC)-(long)(p)),115,0,0,-1,-1,-1,1,"IC=",0,(char*)NULL);
17014 G__memvar_setup((void*)((long)(&p->P1)-(long)(p)),102,0,0,-1,-1,-1,1,"P1[3]=",0,(char*)NULL);
17015 G__memvar_setup((void*)((long)(&p->P2)-(long)(p)),102,0,0,-1,-1,-1,1,"P2[3]=",0,(char*)NULL);
17016 G__memvar_setup((void*)((long)(&p->EP)-(long)(p)),102,0,0,-1,-1,-1,1,"EP[21]=",0,(char*)NULL);
17017 G__memvar_setup((void*)((long)(&p->DM)-(long)(p)),102,0,0,-1,-1,-1,1,"DM=",0,(char*)NULL);
17018 G__memvar_setup((void*)((long)(&p->S1)-(long)(p)),102,0,0,-1,-1,-1,1,"S1=",0,(char*)NULL);
17019 G__memvar_setup((void*)((long)(&p->S2)-(long)(p)),102,0,0,-1,-1,-1,1,"S2=",0,(char*)NULL);
17020 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17021 }
17022 G__tag_memvar_reset();
17023 }
17024
17025
17026
17027 static void G__setup_memvarFKIN(void) {
17028 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FKIN));
17029 { FKIN *p; p=(FKIN*)0x1000; if (p) { }
17030 G__memvar_setup((void*)((long)(&p->PX)-(long)(p)),102,0,0,-1,-1,-1,1,"PX=",0,(char*)NULL);
17031 G__memvar_setup((void*)((long)(&p->PY)-(long)(p)),102,0,0,-1,-1,-1,1,"PY=",0,(char*)NULL);
17032 G__memvar_setup((void*)((long)(&p->PZ)-(long)(p)),102,0,0,-1,-1,-1,1,"PZ=",0,(char*)NULL);
17033 G__memvar_setup((void*)((long)(&p->MA)-(long)(p)),102,0,0,-1,-1,-1,1,"MA=",0,(char*)NULL);
17034 G__memvar_setup((void*)((long)(&p->PA)-(long)(p)),114,0,0,-1,-1,-1,1,"PA=",0,(char*)NULL);
17035 G__memvar_setup((void*)((long)(&p->OV)-(long)(p)),114,0,0,-1,-1,-1,1,"OV=",0,(char*)NULL);
17036 G__memvar_setup((void*)((long)(&p->EV)-(long)(p)),114,0,0,-1,-1,-1,1,"EV=",0,(char*)NULL);
17037 G__memvar_setup((void*)((long)(&p->HC)-(long)(p)),105,0,0,-1,-1,-1,1,"HC=",0,(char*)NULL);
17038 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17039 }
17040 G__tag_memvar_reset();
17041 }
17042
17043
17044
17045 static void G__setup_memvarFVER(void) {
17046 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FVER));
17047 { FVER *p; p=(FVER*)0x1000; if (p) { }
17048 G__memvar_setup((void*)((long)(&p->VX)-(long)(p)),102,0,0,-1,-1,-1,1,"VX=",0,(char*)NULL);
17049 G__memvar_setup((void*)((long)(&p->VY)-(long)(p)),102,0,0,-1,-1,-1,1,"VY=",0,(char*)NULL);
17050 G__memvar_setup((void*)((long)(&p->VZ)-(long)(p)),102,0,0,-1,-1,-1,1,"VZ=",0,(char*)NULL);
17051 G__memvar_setup((void*)((long)(&p->TO)-(long)(p)),102,0,0,-1,-1,-1,1,"TO=",0,(char*)NULL);
17052 G__memvar_setup((void*)((long)(&p->IP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_FKIN),-1,-1,1,"IP=",0,(char*)NULL);
17053 G__memvar_setup((void*)((long)(&p->IS)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEFKINmUcOallocatorlEFKINmUgRsPgR),G__defined_typename("vector<FKIN*>"),-1,1,"IS=",0,(char*)NULL);
17054 G__memvar_setup((void*)((long)(&p->NS)-(long)(p)),114,0,0,-1,-1,-1,1,"NS=",0,(char*)NULL);
17055 G__memvar_setup((void*)((long)(&p->VN)-(long)(p)),99,0,0,-1,-1,-1,1,"VN[4]=",0,(char*)NULL);
17056 G__memvar_setup((void*)((long)(&p->VM)-(long)(p)),99,0,0,-1,-1,-1,1,"VM[4]=",0,(char*)NULL);
17057 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17058 }
17059 G__tag_memvar_reset();
17060 }
17061
17062
17063
17064 static void G__setup_memvarQVRT(void) {
17065 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVRT));
17066 { QVRT *p; p=(QVRT*)0x1000; if (p) { }
17067 G__memvar_setup((void*)((long)(&p->VX)-(long)(p)),102,0,0,-1,-1,-1,1,"VX=",0,(char*)NULL);
17068 G__memvar_setup((void*)((long)(&p->VY)-(long)(p)),102,0,0,-1,-1,-1,1,"VY=",0,(char*)NULL);
17069 G__memvar_setup((void*)((long)(&p->VZ)-(long)(p)),102,0,0,-1,-1,-1,1,"VZ=",0,(char*)NULL);
17070 G__memvar_setup((void*)((long)(&p->VN)-(long)(p)),114,0,0,-1,-1,-1,1,"VN=",0,(char*)NULL);
17071 G__memvar_setup((void*)((long)(&p->TY)-(long)(p)),114,0,0,-1,-1,-1,1,"TY=",0,(char*)NULL);
17072 G__memvar_setup((void*)((long)(&p->IP)-(long)(p)),114,0,0,-1,-1,-1,1,"IP=",0,(char*)NULL);
17073 G__memvar_setup((void*)((long)(&p->ND)-(long)(p)),114,0,0,-1,-1,-1,1,"ND=",0,(char*)NULL);
17074 G__memvar_setup((void*)((long)(&p->DL)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),G__defined_typename("vector<unsigned short>"),-1,1,"DL=",0,(char*)NULL);
17075 G__memvar_setup((void*)((long)(&p->AY)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_YV0V),-1,-1,1,"AY=",0,(char*)NULL);
17076 G__memvar_setup((void*)((long)(&p->AF)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_FVER),-1,-1,1,"AF=",0,(char*)NULL);
17077 G__memvar_setup((void*)((long)(&p->EM)-(long)(p)),102,0,0,-1,-1,-1,1,"EM[6]=",0,(char*)NULL);
17078 G__memvar_setup((void*)((long)(&p->CF)-(long)(p)),102,0,0,-1,-1,-1,1,"CF=",0,(char*)NULL);
17079 G__memvar_setup((void*)((long)(&p->ET)-(long)(p)),102,0,0,-1,-1,-1,1,"ET[7]=",0,(char*)NULL);
17080 G__memvar_setup((void*)((long)(&p->US)-(long)(p)),102,0,0,-1,-1,-1,1,"US=",0,(char*)NULL);
17081 G__memvar_setup((void*)((long)(&p->PK)-(long)(p)),102,0,0,-1,-1,-1,1,"PK=",0,(char*)NULL);
17082 G__memvar_setup((void*)((long)(&p->PT)-(long)(p)),102,0,0,-1,-1,-1,1,"PT=",0,(char*)NULL);
17083 G__memvar_setup((void*)((long)(&p->PL)-(long)(p)),102,0,0,-1,-1,-1,1,"PL=",0,(char*)NULL);
17084 G__memvar_setup((void*)((long)(&p->HY)-(long)(p)),105,0,0,-1,-1,-1,1,"HY=",0,(char*)NULL);
17085 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17086 }
17087 G__tag_memvar_reset();
17088 }
17089
17090
17091
17092 static void G__setup_memvarALPB(void) {
17093 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALPB));
17094 { ALPB *p; p=(ALPB*)0x1000; if (p) { }
17095 G__memvar_setup((void*)((long)(&p->FE)-(long)(p)),105,0,0,-1,-1,-1,1,"FE=",0,(char*)NULL);
17096 G__memvar_setup((void*)((long)(&p->XP)-(long)(p)),105,0,0,-1,-1,-1,1,"XP=",0,(char*)NULL);
17097 G__memvar_setup((void*)((long)(&p->XE)-(long)(p)),105,0,0,-1,-1,-1,1,"XE=",0,(char*)NULL);
17098 G__memvar_setup((void*)((long)(&p->YP)-(long)(p)),105,0,0,-1,-1,-1,1,"YP=",0,(char*)NULL);
17099 G__memvar_setup((void*)((long)(&p->YE)-(long)(p)),105,0,0,-1,-1,-1,1,"YE=",0,(char*)NULL);
17100 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17101 }
17102 G__tag_memvar_reset();
17103 }
17104
17105
17106
17107 static void G__setup_memvarALRP(void) {
17108 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALRP));
17109 { ALRP *p; p=(ALRP*)0x1000; if (p) { }
17110 G__memvar_setup((void*)((long)(&p->PN)-(long)(p)),105,0,0,-1,-1,-1,1,"PN=",0,(char*)NULL);
17111 G__memvar_setup((void*)((long)(&p->WE)-(long)(p)),105,0,0,-1,-1,-1,1,"WE=",0,(char*)NULL);
17112 G__memvar_setup((void*)((long)(&p->ER)-(long)(p)),114,0,0,-1,-1,-1,1,"ER=",0,(char*)NULL);
17113 G__memvar_setup((void*)((long)(&p->XS)-(long)(p)),102,0,0,-1,-1,-1,1,"XS=",0,(char*)NULL);
17114 G__memvar_setup((void*)((long)(&p->YS)-(long)(p)),102,0,0,-1,-1,-1,1,"YS=",0,(char*)NULL);
17115 G__memvar_setup((void*)((long)(&p->ZS)-(long)(p)),102,0,0,-1,-1,-1,1,"ZS=",0,(char*)NULL);
17116 G__memvar_setup((void*)((long)(&p->XR)-(long)(p)),102,0,0,-1,-1,-1,1,"XR=",0,(char*)NULL);
17117 G__memvar_setup((void*)((long)(&p->YR)-(long)(p)),102,0,0,-1,-1,-1,1,"YR=",0,(char*)NULL);
17118 G__memvar_setup((void*)((long)(&p->F1)-(long)(p)),102,0,0,-1,-1,-1,1,"F1=",0,(char*)NULL);
17119 G__memvar_setup((void*)((long)(&p->M1)-(long)(p)),102,0,0,-1,-1,-1,1,"M1=",0,(char*)NULL);
17120 G__memvar_setup((void*)((long)(&p->S1)-(long)(p)),102,0,0,-1,-1,-1,1,"S1=",0,(char*)NULL);
17121 G__memvar_setup((void*)((long)(&p->M2)-(long)(p)),102,0,0,-1,-1,-1,1,"M2=",0,(char*)NULL);
17122 G__memvar_setup((void*)((long)(&p->S2)-(long)(p)),102,0,0,-1,-1,-1,1,"S2=",0,(char*)NULL);
17123 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17124 }
17125 G__tag_memvar_reset();
17126 }
17127
17128
17129
17130 static void G__setup_memvarRNL2(void) {
17131 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNL2));
17132 { RNL2 *p; p=(RNL2*)0x1000; if (p) { }
17133 G__memvar_setup((void*)((long)(&p->DA)-(long)(p)),105,0,0,-1,-1,-1,1,"DA=",0,(char*)NULL);
17134 G__memvar_setup((void*)((long)(&p->TI)-(long)(p)),105,0,0,-1,-1,-1,1,"TI=",0,(char*)NULL);
17135 G__memvar_setup((void*)((long)(&p->EN)-(long)(p)),102,0,0,-1,-1,-1,1,"EN=",0,(char*)NULL);
17136 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17137 }
17138 G__tag_memvar_reset();
17139 }
17140
17141
17142
17143 static void G__setup_memvarRNF2(void) {
17144 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNF2));
17145 { RNF2 *p; p=(RNF2*)0x1000; if (p) { }
17146 G__memvar_setup((void*)((long)(&p->FN)-(long)(p)),105,0,0,-1,-1,-1,1,"FN=",0,(char*)NULL);
17147 G__memvar_setup((void*)((long)(&p->DS)-(long)(p)),105,0,0,-1,-1,-1,1,"DS=",0,(char*)NULL);
17148 G__memvar_setup((void*)((long)(&p->TS)-(long)(p)),105,0,0,-1,-1,-1,1,"TS=",0,(char*)NULL);
17149 G__memvar_setup((void*)((long)(&p->DE)-(long)(p)),105,0,0,-1,-1,-1,1,"DE=",0,(char*)NULL);
17150 G__memvar_setup((void*)((long)(&p->TE)-(long)(p)),105,0,0,-1,-1,-1,1,"TE=",0,(char*)NULL);
17151 G__memvar_setup((void*)((long)(&p->FS)-(long)(p)),105,0,0,-1,-1,-1,1,"FS=",0,(char*)NULL);
17152 G__memvar_setup((void*)((long)(&p->LS)-(long)(p)),105,0,0,-1,-1,-1,1,"LS=",0,(char*)NULL);
17153 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17154 }
17155 G__tag_memvar_reset();
17156 }
17157
17158
17159
17160 static void G__setup_memvarRNR2(void) {
17161 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNR2));
17162 { RNR2 *p; p=(RNR2*)0x1000; if (p) { }
17163 G__memvar_setup((void*)((long)(&p->RN)-(long)(p)),105,0,0,-1,-1,-1,1,"RN=",0,(char*)NULL);
17164 G__memvar_setup((void*)((long)(&p->EN)-(long)(p)),102,0,0,-1,-1,-1,1,"EN=",0,(char*)NULL);
17165 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17166 }
17167 G__tag_memvar_reset();
17168 }
17169
17170
17171
17172 static void G__setup_memvarRLEP(void) {
17173 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RLEP));
17174 { RLEP *p; p=(RLEP*)0x1000; if (p) { }
17175 G__memvar_setup((void*)((long)(&p->LE)-(long)(p)),105,0,0,-1,-1,-1,1,"LE=",0,(char*)NULL);
17176 G__memvar_setup((void*)((long)(&p->LB)-(long)(p)),99,0,0,-1,-1,-1,1,"LB[4]=",0,(char*)NULL);
17177 G__memvar_setup((void*)((long)(&p->LD)-(long)(p)),105,0,0,-1,-1,-1,1,"LD=",0,(char*)NULL);
17178 G__memvar_setup((void*)((long)(&p->LF)-(long)(p)),105,0,0,-1,-1,-1,1,"LF=",0,(char*)NULL);
17179 G__memvar_setup((void*)((long)(&p->LP)-(long)(p)),105,0,0,-1,-1,-1,1,"LP=",0,(char*)NULL);
17180 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17181 }
17182 G__tag_memvar_reset();
17183 }
17184
17185
17186
17187 static void G__setup_memvarLFIL(void) {
17188 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LFIL));
17189 { LFIL *p; p=(LFIL*)0x1000; if (p) { }
17190 G__memvar_setup((void*)((long)(&p->LF)-(long)(p)),105,0,0,-1,-1,-1,1,"LF=",0,(char*)NULL);
17191 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),105,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
17192 G__memvar_setup((void*)((long)(&p->LR)-(long)(p)),105,0,0,-1,-1,-1,1,"LR=",0,(char*)NULL);
17193 G__memvar_setup((void*)((long)(&p->NV)-(long)(p)),105,0,0,-1,-1,-1,1,"NV=",0,(char*)NULL);
17194 G__memvar_setup((void*)((long)(&p->LE)-(long)(p)),102,0,0,-1,-1,-1,1,"LE=",0,(char*)NULL);
17195 G__memvar_setup((void*)((long)(&p->BX)-(long)(p)),102,0,0,-1,-1,-1,1,"BX=",0,(char*)NULL);
17196 G__memvar_setup((void*)((long)(&p->BY)-(long)(p)),102,0,0,-1,-1,-1,1,"BY=",0,(char*)NULL);
17197 G__memvar_setup((void*)((long)(&p->BZ)-(long)(p)),102,0,0,-1,-1,-1,1,"BZ=",0,(char*)NULL);
17198 G__memvar_setup((void*)((long)(&p->EX)-(long)(p)),102,0,0,-1,-1,-1,1,"EX=",0,(char*)NULL);
17199 G__memvar_setup((void*)((long)(&p->EY)-(long)(p)),102,0,0,-1,-1,-1,1,"EY=",0,(char*)NULL);
17200 G__memvar_setup((void*)((long)(&p->EZ)-(long)(p)),102,0,0,-1,-1,-1,1,"EZ=",0,(char*)NULL);
17201 G__memvar_setup((void*)((long)(&p->OF)-(long)(p)),102,0,0,-1,-1,-1,1,"OF=",0,(char*)NULL);
17202 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17203 }
17204 G__tag_memvar_reset();
17205 }
17206
17207
17208
17209 static void G__setup_memvarEVEH(void) {
17210 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EVEH));
17211 { EVEH *p; p=(EVEH*)0x1000; if (p) { }
17212 G__memvar_setup((void*)((long)(&p->EN)-(long)(p)),114,0,0,-1,-1,-1,1,"EN=",0,(char*)NULL);
17213 G__memvar_setup((void*)((long)(&p->RN)-(long)(p)),105,0,0,-1,-1,-1,1,"RN=",0,(char*)NULL);
17214 G__memvar_setup((void*)((long)(&p->RT)-(long)(p)),105,0,0,-1,-1,-1,1,"RT=",0,(char*)NULL);
17215 G__memvar_setup((void*)((long)(&p->DA)-(long)(p)),105,0,0,-1,-1,-1,1,"DA=",0,(char*)NULL);
17216 G__memvar_setup((void*)((long)(&p->TI)-(long)(p)),105,0,0,-1,-1,-1,1,"TI=",0,(char*)NULL);
17217 G__memvar_setup((void*)((long)(&p->EV)-(long)(p)),105,0,0,-1,-1,-1,1,"EV=",0,(char*)NULL);
17218 G__memvar_setup((void*)((long)(&p->M1)-(long)(p)),105,0,0,-1,-1,-1,1,"M1=",0,(char*)NULL);
17219 G__memvar_setup((void*)((long)(&p->M2)-(long)(p)),105,0,0,-1,-1,-1,1,"M2=",0,(char*)NULL);
17220 G__memvar_setup((void*)((long)(&p->M3)-(long)(p)),105,0,0,-1,-1,-1,1,"M3=",0,(char*)NULL);
17221 G__memvar_setup((void*)((long)(&p->M4)-(long)(p)),105,0,0,-1,-1,-1,1,"M4=",0,(char*)NULL);
17222 G__memvar_setup((void*)((long)(&p->TY)-(long)(p)),105,0,0,-1,-1,-1,1,"TY=",0,(char*)NULL);
17223 G__memvar_setup((void*)((long)(&p->ES)-(long)(p)),105,0,0,-1,-1,-1,1,"ES=",0,(char*)NULL);
17224 G__memvar_setup((void*)((long)(&p->TE)-(long)(p)),105,0,0,-1,-1,-1,1,"TE=",0,(char*)NULL);
17225 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17226 }
17227 G__tag_memvar_reset();
17228 }
17229
17230
17231
17232 static void G__setup_memvarKEVH(void) {
17233 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KEVH));
17234 { KEVH *p; p=(KEVH*)0x1000; if (p) { }
17235 G__memvar_setup((void*)((long)(&p->RN)-(long)(p)),105,0,0,-1,-1,-1,1,"RN=",0,(char*)NULL);
17236 G__memvar_setup((void*)((long)(&p->NT)-(long)(p)),114,0,0,-1,-1,-1,1,"NT=",0,(char*)NULL);
17237 G__memvar_setup((void*)((long)(&p->NV)-(long)(p)),114,0,0,-1,-1,-1,1,"NV=",0,(char*)NULL);
17238 G__memvar_setup((void*)((long)(&p->PI)-(long)(p)),105,0,0,-1,-1,-1,1,"PI=",0,(char*)NULL);
17239 G__memvar_setup((void*)((long)(&p->WT)-(long)(p)),102,0,0,-1,-1,-1,1,"WT=",0,(char*)NULL);
17240 G__memvar_setup((void*)((long)(&p->SR)-(long)(p)),105,0,0,-1,-1,-1,1,"SR=",0,(char*)NULL);
17241 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),105,0,0,-1,-1,-1,1,"TR=",0,(char*)NULL);
17242 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17243 }
17244 G__tag_memvar_reset();
17245 }
17246
17247
17248
17249 static void G__setup_memvarREVH(void) {
17250 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_REVH));
17251 { REVH *p; p=(REVH*)0x1000; if (p) { }
17252 G__memvar_setup((void*)((long)(&p->DS)-(long)(p)),105,0,0,-1,-1,-1,1,"DS=",0,(char*)NULL);
17253 G__memvar_setup((void*)((long)(&p->FE)-(long)(p)),105,0,0,-1,-1,-1,1,"FE[2]=",0,(char*)NULL);
17254 G__memvar_setup((void*)((long)(&p->NE)-(long)(p)),105,0,0,-1,-1,-1,1,"NE[2]=",0,(char*)NULL);
17255 G__memvar_setup((void*)((long)(&p->SB)-(long)(p)),105,0,0,-1,-1,-1,1,"SB=",0,(char*)NULL);
17256 G__memvar_setup((void*)((long)(&p->TI)-(long)(p)),102,0,0,-1,-1,-1,1,"TI=",0,(char*)NULL);
17257 G__memvar_setup((void*)((long)(&p->RB)-(long)(p)),105,0,0,-1,-1,-1,1,"RB[2]=",0,(char*)NULL);
17258 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),105,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
17259 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17260 }
17261 G__tag_memvar_reset();
17262 }
17263
17264
17265
17266 static void G__setup_memvarLOLE(void) {
17267 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LOLE));
17268 { LOLE *p; p=(LOLE*)0x1000; if (p) { }
17269 G__memvar_setup((void*)((long)(&p->FB)-(long)(p)),105,0,0,-1,-1,-1,1,"FB[4]=",0,(char*)NULL);
17270 G__memvar_setup((void*)((long)(&p->SP)-(long)(p)),105,0,0,-1,-1,-1,1,"SP=",0,(char*)NULL);
17271 G__memvar_setup((void*)((long)(&p->TO)-(long)(p)),105,0,0,-1,-1,-1,1,"TO=",0,(char*)NULL);
17272 G__memvar_setup((void*)((long)(&p->MA)-(long)(p)),105,0,0,-1,-1,-1,1,"MA[4]=",0,(char*)NULL);
17273 G__memvar_setup((void*)((long)(&p->HV)-(long)(p)),105,0,0,-1,-1,-1,1,"HV=",0,(char*)NULL);
17274 G__memvar_setup((void*)((long)(&p->ER)-(long)(p)),105,0,0,-1,-1,-1,1,"ER=",0,(char*)NULL);
17275 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17276 }
17277 G__tag_memvar_reset();
17278 }
17279
17280
17281
17282 static void G__setup_memvarX1RG(void) {
17283 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1RG));
17284 { X1RG *p; p=(X1RG*)0x1000; if (p) { }
17285 G__memvar_setup((void*)((long)(&p->NA)-(long)(p)),99,0,0,-1,-1,-1,1,"NA[4]=",0,(char*)NULL);
17286 G__memvar_setup((void*)((long)(&p->CO)-(long)(p)),105,0,0,-1,-1,-1,1,"CO[3]=",0,(char*)NULL);
17287 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17288 }
17289 G__tag_memvar_reset();
17290 }
17291
17292
17293
17294 static void G__setup_memvarBOMB(void) {
17295 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_BOMB));
17296 { BOMB *p; p=(BOMB*)0x1000; if (p) { }
17297 G__memvar_setup((void*)((long)(&p->XX)-(long)(p)),102,0,0,-1,-1,-1,1,"XX=",0,(char*)NULL);
17298 G__memvar_setup((void*)((long)(&p->YY)-(long)(p)),102,0,0,-1,-1,-1,1,"YY=",0,(char*)NULL);
17299 G__memvar_setup((void*)((long)(&p->EE)-(long)(p)),105,0,0,-1,-1,-1,1,"EE=",0,(char*)NULL);
17300 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17301 }
17302 G__tag_memvar_reset();
17303 }
17304
17305
17306
17307 static void G__setup_memvarRUNH(void) {
17308 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RUNH));
17309 { RUNH *p; p=(RUNH*)0x1000; if (p) { }
17310 G__memvar_setup((void*)((long)(&p->EN)-(long)(p)),114,0,0,-1,-1,-1,1,"EN=",0,(char*)NULL);
17311 G__memvar_setup((void*)((long)(&p->RN)-(long)(p)),105,0,0,-1,-1,-1,1,"RN=",0,(char*)NULL);
17312 G__memvar_setup((void*)((long)(&p->RT)-(long)(p)),105,0,0,-1,-1,-1,1,"RT=",0,(char*)NULL);
17313 G__memvar_setup((void*)((long)(&p->SD)-(long)(p)),105,0,0,-1,-1,-1,1,"SD=",0,(char*)NULL);
17314 G__memvar_setup((void*)((long)(&p->ST)-(long)(p)),105,0,0,-1,-1,-1,1,"ST=",0,(char*)NULL);
17315 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),99,0,0,-1,-1,-1,1,"TT[8]=",0,(char*)NULL);
17316 G__memvar_setup((void*)((long)(&p->RC)-(long)(p)),99,0,0,-1,-1,-1,1,"RC[8]=",0,(char*)NULL);
17317 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17318 }
17319 G__tag_memvar_reset();
17320 }
17321
17322
17323
17324 static void G__setup_memvarASIM(void) {
17325 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ASIM));
17326 { ASIM *p; p=(ASIM*)0x1000; if (p) { }
17327 G__memvar_setup((void*)((long)(&p->YM)-(long)(p)),105,0,0,-1,-1,-1,1,"YM=",0,(char*)NULL);
17328 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17329 }
17330 G__tag_memvar_reset();
17331 }
17332
17333
17334
17335 static void G__setup_memvarADBR(void) {
17336 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ADBR));
17337 { ADBR *p; p=(ADBR*)0x1000; if (p) { }
17338 G__memvar_setup((void*)((long)(&p->PN)-(long)(p)),114,0,0,-1,-1,-1,1,"PN=",0,(char*)NULL);
17339 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),105,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
17340 G__memvar_setup((void*)((long)(&p->BP)-(long)(p)),114,0,0,-1,-1,-1,1,"BP=",0,(char*)NULL);
17341 G__memvar_setup((void*)((long)(&p->VD)-(long)(p)),114,0,0,-1,-1,-1,1,"VD=",0,(char*)NULL);
17342 G__memvar_setup((void*)((long)(&p->IT)-(long)(p)),114,0,0,-1,-1,-1,1,"IT=",0,(char*)NULL);
17343 G__memvar_setup((void*)((long)(&p->TP)-(long)(p)),114,0,0,-1,-1,-1,1,"TP=",0,(char*)NULL);
17344 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),114,0,0,-1,-1,-1,1,"EC=",0,(char*)NULL);
17345 G__memvar_setup((void*)((long)(&p->LC)-(long)(p)),114,0,0,-1,-1,-1,1,"LC=",0,(char*)NULL);
17346 G__memvar_setup((void*)((long)(&p->SA)-(long)(p)),114,0,0,-1,-1,-1,1,"SA=",0,(char*)NULL);
17347 G__memvar_setup((void*)((long)(&p->HC)-(long)(p)),114,0,0,-1,-1,-1,1,"HC=",0,(char*)NULL);
17348 G__memvar_setup((void*)((long)(&p->MU)-(long)(p)),114,0,0,-1,-1,-1,1,"MU=",0,(char*)NULL);
17349 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),114,0,0,-1,-1,-1,1,"TR=",0,(char*)NULL);
17350 G__memvar_setup((void*)((long)(&p->GE)-(long)(p)),114,0,0,-1,-1,-1,1,"GE=",0,(char*)NULL);
17351 G__memvar_setup((void*)((long)(&p->DB)-(long)(p)),114,0,0,-1,-1,-1,1,"DB=",0,(char*)NULL);
17352 G__memvar_setup((void*)((long)(&p->SI)-(long)(p)),114,0,0,-1,-1,-1,1,"SI=",0,(char*)NULL);
17353 G__memvar_setup((void*)((long)(&p->BE)-(long)(p)),114,0,0,-1,-1,-1,1,"BE=",0,(char*)NULL);
17354 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17355 }
17356 G__tag_memvar_reset();
17357 }
17358
17359
17360
17361 static void G__setup_memvarXTBN(void) {
17362 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTBN));
17363 { XTBN *p; p=(XTBN*)0x1000; if (p) { }
17364 G__memvar_setup((void*)((long)(&p->ID)-(long)(p)),105,0,0,-1,-1,-1,1,"ID=",0,(char*)NULL);
17365 G__memvar_setup((void*)((long)(&p->VR)-(long)(p)),105,0,0,-1,-1,-1,1,"VR[2]=",0,(char*)NULL);
17366 G__memvar_setup((void*)((long)(&p->TN)-(long)(p)),114,0,0,-1,-1,-1,1,"TN=",0,(char*)NULL);
17367 G__memvar_setup((void*)((long)(&p->TB)-(long)(p)),114,0,0,-1,-1,-1,1,"TB=",0,(char*)NULL);
17368 G__memvar_setup((void*)((long)(&p->BM)-(long)(p)),99,0,0,-1,-1,-1,1,"BM[8]=",0,(char*)NULL);
17369 G__memvar_setup((void*)((long)(&p->BN)-(long)(p)),99,0,0,-1,-1,-1,1,"BN[40]=",0,(char*)NULL);
17370 G__memvar_setup((void*)((long)(&p->AD)-(long)(p)),99,0,0,-1,-1,-1,1,"AD[20]=",0,(char*)NULL);
17371 G__memvar_setup((void*)((long)(&p->L1)-(long)(p)),105,0,0,-1,-1,-1,1,"L1=",0,(char*)NULL);
17372 G__memvar_setup((void*)((long)(&p->L2)-(long)(p)),105,0,0,-1,-1,-1,1,"L2=",0,(char*)NULL);
17373 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17374 }
17375 G__tag_memvar_reset();
17376 }
17377
17378
17379
17380 static void G__setup_memvarXTCN(void) {
17381 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTCN));
17382 { XTCN *p; p=(XTCN*)0x1000; if (p) { }
17383 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),105,0,0,-1,-1,-1,1,"TT[2]=",0,(char*)NULL);
17384 G__memvar_setup((void*)((long)(&p->GC)-(long)(p)),105,0,0,-1,-1,-1,1,"GC=",0,(char*)NULL);
17385 G__memvar_setup((void*)((long)(&p->LL)-(long)(p)),105,0,0,-1,-1,-1,1,"LL=",0,(char*)NULL);
17386 G__memvar_setup((void*)((long)(&p->BN)-(long)(p)),105,0,0,-1,-1,-1,1,"BN=",0,(char*)NULL);
17387 G__memvar_setup((void*)((long)(&p->CL)-(long)(p)),105,0,0,-1,-1,-1,1,"CL=",0,(char*)NULL);
17388 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),105,0,0,-1,-1,-1,1,"TR[10]=",0,(char*)NULL);
17389 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17390 }
17391 G__tag_memvar_reset();
17392 }
17393
17394
17395
17396 static void G__setup_memvarXTOP(void) {
17397 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTOP));
17398 { XTOP *p; p=(XTOP*)0x1000; if (p) { }
17399 G__memvar_setup((void*)((long)(&p->ID)-(long)(p)),105,0,0,-1,-1,-1,1,"ID=",0,(char*)NULL);
17400 G__memvar_setup((void*)((long)(&p->VR)-(long)(p)),105,0,0,-1,-1,-1,1,"VR[2]=",0,(char*)NULL);
17401 G__memvar_setup((void*)((long)(&p->NA)-(long)(p)),105,0,0,-1,-1,-1,1,"NA[2]=",0,(char*)NULL);
17402 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),105,0,0,-1,-1,-1,1,"TR=",0,(char*)NULL);
17403 G__memvar_setup((void*)((long)(&p->GS)-(long)(p)),105,0,0,-1,-1,-1,1,"GS=",0,(char*)NULL);
17404 G__memvar_setup((void*)((long)(&p->DS)-(long)(p)),105,0,0,-1,-1,-1,1,"DS[8]=",0,(char*)NULL);
17405 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),114,0,0,-1,-1,-1,1,"TT=",0,(char*)NULL);
17406 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17407 }
17408 G__tag_memvar_reset();
17409 }
17410
17411
17412
17413 static void G__setup_memvarLUPA(void) {
17414 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LUPA));
17415 { LUPA *p; p=(LUPA*)0x1000; if (p) { }
17416 G__memvar_setup((void*)((long)(&p->GB)-(long)(p)),105,0,0,-1,-1,-1,1,"GB=",0,(char*)NULL);
17417 G__memvar_setup((void*)((long)(&p->HV)-(long)(p)),105,0,0,-1,-1,-1,1,"HV=",0,(char*)NULL);
17418 G__memvar_setup((void*)((long)(&p->T1)-(long)(p)),105,0,0,-1,-1,-1,1,"T1=",0,(char*)NULL);
17419 G__memvar_setup((void*)((long)(&p->L2)-(long)(p)),105,0,0,-1,-1,-1,1,"L2=",0,(char*)NULL);
17420 G__memvar_setup((void*)((long)(&p->TE)-(long)(p)),105,0,0,-1,-1,-1,1,"TE=",0,(char*)NULL);
17421 G__memvar_setup((void*)((long)(&p->LO)-(long)(p)),105,0,0,-1,-1,-1,1,"LO=",0,(char*)NULL);
17422 G__memvar_setup((void*)((long)(&p->AM)-(long)(p)),105,0,0,-1,-1,-1,1,"AM=",0,(char*)NULL);
17423 G__memvar_setup((void*)((long)(&p->MD)-(long)(p)),105,0,0,-1,-1,-1,1,"MD=",0,(char*)NULL);
17424 G__memvar_setup((void*)((long)(&p->EF)-(long)(p)),102,0,0,-1,-1,-1,1,"EF=",0,(char*)NULL);
17425 G__memvar_setup((void*)((long)(&p->EC)-(long)(p)),102,0,0,-1,-1,-1,1,"EC[2]=",0,(char*)NULL);
17426 G__memvar_setup((void*)((long)(&p->EW)-(long)(p)),102,0,0,-1,-1,-1,1,"EW[2]=",0,(char*)NULL);
17427 G__memvar_setup((void*)((long)(&p->XC)-(long)(p)),102,0,0,-1,-1,-1,1,"XC[2]=",0,(char*)NULL);
17428 G__memvar_setup((void*)((long)(&p->YC)-(long)(p)),102,0,0,-1,-1,-1,1,"YC[2]=",0,(char*)NULL);
17429 G__memvar_setup((void*)((long)(&p->TC)-(long)(p)),102,0,0,-1,-1,-1,1,"TC[2]=",0,(char*)NULL);
17430 G__memvar_setup((void*)((long)(&p->PC)-(long)(p)),102,0,0,-1,-1,-1,1,"PC[2]=",0,(char*)NULL);
17431 G__memvar_setup((void*)((long)(&p->AX)-(long)(p)),102,0,0,-1,-1,-1,1,"AX[2]=",0,(char*)NULL);
17432 G__memvar_setup((void*)((long)(&p->AY)-(long)(p)),102,0,0,-1,-1,-1,1,"AY[2]=",0,(char*)NULL);
17433 G__memvar_setup((void*)((long)(&p->XX)-(long)(p)),102,0,0,-1,-1,-1,1,"XX[2]=",0,(char*)NULL);
17434 G__memvar_setup((void*)((long)(&p->YY)-(long)(p)),102,0,0,-1,-1,-1,1,"YY[2]=",0,(char*)NULL);
17435 G__memvar_setup((void*)((long)(&p->XY)-(long)(p)),102,0,0,-1,-1,-1,1,"XY[2]=",0,(char*)NULL);
17436 G__memvar_setup((void*)((long)(&p->XA)-(long)(p)),102,0,0,-1,-1,-1,1,"XA[2]=",0,(char*)NULL);
17437 G__memvar_setup((void*)((long)(&p->YA)-(long)(p)),102,0,0,-1,-1,-1,1,"YA[2]=",0,(char*)NULL);
17438 G__memvar_setup((void*)((long)(&p->XD)-(long)(p)),102,0,0,-1,-1,-1,1,"XD[2]=",0,(char*)NULL);
17439 G__memvar_setup((void*)((long)(&p->YD)-(long)(p)),102,0,0,-1,-1,-1,1,"YD[2]=",0,(char*)NULL);
17440 G__memvar_setup((void*)((long)(&p->AD)-(long)(p)),114,0,0,-1,-1,-1,1,"AD[2]=",0,(char*)NULL);
17441 G__memvar_setup((void*)((long)(&p->IT)-(long)(p)),105,0,0,-1,-1,-1,1,"IT[2]=",0,(char*)NULL);
17442 G__memvar_setup((void*)((long)(&p->CT)-(long)(p)),102,0,0,-1,-1,-1,1,"CT[2]=",0,(char*)NULL);
17443 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),102,0,0,-1,-1,-1,1,"TT[2]=",0,(char*)NULL);
17444 G__memvar_setup((void*)((long)(&p->PT)-(long)(p)),102,0,0,-1,-1,-1,1,"PT[2]=",0,(char*)NULL);
17445 G__memvar_setup((void*)((long)(&p->XT)-(long)(p)),102,0,0,-1,-1,-1,1,"XT[2]=",0,(char*)NULL);
17446 G__memvar_setup((void*)((long)(&p->YT)-(long)(p)),102,0,0,-1,-1,-1,1,"YT[2]=",0,(char*)NULL);
17447 G__memvar_setup((void*)((long)(&p->E1)-(long)(p)),102,0,0,-1,-1,-1,1,"E1[2]=",0,(char*)NULL);
17448 G__memvar_setup((void*)((long)(&p->E2)-(long)(p)),102,0,0,-1,-1,-1,1,"E2[2]=",0,(char*)NULL);
17449 G__memvar_setup((void*)((long)(&p->XL)-(long)(p)),102,0,0,-1,-1,-1,1,"XL[2]=",0,(char*)NULL);
17450 G__memvar_setup((void*)((long)(&p->YL)-(long)(p)),102,0,0,-1,-1,-1,1,"YL[2]=",0,(char*)NULL);
17451 G__memvar_setup((void*)((long)(&p->AI)-(long)(p)),114,0,0,-1,-1,-1,1,"AI[2]=",0,(char*)NULL);
17452 G__memvar_setup((void*)((long)(&p->ES)-(long)(p)),102,0,0,-1,-1,-1,1,"ES[2]=",0,(char*)NULL);
17453 G__memvar_setup((void*)((long)(&p->XS)-(long)(p)),102,0,0,-1,-1,-1,1,"XS[2]=",0,(char*)NULL);
17454 G__memvar_setup((void*)((long)(&p->YS)-(long)(p)),102,0,0,-1,-1,-1,1,"YS[2]=",0,(char*)NULL);
17455 G__memvar_setup((void*)((long)(&p->AS)-(long)(p)),114,0,0,-1,-1,-1,1,"AS[2]=",0,(char*)NULL);
17456 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17457 }
17458 G__tag_memvar_reset();
17459 }
17460
17461
17462
17463 static void G__setup_memvarSILH(void) {
17464 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SILH));
17465 { SILH *p; p=(SILH*)0x1000; if (p) { }
17466 G__memvar_setup((void*)((long)(&p->GB)-(long)(p)),105,0,0,-1,-1,-1,1,"GB=",0,(char*)NULL);
17467 G__memvar_setup((void*)((long)(&p->HV)-(long)(p)),105,0,0,-1,-1,-1,1,"HV=",0,(char*)NULL);
17468 G__memvar_setup((void*)((long)(&p->T1)-(long)(p)),105,0,0,-1,-1,-1,1,"T1=",0,(char*)NULL);
17469 G__memvar_setup((void*)((long)(&p->T2)-(long)(p)),105,0,0,-1,-1,-1,1,"T2=",0,(char*)NULL);
17470 G__memvar_setup((void*)((long)(&p->TE)-(long)(p)),105,0,0,-1,-1,-1,1,"TE=",0,(char*)NULL);
17471 G__memvar_setup((void*)((long)(&p->LO)-(long)(p)),105,0,0,-1,-1,-1,1,"LO=",0,(char*)NULL);
17472 G__memvar_setup((void*)((long)(&p->S2)-(long)(p)),105,0,0,-1,-1,-1,1,"S2=",0,(char*)NULL);
17473 G__memvar_setup((void*)((long)(&p->DW)-(long)(p)),105,0,0,-1,-1,-1,1,"DW[3]=",0,(char*)NULL);
17474 G__memvar_setup((void*)((long)(&p->SC)-(long)(p)),105,0,0,-1,-1,-1,1,"SC[3]=",0,(char*)NULL);
17475 G__memvar_setup((void*)((long)(&p->AM)-(long)(p)),105,0,0,-1,-1,-1,1,"AM=",0,(char*)NULL);
17476 G__memvar_setup((void*)((long)(&p->WI)-(long)(p)),105,0,0,-1,-1,-1,1,"WI=",0,(char*)NULL);
17477 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17478 }
17479 G__tag_memvar_reset();
17480 }
17481
17482
17483
17484 static void G__setup_memvarXHVB(void) {
17485 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XHVB));
17486 { XHVB *p; p=(XHVB*)0x1000; if (p) { }
17487 G__memvar_setup((void*)((long)(&p->RU)-(long)(p)),105,0,0,-1,-1,-1,1,"RU=",0,(char*)NULL);
17488 G__memvar_setup((void*)((long)(&p->FE)-(long)(p)),105,0,0,-1,-1,-1,1,"FE=",0,(char*)NULL);
17489 G__memvar_setup((void*)((long)(&p->LE)-(long)(p)),105,0,0,-1,-1,-1,1,"LE=",0,(char*)NULL);
17490 G__memvar_setup((void*)((long)(&p->HV)-(long)(p)),114,0,0,-1,-1,-1,1,"HV=",0,(char*)NULL);
17491 G__memvar_setup((void*)((long)(&p->DE)-(long)(p)),114,0,0,-1,-1,-1,1,"DE=",0,(char*)NULL);
17492 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17493 }
17494 G__tag_memvar_reset();
17495 }
17496
17497
17498
17499 static void G__setup_memvarXTEB(void) {
17500 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTEB));
17501 { XTEB *p; p=(XTEB*)0x1000; if (p) { }
17502 G__memvar_setup((void*)((long)(&p->T1)-(long)(p)),105,0,0,-1,-1,-1,1,"T1=",0,(char*)NULL);
17503 G__memvar_setup((void*)((long)(&p->T2)-(long)(p)),105,0,0,-1,-1,-1,1,"T2=",0,(char*)NULL);
17504 G__memvar_setup((void*)((long)(&p->L2)-(long)(p)),105,0,0,-1,-1,-1,1,"L2=",0,(char*)NULL);
17505 G__memvar_setup((void*)((long)(&p->HT)-(long)(p)),105,0,0,-1,-1,-1,1,"HT[12]=",0,(char*)NULL);
17506 G__memvar_setup((void*)((long)(&p->HW)-(long)(p)),105,0,0,-1,-1,-1,1,"HW[12]=",0,(char*)NULL);
17507 G__memvar_setup((void*)((long)(&p->LW)-(long)(p)),105,0,0,-1,-1,-1,1,"LW[12]=",0,(char*)NULL);
17508 G__memvar_setup((void*)((long)(&p->EW)-(long)(p)),105,0,0,-1,-1,-1,1,"EW[12]=",0,(char*)NULL);
17509 G__memvar_setup((void*)((long)(&p->LT)-(long)(p)),105,0,0,-1,-1,-1,1,"LT[4]=",0,(char*)NULL);
17510 G__memvar_setup((void*)((long)(&p->TE)-(long)(p)),105,0,0,-1,-1,-1,1,"TE[2]=",0,(char*)NULL);
17511 G__memvar_setup((void*)((long)(&p->IT)-(long)(p)),105,0,0,-1,-1,-1,1,"IT[4]=",0,(char*)NULL);
17512 G__memvar_setup((void*)((long)(&p->TP)-(long)(p)),105,0,0,-1,-1,-1,1,"TP[4]=",0,(char*)NULL);
17513 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17514 }
17515 G__tag_memvar_reset();
17516 }
17517
17518
17519
17520 static void G__setup_memvarXTRB(void) {
17521 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTRB));
17522 { XTRB *p; p=(XTRB*)0x1000; if (p) { }
17523 G__memvar_setup((void*)((long)(&p->RP)-(long)(p)),105,0,0,-1,-1,-1,1,"RP[3]=",0,(char*)NULL);
17524 G__memvar_setup((void*)((long)(&p->RN)-(long)(p)),105,0,0,-1,-1,-1,1,"RN=",0,(char*)NULL);
17525 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17526 }
17527 G__tag_memvar_reset();
17528 }
17529
17530
17531
17532 static void G__setup_memvarDTBP(void) {
17533 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_DTBP));
17534 { DTBP *p; p=(DTBP*)0x1000; if (p) { }
17535 G__memvar_setup((void*)((long)(&p->T1)-(long)(p)),105,0,0,-1,-1,-1,1,"T1=",0,(char*)NULL);
17536 G__memvar_setup((void*)((long)(&p->T2)-(long)(p)),105,0,0,-1,-1,-1,1,"T2=",0,(char*)NULL);
17537 G__memvar_setup((void*)((long)(&p->L2)-(long)(p)),105,0,0,-1,-1,-1,1,"L2=",0,(char*)NULL);
17538 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17539 }
17540 G__tag_memvar_reset();
17541 }
17542
17543
17544
17545 static void G__setup_memvarVHBV(void) {
17546 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHBV));
17547 { VHBV *p; p=(VHBV*)0x1000; if (p) { }
17548 G__memvar_setup((void*)((long)(&p->BN)-(long)(p)),114,0,0,-1,-1,-1,1,"BN=",0,(char*)NULL);
17549 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),105,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
17550 G__memvar_setup((void*)((long)(&p->LR)-(long)(p)),105,0,0,-1,-1,-1,1,"LR=",0,(char*)NULL);
17551 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17552 }
17553 G__tag_memvar_reset();
17554 }
17555
17556
17557
17558 static void G__setup_memvarVHPV(void) {
17559 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHPV));
17560 { VHPV *p; p=(VHPV*)0x1000; if (p) { }
17561 G__memvar_setup((void*)((long)(&p->FR)-(long)(p)),105,0,0,-1,-1,-1,1,"FR=",0,(char*)NULL);
17562 G__memvar_setup((void*)((long)(&p->LR)-(long)(p)),105,0,0,-1,-1,-1,1,"LR=",0,(char*)NULL);
17563 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17564 }
17565 G__tag_memvar_reset();
17566 }
17567
17568
17569
17570 static void G__setup_memvarEAUX(void) {
17571 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EAUX));
17572 { EAUX *p; p=(EAUX*)0x1000; if (p) { }
17573 G__memvar_setup((void*)((long)(&p->TR)-(long)(p)),105,0,0,-1,-1,-1,1,"TR=",0,(char*)NULL);
17574 G__memvar_setup((void*)((long)(&p->CA)-(long)(p)),105,0,0,-1,-1,-1,1,"CA=",0,(char*)NULL);
17575 G__memvar_setup((void*)((long)(&p->HV)-(long)(p)),114,0,0,-1,-1,-1,1,"HV=",0,(char*)NULL);
17576 G__memvar_setup((void*)((long)(&p->HE)-(long)(p)),102,0,0,-1,-1,-1,1,"HE=",0,(char*)NULL);
17577 G__memvar_setup((void*)((long)(&p->HK)-(long)(p)),102,0,0,-1,-1,-1,1,"HK=",0,(char*)NULL);
17578 G__memvar_setup((void*)((long)(&p->E2)-(long)(p)),102,0,0,-1,-1,-1,1,"E2=",0,(char*)NULL);
17579 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17580 }
17581 G__tag_memvar_reset();
17582 }
17583
17584
17585
17586 static void G__setup_memvarSIX2(void) {
17587 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIX2));
17588 { SIX2 *p; p=(SIX2*)0x1000; if (p) { }
17589 G__memvar_setup((void*)((long)(&p->TW)-(long)(p)),105,0,0,-1,-1,-1,1,"TW=",0,(char*)NULL);
17590 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17591 }
17592 G__tag_memvar_reset();
17593 }
17594
17595
17596
17597 static void G__setup_memvarX1TV(void) {
17598 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TV));
17599 { X1TV *p; p=(X1TV*)0x1000; if (p) { }
17600 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),99,0,0,-1,-1,-1,1,"TT[4]=",0,(char*)NULL);
17601 G__memvar_setup((void*)((long)(&p->TV)-(long)(p)),105,0,0,-1,-1,-1,1,"TV[4]=",0,(char*)NULL);
17602 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17603 }
17604 G__tag_memvar_reset();
17605 }
17606
17607
17608
17609 static void G__setup_memvarKWGT(void) {
17610 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KWGT));
17611 { KWGT *p; p=(KWGT*)0x1000; if (p) { }
17612 G__memvar_setup((void*)((long)(&p->WN)-(long)(p)),105,0,0,-1,-1,-1,1,"WN=",0,(char*)NULL);
17613 G__memvar_setup((void*)((long)(&p->WV)-(long)(p)),102,0,0,-1,-1,-1,1,"WV=",0,(char*)NULL);
17614 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17615 }
17616 G__tag_memvar_reset();
17617 }
17618
17619
17620
17621 static void G__setup_memvarX1IP(void) {
17622 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1IP));
17623 { X1IP *p; p=(X1IP*)0x1000; if (p) { }
17624 G__memvar_setup((void*)((long)(&p->IT)-(long)(p)),99,0,0,-1,-1,-1,1,"IT[4]=",0,(char*)NULL);
17625 G__memvar_setup((void*)((long)(&p->CO)-(long)(p)),105,0,0,-1,-1,-1,1,"CO[36]=",0,(char*)NULL);
17626 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17627 }
17628 G__tag_memvar_reset();
17629 }
17630
17631
17632
17633 static void G__setup_memvarSIXA(void) {
17634 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIXA));
17635 { SIXA *p; p=(SIXA*)0x1000; if (p) { }
17636 G__memvar_setup((void*)((long)(&p->AO)-(long)(p)),105,0,0,-1,-1,-1,1,"AO=",0,(char*)NULL);
17637 G__memvar_setup((void*)((long)(&p->AE)-(long)(p)),105,0,0,-1,-1,-1,1,"AE=",0,(char*)NULL);
17638 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17639 }
17640 G__tag_memvar_reset();
17641 }
17642
17643
17644
17645 static void G__setup_memvarSITC(void) {
17646 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SITC));
17647 { SITC *p; p=(SITC*)0x1000; if (p) { }
17648 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),105,0,0,-1,-1,-1,1,"TT=",0,(char*)NULL);
17649 G__memvar_setup((void*)((long)(&p->DO)-(long)(p)),105,0,0,-1,-1,-1,1,"DO=",0,(char*)NULL);
17650 G__memvar_setup((void*)((long)(&p->DE)-(long)(p)),105,0,0,-1,-1,-1,1,"DE=",0,(char*)NULL);
17651 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17652 }
17653 G__tag_memvar_reset();
17654 }
17655
17656
17657
17658 static void G__setup_memvarSRCO(void) {
17659 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SRCO));
17660 { SRCO *p; p=(SRCO*)0x1000; if (p) { }
17661 G__memvar_setup((void*)((long)(&p->NA)-(long)(p)),99,0,0,-1,-1,-1,1,"NA[4]=",0,(char*)NULL);
17662 G__memvar_setup((void*)((long)(&p->VA)-(long)(p)),105,0,0,-1,-1,-1,1,"VA=",0,(char*)NULL);
17663 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17664 }
17665 G__tag_memvar_reset();
17666 }
17667
17668
17669
17670 static void G__setup_memvarX1TH(void) {
17671 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TH));
17672 { X1TH *p; p=(X1TH*)0x1000; if (p) { }
17673 G__memvar_setup((void*)((long)(&p->ID)-(long)(p)),105,0,0,-1,-1,-1,1,"ID=",0,(char*)NULL);
17674 G__memvar_setup((void*)((long)(&p->VR)-(long)(p)),105,0,0,-1,-1,-1,1,"VR[2]=",0,(char*)NULL);
17675 G__memvar_setup((void*)((long)(&p->TT)-(long)(p)),99,0,0,-1,-1,-1,1,"TT[4]=",0,(char*)NULL);
17676 G__memvar_setup((void*)((long)(&p->TV)-(long)(p)),105,0,0,-1,-1,-1,1,"TV[4]=",0,(char*)NULL);
17677 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17678 }
17679 G__tag_memvar_reset();
17680 }
17681
17682
17683
17684 static void G__setup_memvarX1AD(void) {
17685 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1AD));
17686 { X1AD *p; p=(X1AD*)0x1000; if (p) { }
17687 G__memvar_setup((void*)((long)(&p->IT)-(long)(p)),99,0,0,-1,-1,-1,1,"IT[4]=",0,(char*)NULL);
17688 G__memvar_setup((void*)((long)(&p->AV)-(long)(p)),105,0,0,-1,-1,-1,1,"AV[36]=",0,(char*)NULL);
17689 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17690 }
17691 G__tag_memvar_reset();
17692 }
17693
17694
17695
17696 static void G__setup_memvarQEXT(void) {
17697 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QEXT));
17698 { QEXT *p; p=(QEXT*)0x1000; if (p) { }
17699 G__memvar_setup((void*)((long)(&p->LP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_RLEP),-1,-1,1,"LP=",0,(char*)NULL);
17700 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17701 }
17702 G__tag_memvar_reset();
17703 }
17704
17705
17706
17707 static void G__setup_memvarQHAC(void) {
17708 G__tag_memvar_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QHAC));
17709 { QHAC *p; p=(QHAC*)0x1000; if (p) { }
17710 G__memvar_setup((void*)((long)(&p->EH)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_EVEH),-1,-1,1,"EH=",0,(char*)NULL);
17711 G__memvar_setup((void*)((long)(&p->RH)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_RUNH),-1,-1,1,"RH=",0,(char*)NULL);
17712 G__memvar_setup((void*)((long)(&p->AS)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_ASIM),-1,-1,1,"AS=",0,(char*)NULL);
17713 G__memvar_setup((void*)((long)(&p->KE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_KEVH),-1,-1,1,"KE=",0,(char*)NULL);
17714 G__memvar_setup((void*)((long)(&p->RE)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_REVH),-1,-1,1,"RE=",0,(char*)NULL);
17715 G__memvar_setup((void*)((long)(&p->LO)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlELOLEmUcOallocatorlELOLEmUgRsPgR),G__defined_typename("vector<LOLE*>"),-1,1,"LO=",0,"!");
17716 G__memvar_setup((void*)((long)(&p->X1)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1RGmUcOallocatorlEX1RGmUgRsPgR),G__defined_typename("vector<X1RG*>"),-1,1,"X1=",0,"!");
17717 G__memvar_setup((void*)((long)(&p->AD)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_ADBR),-1,-1,1,"AD=",0,(char*)NULL);
17718 G__memvar_setup((void*)((long)(&p->BO)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_BOMB),-1,-1,1,"BO=",0,(char*)NULL);
17719 G__memvar_setup((void*)((long)(&p->BN)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXTBNmUcOallocatorlEXTBNmUgRsPgR),G__defined_typename("vector<XTBN*>"),-1,1,"BN=",0,"!");
17720 G__memvar_setup((void*)((long)(&p->CN)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_XTCN),-1,-1,1,"CN=",0,"!");
17721 G__memvar_setup((void*)((long)(&p->OP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_XTOP),-1,-1,1,"OP=",0,"!");
17722 G__memvar_setup((void*)((long)(&p->LP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_LUPA),-1,-1,1,"LP=",0,"!");
17723 G__memvar_setup((void*)((long)(&p->SI)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_SILH),-1,-1,1,"SI=",0,"!");
17724 G__memvar_setup((void*)((long)(&p->HV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXHVBmUcOallocatorlEXHVBmUgRsPgR),G__defined_typename("vector<XHVB*>"),-1,1,"HV=",0,"!");
17725 G__memvar_setup((void*)((long)(&p->EB)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_XTEB),-1,-1,1,"EB=",0,"!");
17726 G__memvar_setup((void*)((long)(&p->RB)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_XTRB),-1,-1,1,"RB=",0,"!");
17727 G__memvar_setup((void*)((long)(&p->BP)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_DTBP),-1,-1,1,"BP=",0,"!");
17728 G__memvar_setup((void*)((long)(&p->PV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHPVmUcOallocatorlEVHPVmUgRsPgR),G__defined_typename("vector<VHPV*>"),-1,1,"PV=",0,"!");
17729 G__memvar_setup((void*)((long)(&p->BV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHBVmUcOallocatorlEVHBVmUgRsPgR),G__defined_typename("vector<VHBV*>"),-1,1,"BV=",0,"!");
17730 G__memvar_setup((void*)((long)(&p->EX)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_EAUX),-1,-1,1,"EX=",0,(char*)NULL);
17731 G__memvar_setup((void*)((long)(&p->X2)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_SIX2),-1,-1,1,"X2=",0,"!");
17732 G__memvar_setup((void*)((long)(&p->TV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1TVmUcOallocatorlEX1TVmUgRsPgR),G__defined_typename("vector<X1TV*>"),-1,1,"TV=",0,"!");
17733 G__memvar_setup((void*)((long)(&p->KW)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEKWGTmUcOallocatorlEKWGTmUgRsPgR),G__defined_typename("vector<KWGT*>"),-1,1,"KW=",0,(char*)NULL);
17734 G__memvar_setup((void*)((long)(&p->IP)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1IPmUcOallocatorlEX1IPmUgRsPgR),G__defined_typename("vector<X1IP*>"),-1,1,"IP=",0,"!");
17735 G__memvar_setup((void*)((long)(&p->XA)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESIXAmUcOallocatorlESIXAmUgRsPgR),G__defined_typename("vector<SIXA*>"),-1,1,"XA=",0,"!");
17736 G__memvar_setup((void*)((long)(&p->TC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_SITC),-1,-1,1,"TC=",0,"!");
17737 G__memvar_setup((void*)((long)(&p->CO)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESRCOmUcOallocatorlESRCOmUgRsPgR),G__defined_typename("vector<SRCO*>"),-1,1,"CO=",0,"!");
17738 G__memvar_setup((void*)((long)(&p->TH)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1THmUcOallocatorlEX1THmUgRsPgR),G__defined_typename("vector<X1TH*>"),-1,1,"TH=",0,"!");
17739 G__memvar_setup((void*)((long)(&p->XD)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1ADmUcOallocatorlEX1ADmUgRsPgR),G__defined_typename("vector<X1AD*>"),-1,1,"XD=",0,"!");
17740 G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
17741 }
17742 G__tag_memvar_reset();
17743 }
17744
17745 extern "C" void G__cpp_setup_memvarBankClassesDict() {
17746 }
17747
17748
17749
17750
17751
17752
17753
17754
17755
17756
17757
17758
17759 static void G__setup_memfuncQLIN(void) {
17760
17761 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QLIN));
17762 G__memfunc_setup("QLIN",308,G__BankClassesDict_217_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QLIN),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17763 G__memfunc_setup("Class",502,G__BankClassesDict_217_2_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17764 G__memfunc_setup("Class_Name",982,G__BankClassesDict_217_3_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17765 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_217_4_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17766 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_217_5_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17767 G__memfunc_setup("IsA",253,G__BankClassesDict_217_6_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17768 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_217_7_0,121,-1,-1,0,2,1,1,0,
17769 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17770 G__memfunc_setup("Streamer",835,G__BankClassesDict_217_8_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17771 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_217_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17772 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_217_0_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17773 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_217_1_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17774 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_217_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17775 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_217_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17776
17777 G__memfunc_setup("QLIN",308,G__BankClassesDict_217_4_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QLIN),-1,0,1,1,1,0,"u 'QLIN' - 11 - -",(char*)NULL,(void*)NULL,0);
17778
17779 G__memfunc_setup("~QLIN",434,G__BankClassesDict_217_5_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17780 G__tag_memfunc_reset();
17781 }
17782
17783 static void G__setup_memfuncQMTL(void) {
17784
17785 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTL));
17786 G__memfunc_setup("QMTL",318,G__BankClassesDict_218_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QMTL),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17787 G__memfunc_setup("Class",502,G__BankClassesDict_218_2_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17788 G__memfunc_setup("Class_Name",982,G__BankClassesDict_218_3_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17789 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_218_4_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17790 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_218_5_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17791 G__memfunc_setup("IsA",253,G__BankClassesDict_218_6_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17792 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_218_7_0,121,-1,-1,0,2,1,1,0,
17793 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17794 G__memfunc_setup("Streamer",835,G__BankClassesDict_218_8_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17795 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_218_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17796 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_218_0_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17797 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_218_1_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17798 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_218_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17799 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_218_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17800
17801 G__memfunc_setup("QMTL",318,G__BankClassesDict_218_4_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QMTL),-1,0,1,1,1,0,"u 'QMTL' - 11 - -",(char*)NULL,(void*)NULL,0);
17802
17803 G__memfunc_setup("~QMTL",444,G__BankClassesDict_218_5_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17804 G__tag_memfunc_reset();
17805 }
17806
17807 static void G__setup_memfuncQMTS(void) {
17808
17809 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTS));
17810 G__memfunc_setup("QMTS",325,G__BankClassesDict_219_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QMTS),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17811 G__memfunc_setup("Class",502,G__BankClassesDict_219_2_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17812 G__memfunc_setup("Class_Name",982,G__BankClassesDict_219_3_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17813 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_219_4_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17814 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_219_5_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17815 G__memfunc_setup("IsA",253,G__BankClassesDict_219_6_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17816 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_219_7_0,121,-1,-1,0,2,1,1,0,
17817 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17818 G__memfunc_setup("Streamer",835,G__BankClassesDict_219_8_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17819 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_219_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17820 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_219_0_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17821 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_219_1_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17822 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_219_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17823 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_219_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17824
17825 G__memfunc_setup("QMTS",325,G__BankClassesDict_219_4_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QMTS),-1,0,1,1,1,0,"u 'QMTS' - 11 - -",(char*)NULL,(void*)NULL,0);
17826
17827 G__memfunc_setup("~QMTS",451,G__BankClassesDict_219_5_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17828 G__tag_memfunc_reset();
17829 }
17830
17831 static void G__setup_memfuncFRFT(void) {
17832
17833 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRFT));
17834 G__memfunc_setup("FRFT",306,G__BankClassesDict_220_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_FRFT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17835 G__memfunc_setup("Assign",613,G__BankClassesDict_220_2_0,121,-1,-1,0,1,1,1,0,"U 'FRFT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17836 G__memfunc_setup("Class",502,G__BankClassesDict_220_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17837 G__memfunc_setup("Class_Name",982,G__BankClassesDict_220_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17838 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_220_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17839 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_220_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17840 G__memfunc_setup("IsA",253,G__BankClassesDict_220_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17841 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_220_8_0,121,-1,-1,0,2,1,1,0,
17842 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17843 G__memfunc_setup("Streamer",835,G__BankClassesDict_220_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17844 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_220_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17845 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_220_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17846 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_220_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17847 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_220_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17848 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_220_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17849
17850 G__memfunc_setup("FRFT",306,G__BankClassesDict_220_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_FRFT),-1,0,1,1,1,0,"u 'FRFT' - 11 - -",(char*)NULL,(void*)NULL,0);
17851
17852 G__memfunc_setup("~FRFT",432,G__BankClassesDict_220_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17853 G__tag_memfunc_reset();
17854 }
17855
17856 static void G__setup_memfuncFRTL(void) {
17857
17858 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRTL));
17859 G__memfunc_setup("FRTL",312,G__BankClassesDict_221_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_FRTL),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17860 G__memfunc_setup("Assign",613,G__BankClassesDict_221_2_0,121,-1,-1,0,1,1,1,0,"U 'FRTL_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17861 G__memfunc_setup("Class",502,G__BankClassesDict_221_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17862 G__memfunc_setup("Class_Name",982,G__BankClassesDict_221_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17863 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_221_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17864 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_221_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17865 G__memfunc_setup("IsA",253,G__BankClassesDict_221_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17866 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_221_8_0,121,-1,-1,0,2,1,1,0,
17867 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17868 G__memfunc_setup("Streamer",835,G__BankClassesDict_221_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17869 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_221_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17870 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_221_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17871 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_221_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17872 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_221_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17873 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_221_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17874
17875 G__memfunc_setup("FRTL",312,G__BankClassesDict_221_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_FRTL),-1,0,1,1,1,0,"u 'FRTL' - 11 - -",(char*)NULL,(void*)NULL,0);
17876
17877 G__memfunc_setup("~FRTL",438,G__BankClassesDict_221_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17878 G__tag_memfunc_reset();
17879 }
17880
17881 static void G__setup_memfuncTEXS(void) {
17882
17883 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_TEXS));
17884 G__memfunc_setup("TEXS",324,G__BankClassesDict_222_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_TEXS),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17885 G__memfunc_setup("Assign",613,G__BankClassesDict_222_2_0,121,-1,-1,0,1,1,1,0,"U 'TEXS_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17886 G__memfunc_setup("Class",502,G__BankClassesDict_222_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17887 G__memfunc_setup("Class_Name",982,G__BankClassesDict_222_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17888 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_222_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17889 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_222_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17890 G__memfunc_setup("IsA",253,G__BankClassesDict_222_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17891 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_222_8_0,121,-1,-1,0,2,1,1,0,
17892 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17893 G__memfunc_setup("Streamer",835,G__BankClassesDict_222_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17894 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_222_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17895 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_222_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17896 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_222_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17897 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_222_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17898 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_222_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17899
17900 G__memfunc_setup("TEXS",324,G__BankClassesDict_222_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_TEXS),-1,0,1,1,1,0,"u 'TEXS' - 11 - -",(char*)NULL,(void*)NULL,0);
17901
17902 G__memfunc_setup("~TEXS",450,G__BankClassesDict_222_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17903 G__tag_memfunc_reset();
17904 }
17905
17906 static void G__setup_memfuncHMAD(void) {
17907
17908 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_HMAD));
17909 G__memfunc_setup("HMAD",282,G__BankClassesDict_223_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_HMAD),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17910 G__memfunc_setup("Assign",613,G__BankClassesDict_223_2_0,121,-1,-1,0,1,1,1,0,"U 'HMAD_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17911 G__memfunc_setup("Class",502,G__BankClassesDict_223_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17912 G__memfunc_setup("Class_Name",982,G__BankClassesDict_223_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17913 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_223_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17914 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_223_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17915 G__memfunc_setup("IsA",253,G__BankClassesDict_223_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17916 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_223_8_0,121,-1,-1,0,2,1,1,0,
17917 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17918 G__memfunc_setup("Streamer",835,G__BankClassesDict_223_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17919 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_223_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17920 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_223_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17921 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_223_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17922 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_223_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17923 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_223_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17924
17925 G__memfunc_setup("HMAD",282,G__BankClassesDict_223_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_HMAD),-1,0,1,1,1,0,"u 'HMAD' - 11 - -",(char*)NULL,(void*)NULL,0);
17926
17927 G__memfunc_setup("~HMAD",408,G__BankClassesDict_223_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17928 G__tag_memfunc_reset();
17929 }
17930
17931 static void G__setup_memfuncMCAD(void) {
17932
17933 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MCAD));
17934 G__memfunc_setup("MCAD",277,G__BankClassesDict_224_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_MCAD),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17935 G__memfunc_setup("Assign",613,G__BankClassesDict_224_2_0,121,-1,-1,0,1,1,1,0,"U 'MCAD_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17936 G__memfunc_setup("Class",502,G__BankClassesDict_224_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17937 G__memfunc_setup("Class_Name",982,G__BankClassesDict_224_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17938 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_224_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17939 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_224_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17940 G__memfunc_setup("IsA",253,G__BankClassesDict_224_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17941 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_224_8_0,121,-1,-1,0,2,1,1,0,
17942 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17943 G__memfunc_setup("Streamer",835,G__BankClassesDict_224_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17944 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_224_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17945 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_224_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17946 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_224_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17947 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_224_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17948 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_224_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17949
17950 G__memfunc_setup("MCAD",277,G__BankClassesDict_224_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_MCAD),-1,0,1,1,1,0,"u 'MCAD' - 11 - -",(char*)NULL,(void*)NULL,0);
17951
17952 G__memfunc_setup("~MCAD",403,G__BankClassesDict_224_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17953 G__tag_memfunc_reset();
17954 }
17955
17956 static void G__setup_memfuncPECO(void) {
17957
17958 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PECO));
17959 G__memfunc_setup("PECO",295,G__BankClassesDict_225_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PECO),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17960 G__memfunc_setup("Assign",613,G__BankClassesDict_225_2_0,121,-1,-1,0,1,1,1,0,"U 'PECO_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17961 G__memfunc_setup("Class",502,G__BankClassesDict_225_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17962 G__memfunc_setup("Class_Name",982,G__BankClassesDict_225_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17963 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_225_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17964 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_225_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17965 G__memfunc_setup("IsA",253,G__BankClassesDict_225_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17966 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_225_8_0,121,-1,-1,0,2,1,1,0,
17967 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17968 G__memfunc_setup("Streamer",835,G__BankClassesDict_225_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17969 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_225_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17970 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_225_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17971 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_225_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17972 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_225_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17973 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_225_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17974
17975 G__memfunc_setup("PECO",295,G__BankClassesDict_225_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PECO),-1,0,1,1,1,0,"u 'PECO' - 11 - -",(char*)NULL,(void*)NULL,0);
17976
17977 G__memfunc_setup("~PECO",421,G__BankClassesDict_225_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
17978 G__tag_memfunc_reset();
17979 }
17980
17981 static void G__setup_memfuncEIDT(void) {
17982
17983 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EIDT));
17984 G__memfunc_setup("EIDT",294,G__BankClassesDict_226_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_EIDT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
17985 G__memfunc_setup("Assign",613,G__BankClassesDict_226_2_0,121,-1,-1,0,1,1,1,0,"U 'EIDT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
17986 G__memfunc_setup("Class",502,G__BankClassesDict_226_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17987 G__memfunc_setup("Class_Name",982,G__BankClassesDict_226_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17988 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_226_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17989 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_226_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17990 G__memfunc_setup("IsA",253,G__BankClassesDict_226_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
17991 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_226_8_0,121,-1,-1,0,2,1,1,0,
17992 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
17993 G__memfunc_setup("Streamer",835,G__BankClassesDict_226_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
17994 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_226_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
17995 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_226_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17996 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_226_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17997 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_226_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
17998 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_226_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
17999
18000 G__memfunc_setup("EIDT",294,G__BankClassesDict_226_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_EIDT),-1,0,1,1,1,0,"u 'EIDT' - 11 - -",(char*)NULL,(void*)NULL,0);
18001
18002 G__memfunc_setup("~EIDT",420,G__BankClassesDict_226_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18003 G__tag_memfunc_reset();
18004 }
18005
18006 static void G__setup_memfuncPHCO(void) {
18007
18008 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PHCO));
18009 G__memfunc_setup("PHCO",298,G__BankClassesDict_227_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PHCO),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18010 G__memfunc_setup("Assign",613,G__BankClassesDict_227_2_0,121,-1,-1,0,1,1,1,0,"U 'PHCO_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18011 G__memfunc_setup("Class",502,G__BankClassesDict_227_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18012 G__memfunc_setup("Class_Name",982,G__BankClassesDict_227_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18013 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_227_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18014 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_227_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18015 G__memfunc_setup("IsA",253,G__BankClassesDict_227_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18016 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_227_8_0,121,-1,-1,0,2,1,1,0,
18017 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18018 G__memfunc_setup("Streamer",835,G__BankClassesDict_227_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18019 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_227_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18020 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_227_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18021 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_227_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18022 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_227_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18023 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_227_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18024
18025 G__memfunc_setup("PHCO",298,G__BankClassesDict_227_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PHCO),-1,0,1,1,1,0,"u 'PHCO' - 11 - -",(char*)NULL,(void*)NULL,0);
18026
18027 G__memfunc_setup("~PHCO",424,G__BankClassesDict_227_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18028 G__tag_memfunc_reset();
18029 }
18030
18031 static void G__setup_memfuncPEPT(void) {
18032
18033 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PEPT));
18034 G__memfunc_setup("PEPT",313,G__BankClassesDict_228_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PEPT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18035 G__memfunc_setup("Assign",613,G__BankClassesDict_228_2_0,121,-1,-1,0,1,1,1,0,"U 'PEPT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18036 G__memfunc_setup("Class",502,G__BankClassesDict_228_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18037 G__memfunc_setup("Class_Name",982,G__BankClassesDict_228_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18038 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_228_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18039 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_228_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18040 G__memfunc_setup("IsA",253,G__BankClassesDict_228_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18041 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_228_8_0,121,-1,-1,0,2,1,1,0,
18042 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18043 G__memfunc_setup("Streamer",835,G__BankClassesDict_228_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18044 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_228_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18045 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_228_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18046 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_228_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18047 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_228_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18048 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_228_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18049
18050 G__memfunc_setup("PEPT",313,G__BankClassesDict_228_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PEPT),-1,0,1,1,1,0,"u 'PEPT' - 11 - -",(char*)NULL,(void*)NULL,0);
18051
18052 G__memfunc_setup("~PEPT",439,G__BankClassesDict_228_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18053 G__tag_memfunc_reset();
18054 }
18055
18056 static void G__setup_memfuncFRID(void) {
18057
18058 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRID));
18059 G__memfunc_setup("FRID",293,G__BankClassesDict_229_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_FRID),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18060 G__memfunc_setup("Assign",613,G__BankClassesDict_229_2_0,121,-1,-1,0,1,1,1,0,"U 'FRID_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18061 G__memfunc_setup("Class",502,G__BankClassesDict_229_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18062 G__memfunc_setup("Class_Name",982,G__BankClassesDict_229_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18063 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_229_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18064 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_229_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18065 G__memfunc_setup("IsA",253,G__BankClassesDict_229_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18066 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_229_8_0,121,-1,-1,0,2,1,1,0,
18067 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18068 G__memfunc_setup("Streamer",835,G__BankClassesDict_229_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18069 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_229_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18070 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_229_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18071 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_229_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18072 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_229_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18073 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_229_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18074
18075 G__memfunc_setup("FRID",293,G__BankClassesDict_229_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_FRID),-1,0,1,1,1,0,"u 'FRID' - 11 - -",(char*)NULL,(void*)NULL,0);
18076
18077 G__memfunc_setup("~FRID",419,G__BankClassesDict_229_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18078 G__tag_memfunc_reset();
18079 }
18080
18081 static void G__setup_memfuncEFOL(void) {
18082
18083 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EFOL));
18084 G__memfunc_setup("EFOL",294,G__BankClassesDict_230_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_EFOL),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18085 G__memfunc_setup("Assign",613,G__BankClassesDict_230_2_0,121,-1,-1,0,1,1,1,0,"U 'EFOL_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18086 G__memfunc_setup("Assign",613,G__BankClassesDict_230_3_0,121,-1,-1,0,1,1,1,0,"U 'DENF_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18087 G__memfunc_setup("Assign",613,G__BankClassesDict_230_4_0,121,-1,-1,0,1,1,1,0,"U 'DENW_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18088 G__memfunc_setup("Class",502,G__BankClassesDict_230_5_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18089 G__memfunc_setup("Class_Name",982,G__BankClassesDict_230_6_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18090 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_230_7_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18091 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_230_8_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18092 G__memfunc_setup("IsA",253,G__BankClassesDict_230_9_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18093 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_230_0_1,121,-1,-1,0,2,1,1,0,
18094 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18095 G__memfunc_setup("Streamer",835,G__BankClassesDict_230_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18096 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_230_2_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18097 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_230_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18098 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_230_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18099 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_230_5_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18100 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_230_6_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18101
18102 G__memfunc_setup("EFOL",294,G__BankClassesDict_230_7_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_EFOL),-1,0,1,1,1,0,"u 'EFOL' - 11 - -",(char*)NULL,(void*)NULL,0);
18103
18104 G__memfunc_setup("~EFOL",420,G__BankClassesDict_230_8_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18105 G__tag_memfunc_reset();
18106 }
18107
18108 static void G__setup_memfuncPCQA(void) {
18109
18110 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PCQA));
18111 G__memfunc_setup("PCQA",293,G__BankClassesDict_231_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PCQA),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18112 G__memfunc_setup("Assign",613,G__BankClassesDict_231_2_0,121,-1,-1,0,1,1,1,0,"U 'PCQA_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18113 G__memfunc_setup("Class",502,G__BankClassesDict_231_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18114 G__memfunc_setup("Class_Name",982,G__BankClassesDict_231_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18115 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_231_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18116 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_231_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18117 G__memfunc_setup("IsA",253,G__BankClassesDict_231_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18118 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_231_8_0,121,-1,-1,0,2,1,1,0,
18119 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18120 G__memfunc_setup("Streamer",835,G__BankClassesDict_231_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18121 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_231_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18122 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_231_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18123 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_231_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18124 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_231_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18125 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_231_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18126
18127 G__memfunc_setup("PCQA",293,G__BankClassesDict_231_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PCQA),-1,0,1,1,1,0,"u 'PCQA' - 11 - -",(char*)NULL,(void*)NULL,0);
18128
18129 G__memfunc_setup("~PCQA",419,G__BankClassesDict_231_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18130 G__tag_memfunc_reset();
18131 }
18132
18133 static void G__setup_memfuncEGPC(void) {
18134
18135 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EGPC));
18136 G__memfunc_setup("EGPC",287,G__BankClassesDict_232_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_EGPC),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18137 G__memfunc_setup("Assign",613,G__BankClassesDict_232_2_0,121,-1,-1,0,1,1,1,0,"U 'EGPC_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18138 G__memfunc_setup("Class",502,G__BankClassesDict_232_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18139 G__memfunc_setup("Class_Name",982,G__BankClassesDict_232_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18140 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_232_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18141 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_232_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18142 G__memfunc_setup("IsA",253,G__BankClassesDict_232_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18143 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_232_8_0,121,-1,-1,0,2,1,1,0,
18144 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18145 G__memfunc_setup("Streamer",835,G__BankClassesDict_232_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18146 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_232_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18147 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_232_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18148 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_232_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18149 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_232_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18150 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_232_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18151
18152 G__memfunc_setup("EGPC",287,G__BankClassesDict_232_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_EGPC),-1,0,1,1,1,0,"u 'EGPC' - 11 - -",(char*)NULL,(void*)NULL,0);
18153
18154 G__memfunc_setup("~EGPC",413,G__BankClassesDict_232_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18155 G__tag_memfunc_reset();
18156 }
18157
18158 static void G__setup_memfuncMUID(void) {
18159
18160 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MUID));
18161 G__memfunc_setup("MUID",303,G__BankClassesDict_233_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_MUID),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18162 G__memfunc_setup("Assign",613,G__BankClassesDict_233_2_0,121,-1,-1,0,1,1,1,0,"U 'MUID_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18163 G__memfunc_setup("Class",502,G__BankClassesDict_233_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18164 G__memfunc_setup("Class_Name",982,G__BankClassesDict_233_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18165 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_233_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18166 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_233_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18167 G__memfunc_setup("IsA",253,G__BankClassesDict_233_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18168 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_233_8_0,121,-1,-1,0,2,1,1,0,
18169 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18170 G__memfunc_setup("Streamer",835,G__BankClassesDict_233_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18171 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_233_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18172 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_233_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18173 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_233_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18174 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_233_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18175 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_233_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18176
18177 G__memfunc_setup("MUID",303,G__BankClassesDict_233_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_MUID),-1,0,1,1,1,0,"u 'MUID' - 11 - -",(char*)NULL,(void*)NULL,0);
18178
18179 G__memfunc_setup("~MUID",429,G__BankClassesDict_233_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18180 G__tag_memfunc_reset();
18181 }
18182
18183 static void G__setup_memfuncPGPC(void) {
18184
18185 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGPC));
18186 G__memfunc_setup("PGPC",298,G__BankClassesDict_234_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PGPC),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18187 G__memfunc_setup("Assign",613,G__BankClassesDict_234_2_0,121,-1,-1,0,1,1,1,0,"U 'PGPC_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18188 G__memfunc_setup("Class",502,G__BankClassesDict_234_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18189 G__memfunc_setup("Class_Name",982,G__BankClassesDict_234_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18190 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_234_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18191 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_234_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18192 G__memfunc_setup("IsA",253,G__BankClassesDict_234_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18193 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_234_8_0,121,-1,-1,0,2,1,1,0,
18194 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18195 G__memfunc_setup("Streamer",835,G__BankClassesDict_234_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18196 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_234_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18197 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_234_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18198 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_234_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18199 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_234_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18200 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_234_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18201
18202 G__memfunc_setup("PGPC",298,G__BankClassesDict_234_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PGPC),-1,0,1,1,1,0,"u 'PGPC' - 11 - -",(char*)NULL,(void*)NULL,0);
18203
18204 G__memfunc_setup("~PGPC",424,G__BankClassesDict_234_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18205 G__tag_memfunc_reset();
18206 }
18207
18208 static void G__setup_memfuncPGAC(void) {
18209
18210 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGAC));
18211 G__memfunc_setup("PGAC",283,G__BankClassesDict_235_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PGAC),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18212 G__memfunc_setup("Assign",613,G__BankClassesDict_235_2_0,121,-1,-1,0,1,1,1,0,"U 'PGAC_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18213 G__memfunc_setup("Class",502,G__BankClassesDict_235_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18214 G__memfunc_setup("Class_Name",982,G__BankClassesDict_235_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18215 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_235_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18216 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_235_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18217 G__memfunc_setup("IsA",253,G__BankClassesDict_235_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18218 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_235_8_0,121,-1,-1,0,2,1,1,0,
18219 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18220 G__memfunc_setup("Streamer",835,G__BankClassesDict_235_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18221 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_235_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18222 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_235_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18223 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_235_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18224 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_235_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18225 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_235_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18226
18227 G__memfunc_setup("PGAC",283,G__BankClassesDict_235_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PGAC),-1,0,1,1,1,0,"u 'PGAC' - 11 - -",(char*)NULL,(void*)NULL,0);
18228
18229 G__memfunc_setup("~PGAC",409,G__BankClassesDict_235_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18230 G__tag_memfunc_reset();
18231 }
18232
18233 static void G__setup_memfuncPDLT(void) {
18234
18235 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PDLT));
18236 G__memfunc_setup("PDLT",308,G__BankClassesDict_236_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PDLT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18237 G__memfunc_setup("Assign",613,G__BankClassesDict_236_2_0,121,-1,-1,0,1,1,1,0,"U 'PDLT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18238 G__memfunc_setup("Class",502,G__BankClassesDict_236_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18239 G__memfunc_setup("Class_Name",982,G__BankClassesDict_236_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18240 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_236_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18241 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_236_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18242 G__memfunc_setup("IsA",253,G__BankClassesDict_236_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18243 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_236_8_0,121,-1,-1,0,2,1,1,0,
18244 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18245 G__memfunc_setup("Streamer",835,G__BankClassesDict_236_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18246 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_236_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18247 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_236_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18248 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_236_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18249 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_236_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18250 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_236_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18251
18252 G__memfunc_setup("PDLT",308,G__BankClassesDict_236_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PDLT),-1,0,1,1,1,0,"u 'PDLT' - 11 - -",(char*)NULL,(void*)NULL,0);
18253
18254 G__memfunc_setup("~PDLT",434,G__BankClassesDict_236_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18255 G__tag_memfunc_reset();
18256 }
18257
18258 static void G__setup_memfuncPMLT(void) {
18259
18260 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PMLT));
18261 G__memfunc_setup("PMLT",317,G__BankClassesDict_237_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_PMLT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18262 G__memfunc_setup("Assign",613,G__BankClassesDict_237_2_0,121,-1,-1,0,1,1,1,0,"U 'PMLT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18263 G__memfunc_setup("Class",502,G__BankClassesDict_237_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18264 G__memfunc_setup("Class_Name",982,G__BankClassesDict_237_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18265 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_237_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18266 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_237_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18267 G__memfunc_setup("IsA",253,G__BankClassesDict_237_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18268 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_237_8_0,121,-1,-1,0,2,1,1,0,
18269 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18270 G__memfunc_setup("Streamer",835,G__BankClassesDict_237_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18271 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_237_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18272 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_237_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18273 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_237_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18274 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_237_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18275 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_237_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18276
18277 G__memfunc_setup("PMLT",317,G__BankClassesDict_237_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_PMLT),-1,0,1,1,1,0,"u 'PMLT' - 11 - -",(char*)NULL,(void*)NULL,0);
18278
18279 G__memfunc_setup("~PMLT",443,G__BankClassesDict_237_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18280 G__tag_memfunc_reset();
18281 }
18282
18283 static void G__setup_memfuncQDET(void) {
18284
18285 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QDET));
18286 G__memfunc_setup("QDET",302,G__BankClassesDict_238_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QDET),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18287 G__memfunc_setup("Assign",613,G__BankClassesDict_238_2_0,121,-1,-1,0,1,1,1,0,"U 'QDET_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18288 G__memfunc_setup("Class",502,G__BankClassesDict_238_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18289 G__memfunc_setup("Class_Name",982,G__BankClassesDict_238_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18290 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_238_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18291 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_238_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18292 G__memfunc_setup("IsA",253,G__BankClassesDict_238_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18293 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_238_8_0,121,-1,-1,0,2,1,1,0,
18294 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18295 G__memfunc_setup("Streamer",835,G__BankClassesDict_238_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18296 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_238_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18297 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_238_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18298 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_238_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18299 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_238_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18300 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_238_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18301
18302 G__memfunc_setup("QDET",302,G__BankClassesDict_238_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QDET),-1,0,1,1,1,0,"u 'QDET' - 11 - -",(char*)NULL,(void*)NULL,0);
18303
18304 G__memfunc_setup("~QDET",428,G__BankClassesDict_238_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18305 G__tag_memfunc_reset();
18306 }
18307
18308 static void G__setup_memfuncQVEC(void) {
18309
18310 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVEC));
18311 G__memfunc_setup("QVEC",303,G__BankClassesDict_239_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QVEC),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18312 G__memfunc_setup("Assign",613,G__BankClassesDict_239_2_0,121,-1,-1,0,1,1,1,0,"U 'QVEC_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18313 G__memfunc_setup("Class",502,G__BankClassesDict_239_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18314 G__memfunc_setup("Class_Name",982,G__BankClassesDict_239_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18315 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_239_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18316 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_239_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18317 G__memfunc_setup("IsA",253,G__BankClassesDict_239_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18318 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_239_8_0,121,-1,-1,0,2,1,1,0,
18319 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18320 G__memfunc_setup("Streamer",835,G__BankClassesDict_239_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18321 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_239_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18322 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_239_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18323 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_239_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18324 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_239_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18325 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_239_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18326
18327 G__memfunc_setup("QVEC",303,G__BankClassesDict_239_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QVEC),-1,0,1,1,1,0,"u 'QVEC' - 11 - -",(char*)NULL,(void*)NULL,0);
18328
18329 G__memfunc_setup("~QVEC",429,G__BankClassesDict_239_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18330 G__tag_memfunc_reset();
18331 }
18332
18333 static void G__setup_memfuncYV0V(void) {
18334
18335 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_YV0V));
18336 G__memfunc_setup("YV0V",309,G__BankClassesDict_244_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_YV0V),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18337 G__memfunc_setup("Assign",613,G__BankClassesDict_244_2_0,121,-1,-1,0,1,1,1,0,"U 'YV0V_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18338 G__memfunc_setup("Class",502,G__BankClassesDict_244_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18339 G__memfunc_setup("Class_Name",982,G__BankClassesDict_244_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18340 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_244_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18341 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_244_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18342 G__memfunc_setup("IsA",253,G__BankClassesDict_244_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18343 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_244_8_0,121,-1,-1,0,2,1,1,0,
18344 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18345 G__memfunc_setup("Streamer",835,G__BankClassesDict_244_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18346 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_244_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18347 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_244_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18348 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_244_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18349 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_244_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18350 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_244_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18351
18352 G__memfunc_setup("YV0V",309,G__BankClassesDict_244_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_YV0V),-1,0,1,1,1,0,"u 'YV0V' - 11 - -",(char*)NULL,(void*)NULL,0);
18353
18354 G__memfunc_setup("~YV0V",435,G__BankClassesDict_244_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18355 G__tag_memfunc_reset();
18356 }
18357
18358 static void G__setup_memfuncFKIN(void) {
18359
18360 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FKIN));
18361 G__memfunc_setup("FKIN",296,G__BankClassesDict_245_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_FKIN),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18362 G__memfunc_setup("Assign",613,G__BankClassesDict_245_2_0,121,-1,-1,0,1,1,1,0,"U 'FKIN_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18363 G__memfunc_setup("Class",502,G__BankClassesDict_245_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18364 G__memfunc_setup("Class_Name",982,G__BankClassesDict_245_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18365 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_245_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18366 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_245_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18367 G__memfunc_setup("IsA",253,G__BankClassesDict_245_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18368 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_245_8_0,121,-1,-1,0,2,1,1,0,
18369 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18370 G__memfunc_setup("Streamer",835,G__BankClassesDict_245_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18371 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_245_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18372 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_245_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18373 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_245_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18374 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_245_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18375 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_245_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18376
18377 G__memfunc_setup("FKIN",296,G__BankClassesDict_245_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_FKIN),-1,0,1,1,1,0,"u 'FKIN' - 11 - -",(char*)NULL,(void*)NULL,0);
18378
18379 G__memfunc_setup("~FKIN",422,G__BankClassesDict_245_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18380 G__tag_memfunc_reset();
18381 }
18382
18383 static void G__setup_memfuncFVER(void) {
18384
18385 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FVER));
18386 G__memfunc_setup("FVER",307,G__BankClassesDict_246_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_FVER),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18387 G__memfunc_setup("Assign",613,G__BankClassesDict_246_2_0,121,-1,-1,0,1,1,1,0,"U 'FVER_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18388 G__memfunc_setup("Class",502,G__BankClassesDict_246_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18389 G__memfunc_setup("Class_Name",982,G__BankClassesDict_246_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18390 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_246_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18391 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_246_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18392 G__memfunc_setup("IsA",253,G__BankClassesDict_246_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18393 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_246_8_0,121,-1,-1,0,2,1,1,0,
18394 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18395 G__memfunc_setup("Streamer",835,G__BankClassesDict_246_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18396 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_246_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18397 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_246_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18398 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_246_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18399 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_246_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18400 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_246_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18401
18402 G__memfunc_setup("FVER",307,G__BankClassesDict_246_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_FVER),-1,0,1,1,1,0,"u 'FVER' - 11 - -",(char*)NULL,(void*)NULL,0);
18403
18404 G__memfunc_setup("~FVER",433,G__BankClassesDict_246_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18405 G__tag_memfunc_reset();
18406 }
18407
18408 static void G__setup_memfuncQVRT(void) {
18409
18410 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVRT));
18411 G__memfunc_setup("QVRT",333,G__BankClassesDict_251_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QVRT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18412 G__memfunc_setup("Assign",613,G__BankClassesDict_251_2_0,121,-1,-1,0,1,1,1,0,"U 'QVRT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18413 G__memfunc_setup("Class",502,G__BankClassesDict_251_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18414 G__memfunc_setup("Class_Name",982,G__BankClassesDict_251_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18415 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_251_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18416 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_251_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18417 G__memfunc_setup("IsA",253,G__BankClassesDict_251_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18418 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_251_8_0,121,-1,-1,0,2,1,1,0,
18419 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18420 G__memfunc_setup("Streamer",835,G__BankClassesDict_251_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18421 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_251_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18422 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_251_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18423 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_251_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18424 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_251_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18425 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_251_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18426
18427 G__memfunc_setup("QVRT",333,G__BankClassesDict_251_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QVRT),-1,0,1,1,1,0,"u 'QVRT' - 11 - -",(char*)NULL,(void*)NULL,0);
18428
18429 G__memfunc_setup("~QVRT",459,G__BankClassesDict_251_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18430 G__tag_memfunc_reset();
18431 }
18432
18433 static void G__setup_memfuncALPB(void) {
18434
18435 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALPB));
18436 G__memfunc_setup("ALPB",287,G__BankClassesDict_252_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_ALPB),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18437 G__memfunc_setup("Assign",613,G__BankClassesDict_252_2_0,121,-1,-1,0,1,1,1,0,"U 'ALPB_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18438 G__memfunc_setup("Class",502,G__BankClassesDict_252_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18439 G__memfunc_setup("Class_Name",982,G__BankClassesDict_252_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18440 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_252_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18441 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_252_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18442 G__memfunc_setup("IsA",253,G__BankClassesDict_252_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18443 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_252_8_0,121,-1,-1,0,2,1,1,0,
18444 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18445 G__memfunc_setup("Streamer",835,G__BankClassesDict_252_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18446 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_252_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18447 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_252_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18448 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_252_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18449 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_252_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18450 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_252_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18451
18452 G__memfunc_setup("ALPB",287,G__BankClassesDict_252_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_ALPB),-1,0,1,1,1,0,"u 'ALPB' - 11 - -",(char*)NULL,(void*)NULL,0);
18453
18454 G__memfunc_setup("~ALPB",413,G__BankClassesDict_252_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18455 G__tag_memfunc_reset();
18456 }
18457
18458 static void G__setup_memfuncALRP(void) {
18459
18460 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALRP));
18461 G__memfunc_setup("ALRP",303,G__BankClassesDict_253_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_ALRP),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18462 G__memfunc_setup("Assign",613,G__BankClassesDict_253_2_0,121,-1,-1,0,1,1,1,0,"U 'ALRP_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18463 G__memfunc_setup("Class",502,G__BankClassesDict_253_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18464 G__memfunc_setup("Class_Name",982,G__BankClassesDict_253_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18465 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_253_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18466 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_253_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18467 G__memfunc_setup("IsA",253,G__BankClassesDict_253_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18468 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_253_8_0,121,-1,-1,0,2,1,1,0,
18469 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18470 G__memfunc_setup("Streamer",835,G__BankClassesDict_253_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18471 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_253_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18472 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_253_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18473 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_253_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18474 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_253_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18475 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_253_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18476
18477 G__memfunc_setup("ALRP",303,G__BankClassesDict_253_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_ALRP),-1,0,1,1,1,0,"u 'ALRP' - 11 - -",(char*)NULL,(void*)NULL,0);
18478
18479 G__memfunc_setup("~ALRP",429,G__BankClassesDict_253_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18480 G__tag_memfunc_reset();
18481 }
18482
18483 static void G__setup_memfuncRNL2(void) {
18484
18485 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNL2));
18486 G__memfunc_setup("RNL2",286,G__BankClassesDict_254_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_RNL2),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18487 G__memfunc_setup("Assign",613,G__BankClassesDict_254_2_0,121,-1,-1,0,1,1,1,0,"U 'RNL2_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18488 G__memfunc_setup("Class",502,G__BankClassesDict_254_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18489 G__memfunc_setup("Class_Name",982,G__BankClassesDict_254_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18490 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_254_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18491 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_254_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18492 G__memfunc_setup("IsA",253,G__BankClassesDict_254_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18493 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_254_8_0,121,-1,-1,0,2,1,1,0,
18494 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18495 G__memfunc_setup("Streamer",835,G__BankClassesDict_254_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18496 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_254_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18497 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_254_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18498 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_254_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18499 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_254_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18500 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_254_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18501
18502 G__memfunc_setup("RNL2",286,G__BankClassesDict_254_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_RNL2),-1,0,1,1,1,0,"u 'RNL2' - 11 - -",(char*)NULL,(void*)NULL,0);
18503
18504 G__memfunc_setup("~RNL2",412,G__BankClassesDict_254_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18505 G__tag_memfunc_reset();
18506 }
18507
18508 static void G__setup_memfuncRNF2(void) {
18509
18510 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNF2));
18511 G__memfunc_setup("RNF2",280,G__BankClassesDict_255_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_RNF2),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18512 G__memfunc_setup("Assign",613,G__BankClassesDict_255_2_0,121,-1,-1,0,1,1,1,0,"U 'RNF2_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18513 G__memfunc_setup("Class",502,G__BankClassesDict_255_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18514 G__memfunc_setup("Class_Name",982,G__BankClassesDict_255_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18515 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_255_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18516 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_255_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18517 G__memfunc_setup("IsA",253,G__BankClassesDict_255_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18518 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_255_8_0,121,-1,-1,0,2,1,1,0,
18519 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18520 G__memfunc_setup("Streamer",835,G__BankClassesDict_255_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18521 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_255_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18522 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_255_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18523 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_255_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18524 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_255_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18525 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_255_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18526
18527 G__memfunc_setup("RNF2",280,G__BankClassesDict_255_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_RNF2),-1,0,1,1,1,0,"u 'RNF2' - 11 - -",(char*)NULL,(void*)NULL,0);
18528
18529 G__memfunc_setup("~RNF2",406,G__BankClassesDict_255_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18530 G__tag_memfunc_reset();
18531 }
18532
18533 static void G__setup_memfuncRNR2(void) {
18534
18535 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNR2));
18536 G__memfunc_setup("RNR2",292,G__BankClassesDict_256_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_RNR2),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18537 G__memfunc_setup("Assign",613,G__BankClassesDict_256_2_0,121,-1,-1,0,1,1,1,0,"U 'RNR2_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18538 G__memfunc_setup("Class",502,G__BankClassesDict_256_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18539 G__memfunc_setup("Class_Name",982,G__BankClassesDict_256_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18540 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_256_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18541 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_256_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18542 G__memfunc_setup("IsA",253,G__BankClassesDict_256_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18543 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_256_8_0,121,-1,-1,0,2,1,1,0,
18544 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18545 G__memfunc_setup("Streamer",835,G__BankClassesDict_256_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18546 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_256_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18547 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_256_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18548 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_256_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18549 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_256_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18550 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_256_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18551
18552 G__memfunc_setup("RNR2",292,G__BankClassesDict_256_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_RNR2),-1,0,1,1,1,0,"u 'RNR2' - 11 - -",(char*)NULL,(void*)NULL,0);
18553
18554 G__memfunc_setup("~RNR2",418,G__BankClassesDict_256_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18555 G__tag_memfunc_reset();
18556 }
18557
18558 static void G__setup_memfuncRLEP(void) {
18559
18560 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RLEP));
18561 G__memfunc_setup("RLEP",307,G__BankClassesDict_257_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_RLEP),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18562 G__memfunc_setup("Assign",613,G__BankClassesDict_257_2_0,121,-1,-1,0,1,1,1,0,"U 'RLEP_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18563 G__memfunc_setup("Class",502,G__BankClassesDict_257_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18564 G__memfunc_setup("Class_Name",982,G__BankClassesDict_257_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18565 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_257_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18566 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_257_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18567 G__memfunc_setup("IsA",253,G__BankClassesDict_257_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18568 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_257_8_0,121,-1,-1,0,2,1,1,0,
18569 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18570 G__memfunc_setup("Streamer",835,G__BankClassesDict_257_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18571 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_257_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18572 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_257_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18573 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_257_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18574 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_257_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18575 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_257_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18576
18577 G__memfunc_setup("RLEP",307,G__BankClassesDict_257_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_RLEP),-1,0,1,1,1,0,"u 'RLEP' - 11 - -",(char*)NULL,(void*)NULL,0);
18578
18579 G__memfunc_setup("~RLEP",433,G__BankClassesDict_257_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18580 G__tag_memfunc_reset();
18581 }
18582
18583 static void G__setup_memfuncLFIL(void) {
18584
18585 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LFIL));
18586 G__memfunc_setup("LFIL",295,G__BankClassesDict_258_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_LFIL),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18587 G__memfunc_setup("Assign",613,G__BankClassesDict_258_2_0,121,-1,-1,0,1,1,1,0,"U 'LFIL_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18588 G__memfunc_setup("Class",502,G__BankClassesDict_258_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18589 G__memfunc_setup("Class_Name",982,G__BankClassesDict_258_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18590 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_258_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18591 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_258_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18592 G__memfunc_setup("IsA",253,G__BankClassesDict_258_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18593 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_258_8_0,121,-1,-1,0,2,1,1,0,
18594 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18595 G__memfunc_setup("Streamer",835,G__BankClassesDict_258_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18596 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_258_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18597 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_258_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18598 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_258_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18599 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_258_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18600 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_258_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18601
18602 G__memfunc_setup("LFIL",295,G__BankClassesDict_258_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_LFIL),-1,0,1,1,1,0,"u 'LFIL' - 11 - -",(char*)NULL,(void*)NULL,0);
18603
18604 G__memfunc_setup("~LFIL",421,G__BankClassesDict_258_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18605 G__tag_memfunc_reset();
18606 }
18607
18608 static void G__setup_memfuncEVEH(void) {
18609
18610 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EVEH));
18611 G__memfunc_setup("EVEH",296,G__BankClassesDict_259_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_EVEH),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18612 G__memfunc_setup("Assign",613,G__BankClassesDict_259_2_0,121,-1,-1,0,1,1,1,0,"U 'EVEH_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18613 G__memfunc_setup("Class",502,G__BankClassesDict_259_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18614 G__memfunc_setup("Class_Name",982,G__BankClassesDict_259_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18615 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_259_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18616 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_259_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18617 G__memfunc_setup("IsA",253,G__BankClassesDict_259_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18618 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_259_8_0,121,-1,-1,0,2,1,1,0,
18619 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18620 G__memfunc_setup("Streamer",835,G__BankClassesDict_259_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18621 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_259_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18622 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_259_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18623 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_259_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18624 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_259_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18625 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_259_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18626
18627 G__memfunc_setup("EVEH",296,G__BankClassesDict_259_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_EVEH),-1,0,1,1,1,0,"u 'EVEH' - 11 - -",(char*)NULL,(void*)NULL,0);
18628
18629 G__memfunc_setup("~EVEH",422,G__BankClassesDict_259_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18630 G__tag_memfunc_reset();
18631 }
18632
18633 static void G__setup_memfuncKEVH(void) {
18634
18635 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KEVH));
18636 G__memfunc_setup("KEVH",302,G__BankClassesDict_260_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_KEVH),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18637 G__memfunc_setup("Assign",613,G__BankClassesDict_260_2_0,121,-1,-1,0,1,1,1,0,"U 'KEVH_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18638 G__memfunc_setup("Class",502,G__BankClassesDict_260_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18639 G__memfunc_setup("Class_Name",982,G__BankClassesDict_260_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18640 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_260_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18641 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_260_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18642 G__memfunc_setup("IsA",253,G__BankClassesDict_260_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18643 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_260_8_0,121,-1,-1,0,2,1,1,0,
18644 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18645 G__memfunc_setup("Streamer",835,G__BankClassesDict_260_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18646 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_260_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18647 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_260_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18648 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_260_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18649 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_260_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18650 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_260_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18651
18652 G__memfunc_setup("KEVH",302,G__BankClassesDict_260_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_KEVH),-1,0,1,1,1,0,"u 'KEVH' - 11 - -",(char*)NULL,(void*)NULL,0);
18653
18654 G__memfunc_setup("~KEVH",428,G__BankClassesDict_260_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18655 G__tag_memfunc_reset();
18656 }
18657
18658 static void G__setup_memfuncREVH(void) {
18659
18660 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_REVH));
18661 G__memfunc_setup("REVH",309,G__BankClassesDict_261_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_REVH),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18662 G__memfunc_setup("Assign",613,G__BankClassesDict_261_2_0,121,-1,-1,0,1,1,1,0,"U 'REVH_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18663 G__memfunc_setup("Class",502,G__BankClassesDict_261_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18664 G__memfunc_setup("Class_Name",982,G__BankClassesDict_261_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18665 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_261_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18666 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_261_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18667 G__memfunc_setup("IsA",253,G__BankClassesDict_261_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18668 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_261_8_0,121,-1,-1,0,2,1,1,0,
18669 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18670 G__memfunc_setup("Streamer",835,G__BankClassesDict_261_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18671 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_261_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18672 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_261_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18673 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_261_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18674 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_261_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18675 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_261_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18676
18677 G__memfunc_setup("REVH",309,G__BankClassesDict_261_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_REVH),-1,0,1,1,1,0,"u 'REVH' - 11 - -",(char*)NULL,(void*)NULL,0);
18678
18679 G__memfunc_setup("~REVH",435,G__BankClassesDict_261_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18680 G__tag_memfunc_reset();
18681 }
18682
18683 static void G__setup_memfuncLOLE(void) {
18684
18685 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LOLE));
18686 G__memfunc_setup("LOLE",300,G__BankClassesDict_262_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_LOLE),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18687 G__memfunc_setup("Assign",613,G__BankClassesDict_262_2_0,121,-1,-1,0,1,1,1,0,"U 'LOLE_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18688 G__memfunc_setup("Class",502,G__BankClassesDict_262_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18689 G__memfunc_setup("Class_Name",982,G__BankClassesDict_262_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18690 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_262_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18691 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_262_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18692 G__memfunc_setup("IsA",253,G__BankClassesDict_262_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18693 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_262_8_0,121,-1,-1,0,2,1,1,0,
18694 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18695 G__memfunc_setup("Streamer",835,G__BankClassesDict_262_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18696 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_262_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18697 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_262_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18698 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_262_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18699 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_262_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18700 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_262_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18701
18702 G__memfunc_setup("LOLE",300,G__BankClassesDict_262_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_LOLE),-1,0,1,1,1,0,"u 'LOLE' - 11 - -",(char*)NULL,(void*)NULL,0);
18703
18704 G__memfunc_setup("~LOLE",426,G__BankClassesDict_262_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18705 G__tag_memfunc_reset();
18706 }
18707
18708 static void G__setup_memfuncX1RG(void) {
18709
18710 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1RG));
18711 G__memfunc_setup("X1RG",290,G__BankClassesDict_263_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_X1RG),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18712 G__memfunc_setup("Assign",613,G__BankClassesDict_263_2_0,121,-1,-1,0,1,1,1,0,"U 'X1RG_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18713 G__memfunc_setup("Class",502,G__BankClassesDict_263_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18714 G__memfunc_setup("Class_Name",982,G__BankClassesDict_263_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18715 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_263_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18716 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_263_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18717 G__memfunc_setup("IsA",253,G__BankClassesDict_263_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18718 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_263_8_0,121,-1,-1,0,2,1,1,0,
18719 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18720 G__memfunc_setup("Streamer",835,G__BankClassesDict_263_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18721 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_263_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18722 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_263_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18723 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_263_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18724 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_263_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18725 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_263_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18726
18727 G__memfunc_setup("X1RG",290,G__BankClassesDict_263_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_X1RG),-1,0,1,1,1,0,"u 'X1RG' - 11 - -",(char*)NULL,(void*)NULL,0);
18728
18729 G__memfunc_setup("~X1RG",416,G__BankClassesDict_263_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18730 G__tag_memfunc_reset();
18731 }
18732
18733 static void G__setup_memfuncBOMB(void) {
18734
18735 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_BOMB));
18736 G__memfunc_setup("BOMB",288,G__BankClassesDict_264_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_BOMB),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18737 G__memfunc_setup("Assign",613,G__BankClassesDict_264_2_0,121,-1,-1,0,1,1,1,0,"U 'BOMB_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18738 G__memfunc_setup("Class",502,G__BankClassesDict_264_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18739 G__memfunc_setup("Class_Name",982,G__BankClassesDict_264_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18740 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_264_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18741 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_264_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18742 G__memfunc_setup("IsA",253,G__BankClassesDict_264_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18743 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_264_8_0,121,-1,-1,0,2,1,1,0,
18744 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18745 G__memfunc_setup("Streamer",835,G__BankClassesDict_264_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18746 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_264_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18747 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_264_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18748 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_264_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18749 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_264_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18750 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_264_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18751
18752 G__memfunc_setup("BOMB",288,G__BankClassesDict_264_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_BOMB),-1,0,1,1,1,0,"u 'BOMB' - 11 - -",(char*)NULL,(void*)NULL,0);
18753
18754 G__memfunc_setup("~BOMB",414,G__BankClassesDict_264_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18755 G__tag_memfunc_reset();
18756 }
18757
18758 static void G__setup_memfuncRUNH(void) {
18759
18760 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RUNH));
18761 G__memfunc_setup("RUNH",317,G__BankClassesDict_265_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_RUNH),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18762 G__memfunc_setup("Assign",613,G__BankClassesDict_265_2_0,121,-1,-1,0,1,1,1,0,"U 'RUNH_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18763 G__memfunc_setup("Class",502,G__BankClassesDict_265_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18764 G__memfunc_setup("Class_Name",982,G__BankClassesDict_265_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18765 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_265_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18766 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_265_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18767 G__memfunc_setup("IsA",253,G__BankClassesDict_265_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18768 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_265_8_0,121,-1,-1,0,2,1,1,0,
18769 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18770 G__memfunc_setup("Streamer",835,G__BankClassesDict_265_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18771 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_265_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18772 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_265_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18773 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_265_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18774 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_265_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18775 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_265_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18776
18777 G__memfunc_setup("RUNH",317,G__BankClassesDict_265_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_RUNH),-1,0,1,1,1,0,"u 'RUNH' - 11 - -",(char*)NULL,(void*)NULL,0);
18778
18779 G__memfunc_setup("~RUNH",443,G__BankClassesDict_265_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18780 G__tag_memfunc_reset();
18781 }
18782
18783 static void G__setup_memfuncASIM(void) {
18784
18785 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ASIM));
18786 G__memfunc_setup("ASIM",298,G__BankClassesDict_266_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_ASIM),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18787 G__memfunc_setup("Assign",613,G__BankClassesDict_266_2_0,121,-1,-1,0,1,1,1,0,"U 'ASIM_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18788 G__memfunc_setup("Class",502,G__BankClassesDict_266_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18789 G__memfunc_setup("Class_Name",982,G__BankClassesDict_266_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18790 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_266_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18791 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_266_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18792 G__memfunc_setup("IsA",253,G__BankClassesDict_266_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18793 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_266_8_0,121,-1,-1,0,2,1,1,0,
18794 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18795 G__memfunc_setup("Streamer",835,G__BankClassesDict_266_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18796 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_266_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18797 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_266_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18798 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_266_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18799 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_266_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18800 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_266_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18801
18802 G__memfunc_setup("ASIM",298,G__BankClassesDict_266_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_ASIM),-1,0,1,1,1,0,"u 'ASIM' - 11 - -",(char*)NULL,(void*)NULL,0);
18803
18804 G__memfunc_setup("~ASIM",424,G__BankClassesDict_266_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18805 G__tag_memfunc_reset();
18806 }
18807
18808 static void G__setup_memfuncADBR(void) {
18809
18810 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ADBR));
18811 G__memfunc_setup("ADBR",281,G__BankClassesDict_267_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_ADBR),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18812 G__memfunc_setup("Assign",613,G__BankClassesDict_267_2_0,121,-1,-1,0,1,1,1,0,"U 'ADBR_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18813 G__memfunc_setup("Class",502,G__BankClassesDict_267_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18814 G__memfunc_setup("Class_Name",982,G__BankClassesDict_267_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18815 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_267_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18816 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_267_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18817 G__memfunc_setup("IsA",253,G__BankClassesDict_267_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18818 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_267_8_0,121,-1,-1,0,2,1,1,0,
18819 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18820 G__memfunc_setup("Streamer",835,G__BankClassesDict_267_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18821 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_267_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18822 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_267_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18823 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_267_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18824 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_267_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18825 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_267_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18826
18827 G__memfunc_setup("ADBR",281,G__BankClassesDict_267_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_ADBR),-1,0,1,1,1,0,"u 'ADBR' - 11 - -",(char*)NULL,(void*)NULL,0);
18828
18829 G__memfunc_setup("~ADBR",407,G__BankClassesDict_267_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18830 G__tag_memfunc_reset();
18831 }
18832
18833 static void G__setup_memfuncXTBN(void) {
18834
18835 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTBN));
18836 G__memfunc_setup("XTBN",316,G__BankClassesDict_268_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_XTBN),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18837 G__memfunc_setup("Assign",613,G__BankClassesDict_268_2_0,121,-1,-1,0,1,1,1,0,"U 'XTBN_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18838 G__memfunc_setup("Class",502,G__BankClassesDict_268_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18839 G__memfunc_setup("Class_Name",982,G__BankClassesDict_268_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18840 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_268_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18841 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_268_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18842 G__memfunc_setup("IsA",253,G__BankClassesDict_268_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18843 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_268_8_0,121,-1,-1,0,2,1,1,0,
18844 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18845 G__memfunc_setup("Streamer",835,G__BankClassesDict_268_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18846 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_268_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18847 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_268_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18848 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_268_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18849 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_268_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18850 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_268_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18851
18852 G__memfunc_setup("XTBN",316,G__BankClassesDict_268_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_XTBN),-1,0,1,1,1,0,"u 'XTBN' - 11 - -",(char*)NULL,(void*)NULL,0);
18853
18854 G__memfunc_setup("~XTBN",442,G__BankClassesDict_268_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18855 G__tag_memfunc_reset();
18856 }
18857
18858 static void G__setup_memfuncXTCN(void) {
18859
18860 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTCN));
18861 G__memfunc_setup("XTCN",317,G__BankClassesDict_269_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_XTCN),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18862 G__memfunc_setup("Assign",613,G__BankClassesDict_269_2_0,121,-1,-1,0,1,1,1,0,"U 'XTCN_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18863 G__memfunc_setup("Class",502,G__BankClassesDict_269_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18864 G__memfunc_setup("Class_Name",982,G__BankClassesDict_269_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18865 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_269_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18866 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_269_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18867 G__memfunc_setup("IsA",253,G__BankClassesDict_269_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18868 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_269_8_0,121,-1,-1,0,2,1,1,0,
18869 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18870 G__memfunc_setup("Streamer",835,G__BankClassesDict_269_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18871 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_269_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18872 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_269_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18873 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_269_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18874 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_269_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18875 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_269_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18876
18877 G__memfunc_setup("XTCN",317,G__BankClassesDict_269_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_XTCN),-1,0,1,1,1,0,"u 'XTCN' - 11 - -",(char*)NULL,(void*)NULL,0);
18878
18879 G__memfunc_setup("~XTCN",443,G__BankClassesDict_269_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18880 G__tag_memfunc_reset();
18881 }
18882
18883 static void G__setup_memfuncXTOP(void) {
18884
18885 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTOP));
18886 G__memfunc_setup("XTOP",331,G__BankClassesDict_270_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_XTOP),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18887 G__memfunc_setup("Assign",613,G__BankClassesDict_270_2_0,121,-1,-1,0,1,1,1,0,"U 'XTOP_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18888 G__memfunc_setup("Class",502,G__BankClassesDict_270_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18889 G__memfunc_setup("Class_Name",982,G__BankClassesDict_270_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18890 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_270_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18891 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_270_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18892 G__memfunc_setup("IsA",253,G__BankClassesDict_270_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18893 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_270_8_0,121,-1,-1,0,2,1,1,0,
18894 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18895 G__memfunc_setup("Streamer",835,G__BankClassesDict_270_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18896 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_270_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18897 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_270_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18898 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_270_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18899 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_270_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18900 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_270_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18901
18902 G__memfunc_setup("XTOP",331,G__BankClassesDict_270_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_XTOP),-1,0,1,1,1,0,"u 'XTOP' - 11 - -",(char*)NULL,(void*)NULL,0);
18903
18904 G__memfunc_setup("~XTOP",457,G__BankClassesDict_270_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18905 G__tag_memfunc_reset();
18906 }
18907
18908 static void G__setup_memfuncLUPA(void) {
18909
18910 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LUPA));
18911 G__memfunc_setup("LUPA",306,G__BankClassesDict_271_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_LUPA),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18912 G__memfunc_setup("Assign",613,G__BankClassesDict_271_2_0,121,-1,-1,0,1,1,1,0,"U 'LUPA_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18913 G__memfunc_setup("Class",502,G__BankClassesDict_271_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18914 G__memfunc_setup("Class_Name",982,G__BankClassesDict_271_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18915 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_271_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18916 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_271_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18917 G__memfunc_setup("IsA",253,G__BankClassesDict_271_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18918 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_271_8_0,121,-1,-1,0,2,1,1,0,
18919 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18920 G__memfunc_setup("Streamer",835,G__BankClassesDict_271_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18921 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_271_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18922 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_271_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18923 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_271_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18924 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_271_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18925 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_271_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18926
18927 G__memfunc_setup("LUPA",306,G__BankClassesDict_271_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_LUPA),-1,0,1,1,1,0,"u 'LUPA' - 11 - -",(char*)NULL,(void*)NULL,0);
18928
18929 G__memfunc_setup("~LUPA",432,G__BankClassesDict_271_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18930 G__tag_memfunc_reset();
18931 }
18932
18933 static void G__setup_memfuncSILH(void) {
18934
18935 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SILH));
18936 G__memfunc_setup("SILH",304,G__BankClassesDict_272_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_SILH),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18937 G__memfunc_setup("Assign",613,G__BankClassesDict_272_2_0,121,-1,-1,0,1,1,1,0,"U 'SILH_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18938 G__memfunc_setup("Class",502,G__BankClassesDict_272_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18939 G__memfunc_setup("Class_Name",982,G__BankClassesDict_272_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18940 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_272_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18941 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_272_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18942 G__memfunc_setup("IsA",253,G__BankClassesDict_272_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18943 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_272_8_0,121,-1,-1,0,2,1,1,0,
18944 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18945 G__memfunc_setup("Streamer",835,G__BankClassesDict_272_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18946 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_272_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18947 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_272_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18948 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_272_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18949 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_272_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18950 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_272_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18951
18952 G__memfunc_setup("SILH",304,G__BankClassesDict_272_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_SILH),-1,0,1,1,1,0,"u 'SILH' - 11 - -",(char*)NULL,(void*)NULL,0);
18953
18954 G__memfunc_setup("~SILH",430,G__BankClassesDict_272_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18955 G__tag_memfunc_reset();
18956 }
18957
18958 static void G__setup_memfuncXHVB(void) {
18959
18960 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XHVB));
18961 G__memfunc_setup("XHVB",312,G__BankClassesDict_273_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_XHVB),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18962 G__memfunc_setup("Assign",613,G__BankClassesDict_273_2_0,121,-1,-1,0,1,1,1,0,"U 'XHVB_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18963 G__memfunc_setup("Class",502,G__BankClassesDict_273_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18964 G__memfunc_setup("Class_Name",982,G__BankClassesDict_273_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18965 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_273_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18966 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_273_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18967 G__memfunc_setup("IsA",253,G__BankClassesDict_273_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18968 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_273_8_0,121,-1,-1,0,2,1,1,0,
18969 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18970 G__memfunc_setup("Streamer",835,G__BankClassesDict_273_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18971 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_273_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18972 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_273_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18973 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_273_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18974 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_273_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18975 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_273_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18976
18977 G__memfunc_setup("XHVB",312,G__BankClassesDict_273_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_XHVB),-1,0,1,1,1,0,"u 'XHVB' - 11 - -",(char*)NULL,(void*)NULL,0);
18978
18979 G__memfunc_setup("~XHVB",438,G__BankClassesDict_273_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
18980 G__tag_memfunc_reset();
18981 }
18982
18983 static void G__setup_memfuncXTEB(void) {
18984
18985 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTEB));
18986 G__memfunc_setup("XTEB",307,G__BankClassesDict_274_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_XTEB),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
18987 G__memfunc_setup("Assign",613,G__BankClassesDict_274_2_0,121,-1,-1,0,1,1,1,0,"U 'XTEB_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
18988 G__memfunc_setup("Class",502,G__BankClassesDict_274_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18989 G__memfunc_setup("Class_Name",982,G__BankClassesDict_274_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18990 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_274_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18991 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_274_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18992 G__memfunc_setup("IsA",253,G__BankClassesDict_274_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
18993 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_274_8_0,121,-1,-1,0,2,1,1,0,
18994 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
18995 G__memfunc_setup("Streamer",835,G__BankClassesDict_274_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
18996 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_274_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
18997 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_274_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
18998 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_274_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
18999 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_274_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19000 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_274_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19001
19002 G__memfunc_setup("XTEB",307,G__BankClassesDict_274_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_XTEB),-1,0,1,1,1,0,"u 'XTEB' - 11 - -",(char*)NULL,(void*)NULL,0);
19003
19004 G__memfunc_setup("~XTEB",433,G__BankClassesDict_274_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19005 G__tag_memfunc_reset();
19006 }
19007
19008 static void G__setup_memfuncXTRB(void) {
19009
19010 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTRB));
19011 G__memfunc_setup("XTRB",320,G__BankClassesDict_275_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_XTRB),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19012 G__memfunc_setup("Assign",613,G__BankClassesDict_275_2_0,121,-1,-1,0,1,1,1,0,"U 'XTRB_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19013 G__memfunc_setup("Class",502,G__BankClassesDict_275_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19014 G__memfunc_setup("Class_Name",982,G__BankClassesDict_275_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19015 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_275_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19016 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_275_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19017 G__memfunc_setup("IsA",253,G__BankClassesDict_275_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19018 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_275_8_0,121,-1,-1,0,2,1,1,0,
19019 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19020 G__memfunc_setup("Streamer",835,G__BankClassesDict_275_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19021 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_275_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19022 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_275_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19023 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_275_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19024 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_275_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19025 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_275_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19026
19027 G__memfunc_setup("XTRB",320,G__BankClassesDict_275_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_XTRB),-1,0,1,1,1,0,"u 'XTRB' - 11 - -",(char*)NULL,(void*)NULL,0);
19028
19029 G__memfunc_setup("~XTRB",446,G__BankClassesDict_275_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19030 G__tag_memfunc_reset();
19031 }
19032
19033 static void G__setup_memfuncDTBP(void) {
19034
19035 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_DTBP));
19036 G__memfunc_setup("DTBP",298,G__BankClassesDict_276_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_DTBP),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19037 G__memfunc_setup("Assign",613,G__BankClassesDict_276_2_0,121,-1,-1,0,1,1,1,0,"U 'DTBP_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19038 G__memfunc_setup("Class",502,G__BankClassesDict_276_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19039 G__memfunc_setup("Class_Name",982,G__BankClassesDict_276_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19040 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_276_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19041 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_276_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19042 G__memfunc_setup("IsA",253,G__BankClassesDict_276_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19043 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_276_8_0,121,-1,-1,0,2,1,1,0,
19044 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19045 G__memfunc_setup("Streamer",835,G__BankClassesDict_276_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19046 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_276_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19047 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_276_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19048 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_276_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19049 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_276_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19050 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_276_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19051
19052 G__memfunc_setup("DTBP",298,G__BankClassesDict_276_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_DTBP),-1,0,1,1,1,0,"u 'DTBP' - 11 - -",(char*)NULL,(void*)NULL,0);
19053
19054 G__memfunc_setup("~DTBP",424,G__BankClassesDict_276_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19055 G__tag_memfunc_reset();
19056 }
19057
19058 static void G__setup_memfuncVHBV(void) {
19059
19060 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHBV));
19061 G__memfunc_setup("VHBV",310,G__BankClassesDict_277_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_VHBV),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19062 G__memfunc_setup("Assign",613,G__BankClassesDict_277_2_0,121,-1,-1,0,1,1,1,0,"U 'VHBV_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19063 G__memfunc_setup("Class",502,G__BankClassesDict_277_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19064 G__memfunc_setup("Class_Name",982,G__BankClassesDict_277_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19065 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_277_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19066 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_277_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19067 G__memfunc_setup("IsA",253,G__BankClassesDict_277_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19068 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_277_8_0,121,-1,-1,0,2,1,1,0,
19069 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19070 G__memfunc_setup("Streamer",835,G__BankClassesDict_277_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19071 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_277_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19072 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_277_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19073 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_277_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19074 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_277_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19075 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_277_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19076
19077 G__memfunc_setup("VHBV",310,G__BankClassesDict_277_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_VHBV),-1,0,1,1,1,0,"u 'VHBV' - 11 - -",(char*)NULL,(void*)NULL,0);
19078
19079 G__memfunc_setup("~VHBV",436,G__BankClassesDict_277_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19080 G__tag_memfunc_reset();
19081 }
19082
19083 static void G__setup_memfuncVHPV(void) {
19084
19085 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHPV));
19086 G__memfunc_setup("VHPV",324,G__BankClassesDict_278_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_VHPV),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19087 G__memfunc_setup("Assign",613,G__BankClassesDict_278_2_0,121,-1,-1,0,1,1,1,0,"U 'VHPV_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19088 G__memfunc_setup("Class",502,G__BankClassesDict_278_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19089 G__memfunc_setup("Class_Name",982,G__BankClassesDict_278_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19090 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_278_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19091 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_278_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19092 G__memfunc_setup("IsA",253,G__BankClassesDict_278_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19093 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_278_8_0,121,-1,-1,0,2,1,1,0,
19094 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19095 G__memfunc_setup("Streamer",835,G__BankClassesDict_278_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19096 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_278_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19097 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_278_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19098 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_278_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19099 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_278_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19100 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_278_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19101
19102 G__memfunc_setup("VHPV",324,G__BankClassesDict_278_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_VHPV),-1,0,1,1,1,0,"u 'VHPV' - 11 - -",(char*)NULL,(void*)NULL,0);
19103
19104 G__memfunc_setup("~VHPV",450,G__BankClassesDict_278_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19105 G__tag_memfunc_reset();
19106 }
19107
19108 static void G__setup_memfuncEAUX(void) {
19109
19110 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EAUX));
19111 G__memfunc_setup("EAUX",307,G__BankClassesDict_279_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_EAUX),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19112 G__memfunc_setup("Assign",613,G__BankClassesDict_279_2_0,121,-1,-1,0,1,1,1,0,"U 'EAUX_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19113 G__memfunc_setup("Class",502,G__BankClassesDict_279_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19114 G__memfunc_setup("Class_Name",982,G__BankClassesDict_279_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19115 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_279_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19116 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_279_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19117 G__memfunc_setup("IsA",253,G__BankClassesDict_279_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19118 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_279_8_0,121,-1,-1,0,2,1,1,0,
19119 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19120 G__memfunc_setup("Streamer",835,G__BankClassesDict_279_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19121 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_279_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19122 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_279_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19123 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_279_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19124 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_279_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19125 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_279_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19126
19127 G__memfunc_setup("EAUX",307,G__BankClassesDict_279_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_EAUX),-1,0,1,1,1,0,"u 'EAUX' - 11 - -",(char*)NULL,(void*)NULL,0);
19128
19129 G__memfunc_setup("~EAUX",433,G__BankClassesDict_279_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19130 G__tag_memfunc_reset();
19131 }
19132
19133 static void G__setup_memfuncSIX2(void) {
19134
19135 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIX2));
19136 G__memfunc_setup("SIX2",294,G__BankClassesDict_280_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_SIX2),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19137 G__memfunc_setup("Assign",613,G__BankClassesDict_280_2_0,121,-1,-1,0,1,1,1,0,"U 'SIX2_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19138 G__memfunc_setup("Class",502,G__BankClassesDict_280_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19139 G__memfunc_setup("Class_Name",982,G__BankClassesDict_280_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19140 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_280_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19141 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_280_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19142 G__memfunc_setup("IsA",253,G__BankClassesDict_280_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19143 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_280_8_0,121,-1,-1,0,2,1,1,0,
19144 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19145 G__memfunc_setup("Streamer",835,G__BankClassesDict_280_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19146 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_280_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19147 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_280_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19148 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_280_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19149 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_280_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19150 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_280_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19151
19152 G__memfunc_setup("SIX2",294,G__BankClassesDict_280_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_SIX2),-1,0,1,1,1,0,"u 'SIX2' - 11 - -",(char*)NULL,(void*)NULL,0);
19153
19154 G__memfunc_setup("~SIX2",420,G__BankClassesDict_280_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19155 G__tag_memfunc_reset();
19156 }
19157
19158 static void G__setup_memfuncX1TV(void) {
19159
19160 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TV));
19161 G__memfunc_setup("X1TV",307,G__BankClassesDict_281_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_X1TV),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19162 G__memfunc_setup("Assign",613,G__BankClassesDict_281_2_0,121,-1,-1,0,1,1,1,0,"U 'X1TV_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19163 G__memfunc_setup("Class",502,G__BankClassesDict_281_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19164 G__memfunc_setup("Class_Name",982,G__BankClassesDict_281_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19165 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_281_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19166 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_281_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19167 G__memfunc_setup("IsA",253,G__BankClassesDict_281_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19168 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_281_8_0,121,-1,-1,0,2,1,1,0,
19169 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19170 G__memfunc_setup("Streamer",835,G__BankClassesDict_281_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19171 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_281_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19172 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_281_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19173 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_281_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19174 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_281_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19175 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_281_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19176
19177 G__memfunc_setup("X1TV",307,G__BankClassesDict_281_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_X1TV),-1,0,1,1,1,0,"u 'X1TV' - 11 - -",(char*)NULL,(void*)NULL,0);
19178
19179 G__memfunc_setup("~X1TV",433,G__BankClassesDict_281_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19180 G__tag_memfunc_reset();
19181 }
19182
19183 static void G__setup_memfuncKWGT(void) {
19184
19185 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KWGT));
19186 G__memfunc_setup("KWGT",317,G__BankClassesDict_282_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_KWGT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19187 G__memfunc_setup("Assign",613,G__BankClassesDict_282_2_0,121,-1,-1,0,1,1,1,0,"U 'KWGT_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19188 G__memfunc_setup("Class",502,G__BankClassesDict_282_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19189 G__memfunc_setup("Class_Name",982,G__BankClassesDict_282_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19190 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_282_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19191 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_282_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19192 G__memfunc_setup("IsA",253,G__BankClassesDict_282_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19193 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_282_8_0,121,-1,-1,0,2,1,1,0,
19194 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19195 G__memfunc_setup("Streamer",835,G__BankClassesDict_282_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19196 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_282_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19197 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_282_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19198 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_282_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19199 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_282_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19200 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_282_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19201
19202 G__memfunc_setup("KWGT",317,G__BankClassesDict_282_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_KWGT),-1,0,1,1,1,0,"u 'KWGT' - 11 - -",(char*)NULL,(void*)NULL,0);
19203
19204 G__memfunc_setup("~KWGT",443,G__BankClassesDict_282_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19205 G__tag_memfunc_reset();
19206 }
19207
19208 static void G__setup_memfuncX1IP(void) {
19209
19210 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1IP));
19211 G__memfunc_setup("X1IP",290,G__BankClassesDict_283_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_X1IP),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19212 G__memfunc_setup("Assign",613,G__BankClassesDict_283_2_0,121,-1,-1,0,1,1,1,0,"U 'X1IP_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19213 G__memfunc_setup("Class",502,G__BankClassesDict_283_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19214 G__memfunc_setup("Class_Name",982,G__BankClassesDict_283_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19215 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_283_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19216 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_283_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19217 G__memfunc_setup("IsA",253,G__BankClassesDict_283_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19218 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_283_8_0,121,-1,-1,0,2,1,1,0,
19219 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19220 G__memfunc_setup("Streamer",835,G__BankClassesDict_283_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19221 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_283_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19222 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_283_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19223 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_283_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19224 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_283_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19225 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_283_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19226
19227 G__memfunc_setup("X1IP",290,G__BankClassesDict_283_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_X1IP),-1,0,1,1,1,0,"u 'X1IP' - 11 - -",(char*)NULL,(void*)NULL,0);
19228
19229 G__memfunc_setup("~X1IP",416,G__BankClassesDict_283_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19230 G__tag_memfunc_reset();
19231 }
19232
19233 static void G__setup_memfuncSIXA(void) {
19234
19235 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIXA));
19236 G__memfunc_setup("SIXA",309,G__BankClassesDict_284_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_SIXA),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19237 G__memfunc_setup("Assign",613,G__BankClassesDict_284_2_0,121,-1,-1,0,1,1,1,0,"U 'SIXA_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19238 G__memfunc_setup("Class",502,G__BankClassesDict_284_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19239 G__memfunc_setup("Class_Name",982,G__BankClassesDict_284_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19240 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_284_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19241 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_284_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19242 G__memfunc_setup("IsA",253,G__BankClassesDict_284_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19243 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_284_8_0,121,-1,-1,0,2,1,1,0,
19244 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19245 G__memfunc_setup("Streamer",835,G__BankClassesDict_284_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19246 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_284_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19247 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_284_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19248 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_284_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19249 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_284_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19250 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_284_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19251
19252 G__memfunc_setup("SIXA",309,G__BankClassesDict_284_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_SIXA),-1,0,1,1,1,0,"u 'SIXA' - 11 - -",(char*)NULL,(void*)NULL,0);
19253
19254 G__memfunc_setup("~SIXA",435,G__BankClassesDict_284_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19255 G__tag_memfunc_reset();
19256 }
19257
19258 static void G__setup_memfuncSITC(void) {
19259
19260 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SITC));
19261 G__memfunc_setup("SITC",307,G__BankClassesDict_285_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_SITC),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19262 G__memfunc_setup("Assign",613,G__BankClassesDict_285_2_0,121,-1,-1,0,1,1,1,0,"U 'SITC_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19263 G__memfunc_setup("Class",502,G__BankClassesDict_285_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19264 G__memfunc_setup("Class_Name",982,G__BankClassesDict_285_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19265 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_285_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19266 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_285_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19267 G__memfunc_setup("IsA",253,G__BankClassesDict_285_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19268 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_285_8_0,121,-1,-1,0,2,1,1,0,
19269 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19270 G__memfunc_setup("Streamer",835,G__BankClassesDict_285_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19271 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_285_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19272 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_285_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19273 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_285_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19274 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_285_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19275 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_285_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19276
19277 G__memfunc_setup("SITC",307,G__BankClassesDict_285_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_SITC),-1,0,1,1,1,0,"u 'SITC' - 11 - -",(char*)NULL,(void*)NULL,0);
19278
19279 G__memfunc_setup("~SITC",433,G__BankClassesDict_285_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19280 G__tag_memfunc_reset();
19281 }
19282
19283 static void G__setup_memfuncSRCO(void) {
19284
19285 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SRCO));
19286 G__memfunc_setup("SRCO",311,G__BankClassesDict_286_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_SRCO),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19287 G__memfunc_setup("Assign",613,G__BankClassesDict_286_2_0,121,-1,-1,0,1,1,1,0,"U 'SRCO_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19288 G__memfunc_setup("Class",502,G__BankClassesDict_286_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19289 G__memfunc_setup("Class_Name",982,G__BankClassesDict_286_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19290 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_286_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19291 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_286_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19292 G__memfunc_setup("IsA",253,G__BankClassesDict_286_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19293 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_286_8_0,121,-1,-1,0,2,1,1,0,
19294 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19295 G__memfunc_setup("Streamer",835,G__BankClassesDict_286_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19296 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_286_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19297 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_286_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19298 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_286_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19299 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_286_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19300 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_286_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19301
19302 G__memfunc_setup("SRCO",311,G__BankClassesDict_286_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_SRCO),-1,0,1,1,1,0,"u 'SRCO' - 11 - -",(char*)NULL,(void*)NULL,0);
19303
19304 G__memfunc_setup("~SRCO",437,G__BankClassesDict_286_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19305 G__tag_memfunc_reset();
19306 }
19307
19308 static void G__setup_memfuncX1TH(void) {
19309
19310 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TH));
19311 G__memfunc_setup("X1TH",293,G__BankClassesDict_287_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_X1TH),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19312 G__memfunc_setup("Assign",613,G__BankClassesDict_287_2_0,121,-1,-1,0,1,1,1,0,"U 'X1TH_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19313 G__memfunc_setup("Class",502,G__BankClassesDict_287_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19314 G__memfunc_setup("Class_Name",982,G__BankClassesDict_287_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19315 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_287_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19316 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_287_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19317 G__memfunc_setup("IsA",253,G__BankClassesDict_287_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19318 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_287_8_0,121,-1,-1,0,2,1,1,0,
19319 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19320 G__memfunc_setup("Streamer",835,G__BankClassesDict_287_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19321 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_287_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19322 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_287_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19323 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_287_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19324 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_287_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19325 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_287_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19326
19327 G__memfunc_setup("X1TH",293,G__BankClassesDict_287_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_X1TH),-1,0,1,1,1,0,"u 'X1TH' - 11 - -",(char*)NULL,(void*)NULL,0);
19328
19329 G__memfunc_setup("~X1TH",419,G__BankClassesDict_287_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19330 G__tag_memfunc_reset();
19331 }
19332
19333 static void G__setup_memfuncX1AD(void) {
19334
19335 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1AD));
19336 G__memfunc_setup("X1AD",270,G__BankClassesDict_288_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_X1AD),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19337 G__memfunc_setup("Assign",613,G__BankClassesDict_288_2_0,121,-1,-1,0,1,1,1,0,"U 'X1AD_PATTERN' - 0 - -",(char*)NULL,(void*)NULL,0);
19338 G__memfunc_setup("Class",502,G__BankClassesDict_288_3_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19339 G__memfunc_setup("Class_Name",982,G__BankClassesDict_288_4_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19340 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_288_5_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19341 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_288_6_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19342 G__memfunc_setup("IsA",253,G__BankClassesDict_288_7_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19343 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_288_8_0,121,-1,-1,0,2,1,1,0,
19344 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19345 G__memfunc_setup("Streamer",835,G__BankClassesDict_288_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19346 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_288_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19347 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_288_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19348 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_288_2_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19349 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_288_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19350 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_288_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19351
19352 G__memfunc_setup("X1AD",270,G__BankClassesDict_288_5_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_X1AD),-1,0,1,1,1,0,"u 'X1AD' - 11 - -",(char*)NULL,(void*)NULL,0);
19353
19354 G__memfunc_setup("~X1AD",396,G__BankClassesDict_288_6_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19355 G__tag_memfunc_reset();
19356 }
19357
19358 static void G__setup_memfuncQEXT(void) {
19359
19360 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QEXT));
19361 G__memfunc_setup("QEXT",322,G__BankClassesDict_289_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QEXT),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19362 G__memfunc_setup("Class",502,G__BankClassesDict_289_2_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19363 G__memfunc_setup("Class_Name",982,G__BankClassesDict_289_3_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19364 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_289_4_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19365 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_289_5_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19366 G__memfunc_setup("IsA",253,G__BankClassesDict_289_6_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19367 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_289_7_0,121,-1,-1,0,2,1,1,0,
19368 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19369 G__memfunc_setup("Streamer",835,G__BankClassesDict_289_8_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19370 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_289_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19371 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_289_0_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19372 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_289_1_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19373 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_289_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19374 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_289_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19375
19376 G__memfunc_setup("QEXT",322,G__BankClassesDict_289_4_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QEXT),-1,0,1,1,1,0,"u 'QEXT' - 11 - -",(char*)NULL,(void*)NULL,0);
19377
19378 G__memfunc_setup("~QEXT",448,G__BankClassesDict_289_5_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19379 G__tag_memfunc_reset();
19380 }
19381
19382 static void G__setup_memfuncQHAC(void) {
19383
19384 G__tag_memfunc_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QHAC));
19385 G__memfunc_setup("QHAC",285,G__BankClassesDict_290_0_0,105,G__get_linked_tagnum(&G__BankClassesDictLN_QHAC),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
19386 G__memfunc_setup("Class",502,G__BankClassesDict_290_2_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19387 G__memfunc_setup("Class_Name",982,G__BankClassesDict_290_3_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19388 G__memfunc_setup("Class_Version",1339,G__BankClassesDict_290_4_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19389 G__memfunc_setup("Dictionary",1046,G__BankClassesDict_290_5_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19390 G__memfunc_setup("IsA",253,G__BankClassesDict_290_6_0,85,G__get_linked_tagnum(&G__BankClassesDictLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
19391 G__memfunc_setup("ShowMembers",1132,G__BankClassesDict_290_7_0,121,-1,-1,0,2,1,1,0,
19392 "u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
19393 G__memfunc_setup("Streamer",835,G__BankClassesDict_290_8_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
19394 G__memfunc_setup("StreamerNVirtual",1656,G__BankClassesDict_290_9_0,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
19395 G__memfunc_setup("DeclFileName",1145,G__BankClassesDict_290_0_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19396 G__memfunc_setup("ImplFileLine",1178,G__BankClassesDict_290_1_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19397 G__memfunc_setup("ImplFileName",1171,G__BankClassesDict_290_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
19398 G__memfunc_setup("DeclFileLine",1152,G__BankClassesDict_290_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
19399
19400 G__memfunc_setup("QHAC",285,G__BankClassesDict_290_4_1,(int)('i'),G__get_linked_tagnum(&G__BankClassesDictLN_QHAC),-1,0,1,1,1,0,"u 'QHAC' - 11 - -",(char*)NULL,(void*)NULL,0);
19401
19402 G__memfunc_setup("~QHAC",411,G__BankClassesDict_290_5_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
19403 G__tag_memfunc_reset();
19404 }
19405
19406
19407
19408
19409
19410 extern "C" void G__cpp_setup_memfuncBankClassesDict() {
19411 }
19412
19413
19414
19415
19416 static void G__cpp_setup_global0() {
19417
19418
19419 G__resetplocal();
19420
19421
19422 G__resetglobalenv();
19423 }
19424 extern "C" void G__cpp_setup_globalBankClassesDict() {
19425 G__cpp_setup_global0();
19426 }
19427
19428
19429
19430
19431 static void G__cpp_setup_func0() {
19432 G__lastifuncposition();
19433
19434 }
19435
19436 static void G__cpp_setup_func1() {
19437 }
19438
19439 static void G__cpp_setup_func2() {
19440 }
19441
19442 static void G__cpp_setup_func3() {
19443 }
19444
19445 static void G__cpp_setup_func4() {
19446 }
19447
19448 static void G__cpp_setup_func5() {
19449 }
19450
19451 static void G__cpp_setup_func6() {
19452 }
19453
19454 static void G__cpp_setup_func7() {
19455 }
19456
19457 static void G__cpp_setup_func8() {
19458 }
19459
19460 static void G__cpp_setup_func9() {
19461 }
19462
19463 static void G__cpp_setup_func10() {
19464 }
19465
19466 static void G__cpp_setup_func11() {
19467 }
19468
19469 static void G__cpp_setup_func12() {
19470 }
19471
19472 static void G__cpp_setup_func13() {
19473 }
19474
19475 static void G__cpp_setup_func14() {
19476 }
19477
19478 static void G__cpp_setup_func15() {
19479
19480 G__resetifuncposition();
19481 }
19482
19483 extern "C" void G__cpp_setup_funcBankClassesDict() {
19484 G__cpp_setup_func0();
19485 G__cpp_setup_func1();
19486 G__cpp_setup_func2();
19487 G__cpp_setup_func3();
19488 G__cpp_setup_func4();
19489 G__cpp_setup_func5();
19490 G__cpp_setup_func6();
19491 G__cpp_setup_func7();
19492 G__cpp_setup_func8();
19493 G__cpp_setup_func9();
19494 G__cpp_setup_func10();
19495 G__cpp_setup_func11();
19496 G__cpp_setup_func12();
19497 G__cpp_setup_func13();
19498 G__cpp_setup_func14();
19499 G__cpp_setup_func15();
19500 }
19501
19502
19503
19504
19505
19506 G__linked_taginfo G__BankClassesDictLN_TClass = { "TClass" , 99 , -1 };
19507 G__linked_taginfo G__BankClassesDictLN_TBuffer = { "TBuffer" , 99 , -1 };
19508 G__linked_taginfo G__BankClassesDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
19509 G__linked_taginfo G__BankClassesDictLN_TObject = { "TObject" , 99 , -1 };
19510 G__linked_taginfo G__BankClassesDictLN_YV0V_PATTERN = { "YV0V_PATTERN" , 99 , -1 };
19511 G__linked_taginfo G__BankClassesDictLN_FVER_PATTERN = { "FVER_PATTERN" , 99 , -1 };
19512 G__linked_taginfo G__BankClassesDictLN_FKIN_PATTERN = { "FKIN_PATTERN" , 99 , -1 };
19513 G__linked_taginfo G__BankClassesDictLN_QVEC_PATTERN = { "QVEC_PATTERN" , 99 , -1 };
19514 G__linked_taginfo G__BankClassesDictLN_QDET_PATTERN = { "QDET_PATTERN" , 99 , -1 };
19515 G__linked_taginfo G__BankClassesDictLN_QVRT_PATTERN = { "QVRT_PATTERN" , 99 , -1 };
19516 G__linked_taginfo G__BankClassesDictLN_FRFT_PATTERN = { "FRFT_PATTERN" , 99 , -1 };
19517 G__linked_taginfo G__BankClassesDictLN_FRTL_PATTERN = { "FRTL_PATTERN" , 99 , -1 };
19518 G__linked_taginfo G__BankClassesDictLN_TEXS_PATTERN = { "TEXS_PATTERN" , 99 , -1 };
19519 G__linked_taginfo G__BankClassesDictLN_EIDT_PATTERN = { "EIDT_PATTERN" , 99 , -1 };
19520 G__linked_taginfo G__BankClassesDictLN_HMAD_PATTERN = { "HMAD_PATTERN" , 99 , -1 };
19521 G__linked_taginfo G__BankClassesDictLN_MCAD_PATTERN = { "MCAD_PATTERN" , 99 , -1 };
19522 G__linked_taginfo G__BankClassesDictLN_PECO_PATTERN = { "PECO_PATTERN" , 99 , -1 };
19523 G__linked_taginfo G__BankClassesDictLN_PHCO_PATTERN = { "PHCO_PATTERN" , 99 , -1 };
19524 G__linked_taginfo G__BankClassesDictLN_PEPT_PATTERN = { "PEPT_PATTERN" , 99 , -1 };
19525 G__linked_taginfo G__BankClassesDictLN_FRID_PATTERN = { "FRID_PATTERN" , 99 , -1 };
19526 G__linked_taginfo G__BankClassesDictLN_EFOL_PATTERN = { "EFOL_PATTERN" , 99 , -1 };
19527 G__linked_taginfo G__BankClassesDictLN_DENF_PATTERN = { "DENF_PATTERN" , 99 , -1 };
19528 G__linked_taginfo G__BankClassesDictLN_DENW_PATTERN = { "DENW_PATTERN" , 99 , -1 };
19529 G__linked_taginfo G__BankClassesDictLN_PCQA_PATTERN = { "PCQA_PATTERN" , 99 , -1 };
19530 G__linked_taginfo G__BankClassesDictLN_EGPC_PATTERN = { "EGPC_PATTERN" , 99 , -1 };
19531 G__linked_taginfo G__BankClassesDictLN_MUID_PATTERN = { "MUID_PATTERN" , 99 , -1 };
19532 G__linked_taginfo G__BankClassesDictLN_PGPC_PATTERN = { "PGPC_PATTERN" , 99 , -1 };
19533 G__linked_taginfo G__BankClassesDictLN_PGAC_PATTERN = { "PGAC_PATTERN" , 99 , -1 };
19534 G__linked_taginfo G__BankClassesDictLN_PDLT_PATTERN = { "PDLT_PATTERN" , 99 , -1 };
19535 G__linked_taginfo G__BankClassesDictLN_PMLT_PATTERN = { "PMLT_PATTERN" , 99 , -1 };
19536 G__linked_taginfo G__BankClassesDictLN_ALPB_PATTERN = { "ALPB_PATTERN" , 99 , -1 };
19537 G__linked_taginfo G__BankClassesDictLN_ALRP_PATTERN = { "ALRP_PATTERN" , 99 , -1 };
19538 G__linked_taginfo G__BankClassesDictLN_RNL2_PATTERN = { "RNL2_PATTERN" , 99 , -1 };
19539 G__linked_taginfo G__BankClassesDictLN_RNF2_PATTERN = { "RNF2_PATTERN" , 99 , -1 };
19540 G__linked_taginfo G__BankClassesDictLN_RNR2_PATTERN = { "RNR2_PATTERN" , 99 , -1 };
19541 G__linked_taginfo G__BankClassesDictLN_RLEP_PATTERN = { "RLEP_PATTERN" , 99 , -1 };
19542 G__linked_taginfo G__BankClassesDictLN_LFIL_PATTERN = { "LFIL_PATTERN" , 99 , -1 };
19543 G__linked_taginfo G__BankClassesDictLN_EVEH_PATTERN = { "EVEH_PATTERN" , 99 , -1 };
19544 G__linked_taginfo G__BankClassesDictLN_KEVH_PATTERN = { "KEVH_PATTERN" , 99 , -1 };
19545 G__linked_taginfo G__BankClassesDictLN_REVH_PATTERN = { "REVH_PATTERN" , 99 , -1 };
19546 G__linked_taginfo G__BankClassesDictLN_LOLE_PATTERN = { "LOLE_PATTERN" , 99 , -1 };
19547 G__linked_taginfo G__BankClassesDictLN_X1RG_PATTERN = { "X1RG_PATTERN" , 99 , -1 };
19548 G__linked_taginfo G__BankClassesDictLN_BOMB_PATTERN = { "BOMB_PATTERN" , 99 , -1 };
19549 G__linked_taginfo G__BankClassesDictLN_RUNH_PATTERN = { "RUNH_PATTERN" , 99 , -1 };
19550 G__linked_taginfo G__BankClassesDictLN_ASIM_PATTERN = { "ASIM_PATTERN" , 99 , -1 };
19551 G__linked_taginfo G__BankClassesDictLN_ADBR_PATTERN = { "ADBR_PATTERN" , 99 , -1 };
19552 G__linked_taginfo G__BankClassesDictLN_XTBN_PATTERN = { "XTBN_PATTERN" , 99 , -1 };
19553 G__linked_taginfo G__BankClassesDictLN_XTCN_PATTERN = { "XTCN_PATTERN" , 99 , -1 };
19554 G__linked_taginfo G__BankClassesDictLN_XTOP_PATTERN = { "XTOP_PATTERN" , 99 , -1 };
19555 G__linked_taginfo G__BankClassesDictLN_LUPA_PATTERN = { "LUPA_PATTERN" , 99 , -1 };
19556 G__linked_taginfo G__BankClassesDictLN_SILH_PATTERN = { "SILH_PATTERN" , 99 , -1 };
19557 G__linked_taginfo G__BankClassesDictLN_XHVB_PATTERN = { "XHVB_PATTERN" , 99 , -1 };
19558 G__linked_taginfo G__BankClassesDictLN_XTEB_PATTERN = { "XTEB_PATTERN" , 99 , -1 };
19559 G__linked_taginfo G__BankClassesDictLN_XTRB_PATTERN = { "XTRB_PATTERN" , 99 , -1 };
19560 G__linked_taginfo G__BankClassesDictLN_DTBP_PATTERN = { "DTBP_PATTERN" , 99 , -1 };
19561 G__linked_taginfo G__BankClassesDictLN_VHBV_PATTERN = { "VHBV_PATTERN" , 99 , -1 };
19562 G__linked_taginfo G__BankClassesDictLN_VHPV_PATTERN = { "VHPV_PATTERN" , 99 , -1 };
19563 G__linked_taginfo G__BankClassesDictLN_EAUX_PATTERN = { "EAUX_PATTERN" , 99 , -1 };
19564 G__linked_taginfo G__BankClassesDictLN_SIX2_PATTERN = { "SIX2_PATTERN" , 99 , -1 };
19565 G__linked_taginfo G__BankClassesDictLN_X1TV_PATTERN = { "X1TV_PATTERN" , 99 , -1 };
19566 G__linked_taginfo G__BankClassesDictLN_KWGT_PATTERN = { "KWGT_PATTERN" , 99 , -1 };
19567 G__linked_taginfo G__BankClassesDictLN_X1IP_PATTERN = { "X1IP_PATTERN" , 99 , -1 };
19568 G__linked_taginfo G__BankClassesDictLN_SIXA_PATTERN = { "SIXA_PATTERN" , 99 , -1 };
19569 G__linked_taginfo G__BankClassesDictLN_SITC_PATTERN = { "SITC_PATTERN" , 99 , -1 };
19570 G__linked_taginfo G__BankClassesDictLN_SRCO_PATTERN = { "SRCO_PATTERN" , 99 , -1 };
19571 G__linked_taginfo G__BankClassesDictLN_X1TH_PATTERN = { "X1TH_PATTERN" , 99 , -1 };
19572 G__linked_taginfo G__BankClassesDictLN_X1AD_PATTERN = { "X1AD_PATTERN" , 99 , -1 };
19573 G__linked_taginfo G__BankClassesDictLN_QLIN = { "QLIN" , 99 , -1 };
19574 G__linked_taginfo G__BankClassesDictLN_QMTL = { "QMTL" , 99 , -1 };
19575 G__linked_taginfo G__BankClassesDictLN_QMTS = { "QMTS" , 99 , -1 };
19576 G__linked_taginfo G__BankClassesDictLN_FRFT = { "FRFT" , 99 , -1 };
19577 G__linked_taginfo G__BankClassesDictLN_FRTL = { "FRTL" , 99 , -1 };
19578 G__linked_taginfo G__BankClassesDictLN_TEXS = { "TEXS" , 99 , -1 };
19579 G__linked_taginfo G__BankClassesDictLN_HMAD = { "HMAD" , 99 , -1 };
19580 G__linked_taginfo G__BankClassesDictLN_MCAD = { "MCAD" , 99 , -1 };
19581 G__linked_taginfo G__BankClassesDictLN_PECO = { "PECO" , 99 , -1 };
19582 G__linked_taginfo G__BankClassesDictLN_EIDT = { "EIDT" , 99 , -1 };
19583 G__linked_taginfo G__BankClassesDictLN_PHCO = { "PHCO" , 99 , -1 };
19584 G__linked_taginfo G__BankClassesDictLN_PEPT = { "PEPT" , 99 , -1 };
19585 G__linked_taginfo G__BankClassesDictLN_FRID = { "FRID" , 99 , -1 };
19586 G__linked_taginfo G__BankClassesDictLN_EFOL = { "EFOL" , 99 , -1 };
19587 G__linked_taginfo G__BankClassesDictLN_PCQA = { "PCQA" , 99 , -1 };
19588 G__linked_taginfo G__BankClassesDictLN_EGPC = { "EGPC" , 99 , -1 };
19589 G__linked_taginfo G__BankClassesDictLN_MUID = { "MUID" , 99 , -1 };
19590 G__linked_taginfo G__BankClassesDictLN_PGPC = { "PGPC" , 99 , -1 };
19591 G__linked_taginfo G__BankClassesDictLN_PGAC = { "PGAC" , 99 , -1 };
19592 G__linked_taginfo G__BankClassesDictLN_PDLT = { "PDLT" , 99 , -1 };
19593 G__linked_taginfo G__BankClassesDictLN_PMLT = { "PMLT" , 99 , -1 };
19594 G__linked_taginfo G__BankClassesDictLN_QDET = { "QDET" , 99 , -1 };
19595 G__linked_taginfo G__BankClassesDictLN_QVEC = { "QVEC" , 99 , -1 };
19596 G__linked_taginfo G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR = { "vector<unsigned short,allocator<unsigned short> >" , 99 , -1 };
19597 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEunsignedsPshortcOintgR = { "random_access_iterator<unsigned short,int>" , 115 , -1 };
19598 G__linked_taginfo G__BankClassesDictLN_YV0V = { "YV0V" , 99 , -1 };
19599 G__linked_taginfo G__BankClassesDictLN_FKIN = { "FKIN" , 99 , -1 };
19600 G__linked_taginfo G__BankClassesDictLN_FVER = { "FVER" , 99 , -1 };
19601 G__linked_taginfo G__BankClassesDictLN_vectorlEFKINmUcOallocatorlEFKINmUgRsPgR = { "vector<FKIN*,allocator<FKIN*> >" , 99 , -1 };
19602 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEFKINmUcOintgR = { "random_access_iterator<FKIN*,int>" , 115 , -1 };
19603 G__linked_taginfo G__BankClassesDictLN_QVRT = { "QVRT" , 99 , -1 };
19604 G__linked_taginfo G__BankClassesDictLN_ALPB = { "ALPB" , 99 , -1 };
19605 G__linked_taginfo G__BankClassesDictLN_ALRP = { "ALRP" , 99 , -1 };
19606 G__linked_taginfo G__BankClassesDictLN_RNL2 = { "RNL2" , 99 , -1 };
19607 G__linked_taginfo G__BankClassesDictLN_RNF2 = { "RNF2" , 99 , -1 };
19608 G__linked_taginfo G__BankClassesDictLN_RNR2 = { "RNR2" , 99 , -1 };
19609 G__linked_taginfo G__BankClassesDictLN_RLEP = { "RLEP" , 99 , -1 };
19610 G__linked_taginfo G__BankClassesDictLN_LFIL = { "LFIL" , 99 , -1 };
19611 G__linked_taginfo G__BankClassesDictLN_EVEH = { "EVEH" , 99 , -1 };
19612 G__linked_taginfo G__BankClassesDictLN_KEVH = { "KEVH" , 99 , -1 };
19613 G__linked_taginfo G__BankClassesDictLN_REVH = { "REVH" , 99 , -1 };
19614 G__linked_taginfo G__BankClassesDictLN_LOLE = { "LOLE" , 99 , -1 };
19615 G__linked_taginfo G__BankClassesDictLN_X1RG = { "X1RG" , 99 , -1 };
19616 G__linked_taginfo G__BankClassesDictLN_BOMB = { "BOMB" , 99 , -1 };
19617 G__linked_taginfo G__BankClassesDictLN_RUNH = { "RUNH" , 99 , -1 };
19618 G__linked_taginfo G__BankClassesDictLN_ASIM = { "ASIM" , 99 , -1 };
19619 G__linked_taginfo G__BankClassesDictLN_ADBR = { "ADBR" , 99 , -1 };
19620 G__linked_taginfo G__BankClassesDictLN_XTBN = { "XTBN" , 99 , -1 };
19621 G__linked_taginfo G__BankClassesDictLN_XTCN = { "XTCN" , 99 , -1 };
19622 G__linked_taginfo G__BankClassesDictLN_XTOP = { "XTOP" , 99 , -1 };
19623 G__linked_taginfo G__BankClassesDictLN_LUPA = { "LUPA" , 99 , -1 };
19624 G__linked_taginfo G__BankClassesDictLN_SILH = { "SILH" , 99 , -1 };
19625 G__linked_taginfo G__BankClassesDictLN_XHVB = { "XHVB" , 99 , -1 };
19626 G__linked_taginfo G__BankClassesDictLN_XTEB = { "XTEB" , 99 , -1 };
19627 G__linked_taginfo G__BankClassesDictLN_XTRB = { "XTRB" , 99 , -1 };
19628 G__linked_taginfo G__BankClassesDictLN_DTBP = { "DTBP" , 99 , -1 };
19629 G__linked_taginfo G__BankClassesDictLN_VHBV = { "VHBV" , 99 , -1 };
19630 G__linked_taginfo G__BankClassesDictLN_VHPV = { "VHPV" , 99 , -1 };
19631 G__linked_taginfo G__BankClassesDictLN_EAUX = { "EAUX" , 99 , -1 };
19632 G__linked_taginfo G__BankClassesDictLN_SIX2 = { "SIX2" , 99 , -1 };
19633 G__linked_taginfo G__BankClassesDictLN_X1TV = { "X1TV" , 99 , -1 };
19634 G__linked_taginfo G__BankClassesDictLN_KWGT = { "KWGT" , 99 , -1 };
19635 G__linked_taginfo G__BankClassesDictLN_X1IP = { "X1IP" , 99 , -1 };
19636 G__linked_taginfo G__BankClassesDictLN_SIXA = { "SIXA" , 99 , -1 };
19637 G__linked_taginfo G__BankClassesDictLN_SITC = { "SITC" , 99 , -1 };
19638 G__linked_taginfo G__BankClassesDictLN_SRCO = { "SRCO" , 99 , -1 };
19639 G__linked_taginfo G__BankClassesDictLN_X1TH = { "X1TH" , 99 , -1 };
19640 G__linked_taginfo G__BankClassesDictLN_X1AD = { "X1AD" , 99 , -1 };
19641 G__linked_taginfo G__BankClassesDictLN_QEXT = { "QEXT" , 99 , -1 };
19642 G__linked_taginfo G__BankClassesDictLN_QHAC = { "QHAC" , 99 , -1 };
19643 G__linked_taginfo G__BankClassesDictLN_vectorlELOLEmUcOallocatorlELOLEmUgRsPgR = { "vector<LOLE*,allocator<LOLE*> >" , 99 , -1 };
19644 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlELOLEmUcOintgR = { "random_access_iterator<LOLE*,int>" , 115 , -1 };
19645 G__linked_taginfo G__BankClassesDictLN_vectorlEX1RGmUcOallocatorlEX1RGmUgRsPgR = { "vector<X1RG*,allocator<X1RG*> >" , 99 , -1 };
19646 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEX1RGmUcOintgR = { "random_access_iterator<X1RG*,int>" , 115 , -1 };
19647 G__linked_taginfo G__BankClassesDictLN_vectorlEXTBNmUcOallocatorlEXTBNmUgRsPgR = { "vector<XTBN*,allocator<XTBN*> >" , 99 , -1 };
19648 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEXTBNmUcOintgR = { "random_access_iterator<XTBN*,int>" , 115 , -1 };
19649 G__linked_taginfo G__BankClassesDictLN_vectorlEXHVBmUcOallocatorlEXHVBmUgRsPgR = { "vector<XHVB*,allocator<XHVB*> >" , 99 , -1 };
19650 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEXHVBmUcOintgR = { "random_access_iterator<XHVB*,int>" , 115 , -1 };
19651 G__linked_taginfo G__BankClassesDictLN_vectorlEVHPVmUcOallocatorlEVHPVmUgRsPgR = { "vector<VHPV*,allocator<VHPV*> >" , 99 , -1 };
19652 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEVHPVmUcOintgR = { "random_access_iterator<VHPV*,int>" , 115 , -1 };
19653 G__linked_taginfo G__BankClassesDictLN_vectorlEVHBVmUcOallocatorlEVHBVmUgRsPgR = { "vector<VHBV*,allocator<VHBV*> >" , 99 , -1 };
19654 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEVHBVmUcOintgR = { "random_access_iterator<VHBV*,int>" , 115 , -1 };
19655 G__linked_taginfo G__BankClassesDictLN_vectorlEX1TVmUcOallocatorlEX1TVmUgRsPgR = { "vector<X1TV*,allocator<X1TV*> >" , 99 , -1 };
19656 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEX1TVmUcOintgR = { "random_access_iterator<X1TV*,int>" , 115 , -1 };
19657 G__linked_taginfo G__BankClassesDictLN_vectorlEKWGTmUcOallocatorlEKWGTmUgRsPgR = { "vector<KWGT*,allocator<KWGT*> >" , 99 , -1 };
19658 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEKWGTmUcOintgR = { "random_access_iterator<KWGT*,int>" , 115 , -1 };
19659 G__linked_taginfo G__BankClassesDictLN_vectorlEX1IPmUcOallocatorlEX1IPmUgRsPgR = { "vector<X1IP*,allocator<X1IP*> >" , 99 , -1 };
19660 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEX1IPmUcOintgR = { "random_access_iterator<X1IP*,int>" , 115 , -1 };
19661 G__linked_taginfo G__BankClassesDictLN_vectorlESIXAmUcOallocatorlESIXAmUgRsPgR = { "vector<SIXA*,allocator<SIXA*> >" , 99 , -1 };
19662 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlESIXAmUcOintgR = { "random_access_iterator<SIXA*,int>" , 115 , -1 };
19663 G__linked_taginfo G__BankClassesDictLN_vectorlESRCOmUcOallocatorlESRCOmUgRsPgR = { "vector<SRCO*,allocator<SRCO*> >" , 99 , -1 };
19664 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlESRCOmUcOintgR = { "random_access_iterator<SRCO*,int>" , 115 , -1 };
19665 G__linked_taginfo G__BankClassesDictLN_vectorlEX1THmUcOallocatorlEX1THmUgRsPgR = { "vector<X1TH*,allocator<X1TH*> >" , 99 , -1 };
19666 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEX1THmUcOintgR = { "random_access_iterator<X1TH*,int>" , 115 , -1 };
19667 G__linked_taginfo G__BankClassesDictLN_vectorlEX1ADmUcOallocatorlEX1ADmUgRsPgR = { "vector<X1AD*,allocator<X1AD*> >" , 99 , -1 };
19668 G__linked_taginfo G__BankClassesDictLN_random_access_iteratorlEX1ADmUcOintgR = { "random_access_iterator<X1AD*,int>" , 115 , -1 };
19669
19670
19671 extern "C" void G__cpp_reset_tagtableBankClassesDict() {
19672 G__BankClassesDictLN_TClass.tagnum = -1 ;
19673 G__BankClassesDictLN_TBuffer.tagnum = -1 ;
19674 G__BankClassesDictLN_TMemberInspector.tagnum = -1 ;
19675 G__BankClassesDictLN_TObject.tagnum = -1 ;
19676 G__BankClassesDictLN_YV0V_PATTERN.tagnum = -1 ;
19677 G__BankClassesDictLN_FVER_PATTERN.tagnum = -1 ;
19678 G__BankClassesDictLN_FKIN_PATTERN.tagnum = -1 ;
19679 G__BankClassesDictLN_QVEC_PATTERN.tagnum = -1 ;
19680 G__BankClassesDictLN_QDET_PATTERN.tagnum = -1 ;
19681 G__BankClassesDictLN_QVRT_PATTERN.tagnum = -1 ;
19682 G__BankClassesDictLN_FRFT_PATTERN.tagnum = -1 ;
19683 G__BankClassesDictLN_FRTL_PATTERN.tagnum = -1 ;
19684 G__BankClassesDictLN_TEXS_PATTERN.tagnum = -1 ;
19685 G__BankClassesDictLN_EIDT_PATTERN.tagnum = -1 ;
19686 G__BankClassesDictLN_HMAD_PATTERN.tagnum = -1 ;
19687 G__BankClassesDictLN_MCAD_PATTERN.tagnum = -1 ;
19688 G__BankClassesDictLN_PECO_PATTERN.tagnum = -1 ;
19689 G__BankClassesDictLN_PHCO_PATTERN.tagnum = -1 ;
19690 G__BankClassesDictLN_PEPT_PATTERN.tagnum = -1 ;
19691 G__BankClassesDictLN_FRID_PATTERN.tagnum = -1 ;
19692 G__BankClassesDictLN_EFOL_PATTERN.tagnum = -1 ;
19693 G__BankClassesDictLN_DENF_PATTERN.tagnum = -1 ;
19694 G__BankClassesDictLN_DENW_PATTERN.tagnum = -1 ;
19695 G__BankClassesDictLN_PCQA_PATTERN.tagnum = -1 ;
19696 G__BankClassesDictLN_EGPC_PATTERN.tagnum = -1 ;
19697 G__BankClassesDictLN_MUID_PATTERN.tagnum = -1 ;
19698 G__BankClassesDictLN_PGPC_PATTERN.tagnum = -1 ;
19699 G__BankClassesDictLN_PGAC_PATTERN.tagnum = -1 ;
19700 G__BankClassesDictLN_PDLT_PATTERN.tagnum = -1 ;
19701 G__BankClassesDictLN_PMLT_PATTERN.tagnum = -1 ;
19702 G__BankClassesDictLN_ALPB_PATTERN.tagnum = -1 ;
19703 G__BankClassesDictLN_ALRP_PATTERN.tagnum = -1 ;
19704 G__BankClassesDictLN_RNL2_PATTERN.tagnum = -1 ;
19705 G__BankClassesDictLN_RNF2_PATTERN.tagnum = -1 ;
19706 G__BankClassesDictLN_RNR2_PATTERN.tagnum = -1 ;
19707 G__BankClassesDictLN_RLEP_PATTERN.tagnum = -1 ;
19708 G__BankClassesDictLN_LFIL_PATTERN.tagnum = -1 ;
19709 G__BankClassesDictLN_EVEH_PATTERN.tagnum = -1 ;
19710 G__BankClassesDictLN_KEVH_PATTERN.tagnum = -1 ;
19711 G__BankClassesDictLN_REVH_PATTERN.tagnum = -1 ;
19712 G__BankClassesDictLN_LOLE_PATTERN.tagnum = -1 ;
19713 G__BankClassesDictLN_X1RG_PATTERN.tagnum = -1 ;
19714 G__BankClassesDictLN_BOMB_PATTERN.tagnum = -1 ;
19715 G__BankClassesDictLN_RUNH_PATTERN.tagnum = -1 ;
19716 G__BankClassesDictLN_ASIM_PATTERN.tagnum = -1 ;
19717 G__BankClassesDictLN_ADBR_PATTERN.tagnum = -1 ;
19718 G__BankClassesDictLN_XTBN_PATTERN.tagnum = -1 ;
19719 G__BankClassesDictLN_XTCN_PATTERN.tagnum = -1 ;
19720 G__BankClassesDictLN_XTOP_PATTERN.tagnum = -1 ;
19721 G__BankClassesDictLN_LUPA_PATTERN.tagnum = -1 ;
19722 G__BankClassesDictLN_SILH_PATTERN.tagnum = -1 ;
19723 G__BankClassesDictLN_XHVB_PATTERN.tagnum = -1 ;
19724 G__BankClassesDictLN_XTEB_PATTERN.tagnum = -1 ;
19725 G__BankClassesDictLN_XTRB_PATTERN.tagnum = -1 ;
19726 G__BankClassesDictLN_DTBP_PATTERN.tagnum = -1 ;
19727 G__BankClassesDictLN_VHBV_PATTERN.tagnum = -1 ;
19728 G__BankClassesDictLN_VHPV_PATTERN.tagnum = -1 ;
19729 G__BankClassesDictLN_EAUX_PATTERN.tagnum = -1 ;
19730 G__BankClassesDictLN_SIX2_PATTERN.tagnum = -1 ;
19731 G__BankClassesDictLN_X1TV_PATTERN.tagnum = -1 ;
19732 G__BankClassesDictLN_KWGT_PATTERN.tagnum = -1 ;
19733 G__BankClassesDictLN_X1IP_PATTERN.tagnum = -1 ;
19734 G__BankClassesDictLN_SIXA_PATTERN.tagnum = -1 ;
19735 G__BankClassesDictLN_SITC_PATTERN.tagnum = -1 ;
19736 G__BankClassesDictLN_SRCO_PATTERN.tagnum = -1 ;
19737 G__BankClassesDictLN_X1TH_PATTERN.tagnum = -1 ;
19738 G__BankClassesDictLN_X1AD_PATTERN.tagnum = -1 ;
19739 G__BankClassesDictLN_QLIN.tagnum = -1 ;
19740 G__BankClassesDictLN_QMTL.tagnum = -1 ;
19741 G__BankClassesDictLN_QMTS.tagnum = -1 ;
19742 G__BankClassesDictLN_FRFT.tagnum = -1 ;
19743 G__BankClassesDictLN_FRTL.tagnum = -1 ;
19744 G__BankClassesDictLN_TEXS.tagnum = -1 ;
19745 G__BankClassesDictLN_HMAD.tagnum = -1 ;
19746 G__BankClassesDictLN_MCAD.tagnum = -1 ;
19747 G__BankClassesDictLN_PECO.tagnum = -1 ;
19748 G__BankClassesDictLN_EIDT.tagnum = -1 ;
19749 G__BankClassesDictLN_PHCO.tagnum = -1 ;
19750 G__BankClassesDictLN_PEPT.tagnum = -1 ;
19751 G__BankClassesDictLN_FRID.tagnum = -1 ;
19752 G__BankClassesDictLN_EFOL.tagnum = -1 ;
19753 G__BankClassesDictLN_PCQA.tagnum = -1 ;
19754 G__BankClassesDictLN_EGPC.tagnum = -1 ;
19755 G__BankClassesDictLN_MUID.tagnum = -1 ;
19756 G__BankClassesDictLN_PGPC.tagnum = -1 ;
19757 G__BankClassesDictLN_PGAC.tagnum = -1 ;
19758 G__BankClassesDictLN_PDLT.tagnum = -1 ;
19759 G__BankClassesDictLN_PMLT.tagnum = -1 ;
19760 G__BankClassesDictLN_QDET.tagnum = -1 ;
19761 G__BankClassesDictLN_QVEC.tagnum = -1 ;
19762 G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR.tagnum = -1 ;
19763 G__BankClassesDictLN_random_access_iteratorlEunsignedsPshortcOintgR.tagnum = -1 ;
19764 G__BankClassesDictLN_YV0V.tagnum = -1 ;
19765 G__BankClassesDictLN_FKIN.tagnum = -1 ;
19766 G__BankClassesDictLN_FVER.tagnum = -1 ;
19767 G__BankClassesDictLN_vectorlEFKINmUcOallocatorlEFKINmUgRsPgR.tagnum = -1 ;
19768 G__BankClassesDictLN_random_access_iteratorlEFKINmUcOintgR.tagnum = -1 ;
19769 G__BankClassesDictLN_QVRT.tagnum = -1 ;
19770 G__BankClassesDictLN_ALPB.tagnum = -1 ;
19771 G__BankClassesDictLN_ALRP.tagnum = -1 ;
19772 G__BankClassesDictLN_RNL2.tagnum = -1 ;
19773 G__BankClassesDictLN_RNF2.tagnum = -1 ;
19774 G__BankClassesDictLN_RNR2.tagnum = -1 ;
19775 G__BankClassesDictLN_RLEP.tagnum = -1 ;
19776 G__BankClassesDictLN_LFIL.tagnum = -1 ;
19777 G__BankClassesDictLN_EVEH.tagnum = -1 ;
19778 G__BankClassesDictLN_KEVH.tagnum = -1 ;
19779 G__BankClassesDictLN_REVH.tagnum = -1 ;
19780 G__BankClassesDictLN_LOLE.tagnum = -1 ;
19781 G__BankClassesDictLN_X1RG.tagnum = -1 ;
19782 G__BankClassesDictLN_BOMB.tagnum = -1 ;
19783 G__BankClassesDictLN_RUNH.tagnum = -1 ;
19784 G__BankClassesDictLN_ASIM.tagnum = -1 ;
19785 G__BankClassesDictLN_ADBR.tagnum = -1 ;
19786 G__BankClassesDictLN_XTBN.tagnum = -1 ;
19787 G__BankClassesDictLN_XTCN.tagnum = -1 ;
19788 G__BankClassesDictLN_XTOP.tagnum = -1 ;
19789 G__BankClassesDictLN_LUPA.tagnum = -1 ;
19790 G__BankClassesDictLN_SILH.tagnum = -1 ;
19791 G__BankClassesDictLN_XHVB.tagnum = -1 ;
19792 G__BankClassesDictLN_XTEB.tagnum = -1 ;
19793 G__BankClassesDictLN_XTRB.tagnum = -1 ;
19794 G__BankClassesDictLN_DTBP.tagnum = -1 ;
19795 G__BankClassesDictLN_VHBV.tagnum = -1 ;
19796 G__BankClassesDictLN_VHPV.tagnum = -1 ;
19797 G__BankClassesDictLN_EAUX.tagnum = -1 ;
19798 G__BankClassesDictLN_SIX2.tagnum = -1 ;
19799 G__BankClassesDictLN_X1TV.tagnum = -1 ;
19800 G__BankClassesDictLN_KWGT.tagnum = -1 ;
19801 G__BankClassesDictLN_X1IP.tagnum = -1 ;
19802 G__BankClassesDictLN_SIXA.tagnum = -1 ;
19803 G__BankClassesDictLN_SITC.tagnum = -1 ;
19804 G__BankClassesDictLN_SRCO.tagnum = -1 ;
19805 G__BankClassesDictLN_X1TH.tagnum = -1 ;
19806 G__BankClassesDictLN_X1AD.tagnum = -1 ;
19807 G__BankClassesDictLN_QEXT.tagnum = -1 ;
19808 G__BankClassesDictLN_QHAC.tagnum = -1 ;
19809 G__BankClassesDictLN_vectorlELOLEmUcOallocatorlELOLEmUgRsPgR.tagnum = -1 ;
19810 G__BankClassesDictLN_random_access_iteratorlELOLEmUcOintgR.tagnum = -1 ;
19811 G__BankClassesDictLN_vectorlEX1RGmUcOallocatorlEX1RGmUgRsPgR.tagnum = -1 ;
19812 G__BankClassesDictLN_random_access_iteratorlEX1RGmUcOintgR.tagnum = -1 ;
19813 G__BankClassesDictLN_vectorlEXTBNmUcOallocatorlEXTBNmUgRsPgR.tagnum = -1 ;
19814 G__BankClassesDictLN_random_access_iteratorlEXTBNmUcOintgR.tagnum = -1 ;
19815 G__BankClassesDictLN_vectorlEXHVBmUcOallocatorlEXHVBmUgRsPgR.tagnum = -1 ;
19816 G__BankClassesDictLN_random_access_iteratorlEXHVBmUcOintgR.tagnum = -1 ;
19817 G__BankClassesDictLN_vectorlEVHPVmUcOallocatorlEVHPVmUgRsPgR.tagnum = -1 ;
19818 G__BankClassesDictLN_random_access_iteratorlEVHPVmUcOintgR.tagnum = -1 ;
19819 G__BankClassesDictLN_vectorlEVHBVmUcOallocatorlEVHBVmUgRsPgR.tagnum = -1 ;
19820 G__BankClassesDictLN_random_access_iteratorlEVHBVmUcOintgR.tagnum = -1 ;
19821 G__BankClassesDictLN_vectorlEX1TVmUcOallocatorlEX1TVmUgRsPgR.tagnum = -1 ;
19822 G__BankClassesDictLN_random_access_iteratorlEX1TVmUcOintgR.tagnum = -1 ;
19823 G__BankClassesDictLN_vectorlEKWGTmUcOallocatorlEKWGTmUgRsPgR.tagnum = -1 ;
19824 G__BankClassesDictLN_random_access_iteratorlEKWGTmUcOintgR.tagnum = -1 ;
19825 G__BankClassesDictLN_vectorlEX1IPmUcOallocatorlEX1IPmUgRsPgR.tagnum = -1 ;
19826 G__BankClassesDictLN_random_access_iteratorlEX1IPmUcOintgR.tagnum = -1 ;
19827 G__BankClassesDictLN_vectorlESIXAmUcOallocatorlESIXAmUgRsPgR.tagnum = -1 ;
19828 G__BankClassesDictLN_random_access_iteratorlESIXAmUcOintgR.tagnum = -1 ;
19829 G__BankClassesDictLN_vectorlESRCOmUcOallocatorlESRCOmUgRsPgR.tagnum = -1 ;
19830 G__BankClassesDictLN_random_access_iteratorlESRCOmUcOintgR.tagnum = -1 ;
19831 G__BankClassesDictLN_vectorlEX1THmUcOallocatorlEX1THmUgRsPgR.tagnum = -1 ;
19832 G__BankClassesDictLN_random_access_iteratorlEX1THmUcOintgR.tagnum = -1 ;
19833 G__BankClassesDictLN_vectorlEX1ADmUcOallocatorlEX1ADmUgRsPgR.tagnum = -1 ;
19834 G__BankClassesDictLN_random_access_iteratorlEX1ADmUcOintgR.tagnum = -1 ;
19835 }
19836
19837
19838 extern "C" void G__cpp_setup_tagtableBankClassesDict() {
19839
19840
19841 G__get_linked_tagnum(&G__BankClassesDictLN_TClass);
19842 G__get_linked_tagnum(&G__BankClassesDictLN_TBuffer);
19843 G__get_linked_tagnum(&G__BankClassesDictLN_TMemberInspector);
19844 G__get_linked_tagnum(&G__BankClassesDictLN_TObject);
19845 G__get_linked_tagnum(&G__BankClassesDictLN_YV0V_PATTERN);
19846 G__get_linked_tagnum(&G__BankClassesDictLN_FVER_PATTERN);
19847 G__get_linked_tagnum(&G__BankClassesDictLN_FKIN_PATTERN);
19848 G__get_linked_tagnum(&G__BankClassesDictLN_QVEC_PATTERN);
19849 G__get_linked_tagnum(&G__BankClassesDictLN_QDET_PATTERN);
19850 G__get_linked_tagnum(&G__BankClassesDictLN_QVRT_PATTERN);
19851 G__get_linked_tagnum(&G__BankClassesDictLN_FRFT_PATTERN);
19852 G__get_linked_tagnum(&G__BankClassesDictLN_FRTL_PATTERN);
19853 G__get_linked_tagnum(&G__BankClassesDictLN_TEXS_PATTERN);
19854 G__get_linked_tagnum(&G__BankClassesDictLN_EIDT_PATTERN);
19855 G__get_linked_tagnum(&G__BankClassesDictLN_HMAD_PATTERN);
19856 G__get_linked_tagnum(&G__BankClassesDictLN_MCAD_PATTERN);
19857 G__get_linked_tagnum(&G__BankClassesDictLN_PECO_PATTERN);
19858 G__get_linked_tagnum(&G__BankClassesDictLN_PHCO_PATTERN);
19859 G__get_linked_tagnum(&G__BankClassesDictLN_PEPT_PATTERN);
19860 G__get_linked_tagnum(&G__BankClassesDictLN_FRID_PATTERN);
19861 G__get_linked_tagnum(&G__BankClassesDictLN_EFOL_PATTERN);
19862 G__get_linked_tagnum(&G__BankClassesDictLN_DENF_PATTERN);
19863 G__get_linked_tagnum(&G__BankClassesDictLN_DENW_PATTERN);
19864 G__get_linked_tagnum(&G__BankClassesDictLN_PCQA_PATTERN);
19865 G__get_linked_tagnum(&G__BankClassesDictLN_EGPC_PATTERN);
19866 G__get_linked_tagnum(&G__BankClassesDictLN_MUID_PATTERN);
19867 G__get_linked_tagnum(&G__BankClassesDictLN_PGPC_PATTERN);
19868 G__get_linked_tagnum(&G__BankClassesDictLN_PGAC_PATTERN);
19869 G__get_linked_tagnum(&G__BankClassesDictLN_PDLT_PATTERN);
19870 G__get_linked_tagnum(&G__BankClassesDictLN_PMLT_PATTERN);
19871 G__get_linked_tagnum(&G__BankClassesDictLN_ALPB_PATTERN);
19872 G__get_linked_tagnum(&G__BankClassesDictLN_ALRP_PATTERN);
19873 G__get_linked_tagnum(&G__BankClassesDictLN_RNL2_PATTERN);
19874 G__get_linked_tagnum(&G__BankClassesDictLN_RNF2_PATTERN);
19875 G__get_linked_tagnum(&G__BankClassesDictLN_RNR2_PATTERN);
19876 G__get_linked_tagnum(&G__BankClassesDictLN_RLEP_PATTERN);
19877 G__get_linked_tagnum(&G__BankClassesDictLN_LFIL_PATTERN);
19878 G__get_linked_tagnum(&G__BankClassesDictLN_EVEH_PATTERN);
19879 G__get_linked_tagnum(&G__BankClassesDictLN_KEVH_PATTERN);
19880 G__get_linked_tagnum(&G__BankClassesDictLN_REVH_PATTERN);
19881 G__get_linked_tagnum(&G__BankClassesDictLN_LOLE_PATTERN);
19882 G__get_linked_tagnum(&G__BankClassesDictLN_X1RG_PATTERN);
19883 G__get_linked_tagnum(&G__BankClassesDictLN_BOMB_PATTERN);
19884 G__get_linked_tagnum(&G__BankClassesDictLN_RUNH_PATTERN);
19885 G__get_linked_tagnum(&G__BankClassesDictLN_ASIM_PATTERN);
19886 G__get_linked_tagnum(&G__BankClassesDictLN_ADBR_PATTERN);
19887 G__get_linked_tagnum(&G__BankClassesDictLN_XTBN_PATTERN);
19888 G__get_linked_tagnum(&G__BankClassesDictLN_XTCN_PATTERN);
19889 G__get_linked_tagnum(&G__BankClassesDictLN_XTOP_PATTERN);
19890 G__get_linked_tagnum(&G__BankClassesDictLN_LUPA_PATTERN);
19891 G__get_linked_tagnum(&G__BankClassesDictLN_SILH_PATTERN);
19892 G__get_linked_tagnum(&G__BankClassesDictLN_XHVB_PATTERN);
19893 G__get_linked_tagnum(&G__BankClassesDictLN_XTEB_PATTERN);
19894 G__get_linked_tagnum(&G__BankClassesDictLN_XTRB_PATTERN);
19895 G__get_linked_tagnum(&G__BankClassesDictLN_DTBP_PATTERN);
19896 G__get_linked_tagnum(&G__BankClassesDictLN_VHBV_PATTERN);
19897 G__get_linked_tagnum(&G__BankClassesDictLN_VHPV_PATTERN);
19898 G__get_linked_tagnum(&G__BankClassesDictLN_EAUX_PATTERN);
19899 G__get_linked_tagnum(&G__BankClassesDictLN_SIX2_PATTERN);
19900 G__get_linked_tagnum(&G__BankClassesDictLN_X1TV_PATTERN);
19901 G__get_linked_tagnum(&G__BankClassesDictLN_KWGT_PATTERN);
19902 G__get_linked_tagnum(&G__BankClassesDictLN_X1IP_PATTERN);
19903 G__get_linked_tagnum(&G__BankClassesDictLN_SIXA_PATTERN);
19904 G__get_linked_tagnum(&G__BankClassesDictLN_SITC_PATTERN);
19905 G__get_linked_tagnum(&G__BankClassesDictLN_SRCO_PATTERN);
19906 G__get_linked_tagnum(&G__BankClassesDictLN_X1TH_PATTERN);
19907 G__get_linked_tagnum(&G__BankClassesDictLN_X1AD_PATTERN);
19908 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QLIN),sizeof(QLIN),-1,292096,"class QLIN",G__setup_memvarQLIN,G__setup_memfuncQLIN);
19909 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTL),sizeof(QMTL),-1,292096,"class QMTL",G__setup_memvarQMTL,G__setup_memfuncQMTL);
19910 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QMTS),sizeof(QMTS),-1,292096,"class QMTS",G__setup_memvarQMTS,G__setup_memfuncQMTS);
19911 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRFT),sizeof(FRFT),-1,292096,"class FRFT",G__setup_memvarFRFT,G__setup_memfuncFRFT);
19912 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRTL),sizeof(FRTL),-1,292096,"class FRTL",G__setup_memvarFRTL,G__setup_memfuncFRTL);
19913 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_TEXS),sizeof(TEXS),-1,292096,"class TEXS",G__setup_memvarTEXS,G__setup_memfuncTEXS);
19914 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_HMAD),sizeof(HMAD),-1,292096,"class HMAD",G__setup_memvarHMAD,G__setup_memfuncHMAD);
19915 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MCAD),sizeof(MCAD),-1,292096,"class MCAD",G__setup_memvarMCAD,G__setup_memfuncMCAD);
19916 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PECO),sizeof(PECO),-1,292096,"class PECO",G__setup_memvarPECO,G__setup_memfuncPECO);
19917 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EIDT),sizeof(EIDT),-1,292096,"class EIDT",G__setup_memvarEIDT,G__setup_memfuncEIDT);
19918 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PHCO),sizeof(PHCO),-1,292096,"class PHCO",G__setup_memvarPHCO,G__setup_memfuncPHCO);
19919 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PEPT),sizeof(PEPT),-1,292096,"class PEPT",G__setup_memvarPEPT,G__setup_memfuncPEPT);
19920 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FRID),sizeof(FRID),-1,292096,"class FRID",G__setup_memvarFRID,G__setup_memfuncFRID);
19921 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EFOL),sizeof(EFOL),-1,292096,"class EFOL",G__setup_memvarEFOL,G__setup_memfuncEFOL);
19922 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PCQA),sizeof(PCQA),-1,292096,"class PCQA",G__setup_memvarPCQA,G__setup_memfuncPCQA);
19923 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EGPC),sizeof(EGPC),-1,292096,"class EGPC",G__setup_memvarEGPC,G__setup_memfuncEGPC);
19924 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_MUID),sizeof(MUID),-1,292096,"class MUID",G__setup_memvarMUID,G__setup_memfuncMUID);
19925 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGPC),sizeof(PGPC),-1,292096,"class PGPC",G__setup_memvarPGPC,G__setup_memfuncPGPC);
19926 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PGAC),sizeof(PGAC),-1,292096,"class PGAC",G__setup_memvarPGAC,G__setup_memfuncPGAC);
19927 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PDLT),sizeof(PDLT),-1,292096,"class PDLT",G__setup_memvarPDLT,G__setup_memfuncPDLT);
19928 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_PMLT),sizeof(PMLT),-1,292096,"class PMLT",G__setup_memvarPMLT,G__setup_memfuncPMLT);
19929 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QDET),sizeof(QDET),-1,292096,"class QDET",G__setup_memvarQDET,G__setup_memfuncQDET);
19930 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVEC),sizeof(QVEC),-1,292096,"class QVEC",G__setup_memvarQVEC,G__setup_memfuncQVEC);
19931 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR);
19932 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEunsignedsPshortcOintgR);
19933 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_YV0V),sizeof(YV0V),-1,292096,"class YV0V",G__setup_memvarYV0V,G__setup_memfuncYV0V);
19934 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FKIN),sizeof(FKIN),-1,292096,"class FKIN",G__setup_memvarFKIN,G__setup_memfuncFKIN);
19935 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_FVER),sizeof(FVER),-1,292096,"class FVER",G__setup_memvarFVER,G__setup_memfuncFVER);
19936 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEFKINmUcOallocatorlEFKINmUgRsPgR);
19937 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEFKINmUcOintgR);
19938 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QVRT),sizeof(QVRT),-1,292096,"class QVRT",G__setup_memvarQVRT,G__setup_memfuncQVRT);
19939 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALPB),sizeof(ALPB),-1,292096,"class ALPB",G__setup_memvarALPB,G__setup_memfuncALPB);
19940 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ALRP),sizeof(ALRP),-1,292096,"class ALRP",G__setup_memvarALRP,G__setup_memfuncALRP);
19941 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNL2),sizeof(RNL2),-1,292096,"class RNL2",G__setup_memvarRNL2,G__setup_memfuncRNL2);
19942 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNF2),sizeof(RNF2),-1,292096,"class RNF2",G__setup_memvarRNF2,G__setup_memfuncRNF2);
19943 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RNR2),sizeof(RNR2),-1,292096,"class RNR2",G__setup_memvarRNR2,G__setup_memfuncRNR2);
19944 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RLEP),sizeof(RLEP),-1,292096,"class RLEP",G__setup_memvarRLEP,G__setup_memfuncRLEP);
19945 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LFIL),sizeof(LFIL),-1,292096,"class LFIL",G__setup_memvarLFIL,G__setup_memfuncLFIL);
19946 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EVEH),sizeof(EVEH),-1,292096,"class EVEH",G__setup_memvarEVEH,G__setup_memfuncEVEH);
19947 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KEVH),sizeof(KEVH),-1,292096,"class KEVH",G__setup_memvarKEVH,G__setup_memfuncKEVH);
19948 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_REVH),sizeof(REVH),-1,292096,"class REVH",G__setup_memvarREVH,G__setup_memfuncREVH);
19949 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LOLE),sizeof(LOLE),-1,292096,"class LOLE",G__setup_memvarLOLE,G__setup_memfuncLOLE);
19950 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1RG),sizeof(X1RG),-1,292096,"class X1RG",G__setup_memvarX1RG,G__setup_memfuncX1RG);
19951 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_BOMB),sizeof(BOMB),-1,292096,"class BOMB",G__setup_memvarBOMB,G__setup_memfuncBOMB);
19952 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_RUNH),sizeof(RUNH),-1,292096,"class RUNH",G__setup_memvarRUNH,G__setup_memfuncRUNH);
19953 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ASIM),sizeof(ASIM),-1,292096,"class ASIM",G__setup_memvarASIM,G__setup_memfuncASIM);
19954 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_ADBR),sizeof(ADBR),-1,292096,"class ADBR",G__setup_memvarADBR,G__setup_memfuncADBR);
19955 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTBN),sizeof(XTBN),-1,292096,"class XTBN",G__setup_memvarXTBN,G__setup_memfuncXTBN);
19956 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTCN),sizeof(XTCN),-1,292096,"class XTCN",G__setup_memvarXTCN,G__setup_memfuncXTCN);
19957 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTOP),sizeof(XTOP),-1,292096,"class XTOP",G__setup_memvarXTOP,G__setup_memfuncXTOP);
19958 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_LUPA),sizeof(LUPA),-1,292096,"class LUPA",G__setup_memvarLUPA,G__setup_memfuncLUPA);
19959 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SILH),sizeof(SILH),-1,292096,"class SILH",G__setup_memvarSILH,G__setup_memfuncSILH);
19960 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XHVB),sizeof(XHVB),-1,292096,"class XHVB",G__setup_memvarXHVB,G__setup_memfuncXHVB);
19961 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTEB),sizeof(XTEB),-1,292096,"class XTEB",G__setup_memvarXTEB,G__setup_memfuncXTEB);
19962 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_XTRB),sizeof(XTRB),-1,292096,"class XTRB",G__setup_memvarXTRB,G__setup_memfuncXTRB);
19963 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_DTBP),sizeof(DTBP),-1,292096,"class DTBP",G__setup_memvarDTBP,G__setup_memfuncDTBP);
19964 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHBV),sizeof(VHBV),-1,292096,"class VHBV",G__setup_memvarVHBV,G__setup_memfuncVHBV);
19965 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_VHPV),sizeof(VHPV),-1,292096,"class VHPV",G__setup_memvarVHPV,G__setup_memfuncVHPV);
19966 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_EAUX),sizeof(EAUX),-1,292096,"class EAUX",G__setup_memvarEAUX,G__setup_memfuncEAUX);
19967 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIX2),sizeof(SIX2),-1,292096,"class SIX2",G__setup_memvarSIX2,G__setup_memfuncSIX2);
19968 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TV),sizeof(X1TV),-1,292096,"class X1TV",G__setup_memvarX1TV,G__setup_memfuncX1TV);
19969 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_KWGT),sizeof(KWGT),-1,292096,"class KWGT",G__setup_memvarKWGT,G__setup_memfuncKWGT);
19970 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1IP),sizeof(X1IP),-1,292096,"class X1IP",G__setup_memvarX1IP,G__setup_memfuncX1IP);
19971 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SIXA),sizeof(SIXA),-1,292096,"class SIXA",G__setup_memvarSIXA,G__setup_memfuncSIXA);
19972 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SITC),sizeof(SITC),-1,292096,"class SITC",G__setup_memvarSITC,G__setup_memfuncSITC);
19973 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_SRCO),sizeof(SRCO),-1,292096,"class SRCO",G__setup_memvarSRCO,G__setup_memfuncSRCO);
19974 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1TH),sizeof(X1TH),-1,292096,"class X1TH",G__setup_memvarX1TH,G__setup_memfuncX1TH);
19975 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_X1AD),sizeof(X1AD),-1,292096,"class X1AD",G__setup_memvarX1AD,G__setup_memfuncX1AD);
19976 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QEXT),sizeof(QEXT),-1,292096,"class QEXT",G__setup_memvarQEXT,G__setup_memfuncQEXT);
19977 G__tagtable_setup(G__get_linked_tagnum(&G__BankClassesDictLN_QHAC),sizeof(QHAC),-1,292096,"class QHAC",G__setup_memvarQHAC,G__setup_memfuncQHAC);
19978 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlELOLEmUcOallocatorlELOLEmUgRsPgR);
19979 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlELOLEmUcOintgR);
19980 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1RGmUcOallocatorlEX1RGmUgRsPgR);
19981 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1RGmUcOintgR);
19982 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXTBNmUcOallocatorlEXTBNmUgRsPgR);
19983 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEXTBNmUcOintgR);
19984 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEXHVBmUcOallocatorlEXHVBmUgRsPgR);
19985 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEXHVBmUcOintgR);
19986 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHPVmUcOallocatorlEVHPVmUgRsPgR);
19987 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEVHPVmUcOintgR);
19988 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEVHBVmUcOallocatorlEVHBVmUgRsPgR);
19989 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEVHBVmUcOintgR);
19990 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1TVmUcOallocatorlEX1TVmUgRsPgR);
19991 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1TVmUcOintgR);
19992 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEKWGTmUcOallocatorlEKWGTmUgRsPgR);
19993 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEKWGTmUcOintgR);
19994 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1IPmUcOallocatorlEX1IPmUgRsPgR);
19995 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1IPmUcOintgR);
19996 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESIXAmUcOallocatorlESIXAmUgRsPgR);
19997 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlESIXAmUcOintgR);
19998 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlESRCOmUcOallocatorlESRCOmUgRsPgR);
19999 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlESRCOmUcOintgR);
20000 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1THmUcOallocatorlEX1THmUgRsPgR);
20001 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1THmUcOintgR);
20002 G__get_linked_tagnum(&G__BankClassesDictLN_vectorlEX1ADmUcOallocatorlEX1ADmUgRsPgR);
20003 G__get_linked_tagnum(&G__BankClassesDictLN_random_access_iteratorlEX1ADmUcOintgR);
20004 }
20005 extern "C" void G__cpp_setupBankClassesDict(void) {
20006 G__check_setup_version(30051515,"G__cpp_setupBankClassesDict()");
20007 G__set_cpp_environmentBankClassesDict();
20008 G__cpp_setup_tagtableBankClassesDict();
20009
20010 G__cpp_setup_inheritanceBankClassesDict();
20011
20012 G__cpp_setup_typetableBankClassesDict();
20013
20014 G__cpp_setup_memvarBankClassesDict();
20015
20016 G__cpp_setup_memfuncBankClassesDict();
20017 G__cpp_setup_globalBankClassesDict();
20018 G__cpp_setup_funcBankClassesDict();
20019
20020 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncBankClassesDict();
20021 return;
20022 }
20023 class G__cpp_setup_initBankClassesDict {
20024 public:
20025 G__cpp_setup_initBankClassesDict() { G__add_setup_func("BankClassesDict",(G__incsetup)(&G__cpp_setupBankClassesDict)); G__call_setup_funcs(); }
20026 ~G__cpp_setup_initBankClassesDict() { G__remove_setup_func("BankClassesDict"); }
20027 };
20028 G__cpp_setup_initBankClassesDict G__cpp_setup_initializerBankClassesDict;
20029
