00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME graf3ddIg3ddIsrcdIG__G3D
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
00016 namespace std {} using namespace std;
00017 #include "G__G3D.h"
00018
00019 #include "TClass.h"
00020 #include "TBuffer.h"
00021 #include "TMemberInspector.h"
00022 #include "TError.h"
00023
00024 #ifndef G__ROOT
00025 #define G__ROOT
00026 #endif
00027
00028 #include "RtypesImp.h"
00029 #include "TIsAProxy.h"
00030
00031
00032
00033 namespace ROOT {
00034 namespace Shadow {
00035 }
00036 }
00037
00038
00039 namespace ROOT {
00040 void TAxis3D_ShowMembers(void *obj, TMemberInspector &R__insp);
00041 static void *new_TAxis3D(void *p = 0);
00042 static void *newArray_TAxis3D(Long_t size, void *p);
00043 static void delete_TAxis3D(void *p);
00044 static void deleteArray_TAxis3D(void *p);
00045 static void destruct_TAxis3D(void *p);
00046
00047
00048 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAxis3D*)
00049 {
00050 ::TAxis3D *ptr = 0;
00051 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAxis3D >(0);
00052 static ::ROOT::TGenericClassInfo
00053 instance("TAxis3D", ::TAxis3D::Class_Version(), "include/TAxis3D.h", 33,
00054 typeid(::TAxis3D), DefineBehavior(ptr, ptr),
00055 &::TAxis3D::Dictionary, isa_proxy, 4,
00056 sizeof(::TAxis3D) );
00057 instance.SetNew(&new_TAxis3D);
00058 instance.SetNewArray(&newArray_TAxis3D);
00059 instance.SetDelete(&delete_TAxis3D);
00060 instance.SetDeleteArray(&deleteArray_TAxis3D);
00061 instance.SetDestructor(&destruct_TAxis3D);
00062 return &instance;
00063 }
00064 TGenericClassInfo *GenerateInitInstance(const ::TAxis3D*)
00065 {
00066 return GenerateInitInstanceLocal((::TAxis3D*)0);
00067 }
00068
00069 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAxis3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00070 }
00071
00072 namespace ROOT {
00073 void TMaterial_ShowMembers(void *obj, TMemberInspector &R__insp);
00074 static void *new_TMaterial(void *p = 0);
00075 static void *newArray_TMaterial(Long_t size, void *p);
00076 static void delete_TMaterial(void *p);
00077 static void deleteArray_TMaterial(void *p);
00078 static void destruct_TMaterial(void *p);
00079 static void streamer_TMaterial(TBuffer &buf, void *obj);
00080
00081
00082 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMaterial*)
00083 {
00084 ::TMaterial *ptr = 0;
00085 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMaterial >(0);
00086 static ::ROOT::TGenericClassInfo
00087 instance("TMaterial", ::TMaterial::Class_Version(), "include/TMaterial.h", 32,
00088 typeid(::TMaterial), DefineBehavior(ptr, ptr),
00089 &::TMaterial::Dictionary, isa_proxy, 1,
00090 sizeof(::TMaterial) );
00091 instance.SetNew(&new_TMaterial);
00092 instance.SetNewArray(&newArray_TMaterial);
00093 instance.SetDelete(&delete_TMaterial);
00094 instance.SetDeleteArray(&deleteArray_TMaterial);
00095 instance.SetDestructor(&destruct_TMaterial);
00096 instance.SetStreamerFunc(&streamer_TMaterial);
00097 return &instance;
00098 }
00099 TGenericClassInfo *GenerateInitInstance(const ::TMaterial*)
00100 {
00101 return GenerateInitInstanceLocal((::TMaterial*)0);
00102 }
00103
00104 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMaterial*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00105 }
00106
00107 namespace ROOT {
00108 void TNode_ShowMembers(void *obj, TMemberInspector &R__insp);
00109 static void *new_TNode(void *p = 0);
00110 static void *newArray_TNode(Long_t size, void *p);
00111 static void delete_TNode(void *p);
00112 static void deleteArray_TNode(void *p);
00113 static void destruct_TNode(void *p);
00114 static void streamer_TNode(TBuffer &buf, void *obj);
00115
00116
00117 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNode*)
00118 {
00119 ::TNode *ptr = 0;
00120 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNode >(0);
00121 static ::ROOT::TGenericClassInfo
00122 instance("TNode", ::TNode::Class_Version(), "include/TNode.h", 43,
00123 typeid(::TNode), DefineBehavior(ptr, ptr),
00124 &::TNode::Dictionary, isa_proxy, 1,
00125 sizeof(::TNode) );
00126 instance.SetNew(&new_TNode);
00127 instance.SetNewArray(&newArray_TNode);
00128 instance.SetDelete(&delete_TNode);
00129 instance.SetDeleteArray(&deleteArray_TNode);
00130 instance.SetDestructor(&destruct_TNode);
00131 instance.SetStreamerFunc(&streamer_TNode);
00132 return &instance;
00133 }
00134 TGenericClassInfo *GenerateInitInstance(const ::TNode*)
00135 {
00136 return GenerateInitInstanceLocal((::TNode*)0);
00137 }
00138
00139 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNode*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00140 }
00141
00142 namespace ROOT {
00143 void TShape_ShowMembers(void *obj, TMemberInspector &R__insp);
00144 static void *new_TShape(void *p = 0);
00145 static void *newArray_TShape(Long_t size, void *p);
00146 static void delete_TShape(void *p);
00147 static void deleteArray_TShape(void *p);
00148 static void destruct_TShape(void *p);
00149 static void streamer_TShape(TBuffer &buf, void *obj);
00150
00151
00152 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TShape*)
00153 {
00154 ::TShape *ptr = 0;
00155 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TShape >(0);
00156 static ::ROOT::TGenericClassInfo
00157 instance("TShape", ::TShape::Class_Version(), "include/TShape.h", 47,
00158 typeid(::TShape), DefineBehavior(ptr, ptr),
00159 &::TShape::Dictionary, isa_proxy, 1,
00160 sizeof(::TShape) );
00161 instance.SetNew(&new_TShape);
00162 instance.SetNewArray(&newArray_TShape);
00163 instance.SetDelete(&delete_TShape);
00164 instance.SetDeleteArray(&deleteArray_TShape);
00165 instance.SetDestructor(&destruct_TShape);
00166 instance.SetStreamerFunc(&streamer_TShape);
00167 return &instance;
00168 }
00169 TGenericClassInfo *GenerateInitInstance(const ::TShape*)
00170 {
00171 return GenerateInitInstanceLocal((::TShape*)0);
00172 }
00173
00174 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TShape*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00175 }
00176
00177 namespace ROOT {
00178 void TBRIK_ShowMembers(void *obj, TMemberInspector &R__insp);
00179 static void *new_TBRIK(void *p = 0);
00180 static void *newArray_TBRIK(Long_t size, void *p);
00181 static void delete_TBRIK(void *p);
00182 static void deleteArray_TBRIK(void *p);
00183 static void destruct_TBRIK(void *p);
00184
00185
00186 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBRIK*)
00187 {
00188 ::TBRIK *ptr = 0;
00189 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBRIK >(0);
00190 static ::ROOT::TGenericClassInfo
00191 instance("TBRIK", ::TBRIK::Class_Version(), "include/TBRIK.h", 28,
00192 typeid(::TBRIK), DefineBehavior(ptr, ptr),
00193 &::TBRIK::Dictionary, isa_proxy, 4,
00194 sizeof(::TBRIK) );
00195 instance.SetNew(&new_TBRIK);
00196 instance.SetNewArray(&newArray_TBRIK);
00197 instance.SetDelete(&delete_TBRIK);
00198 instance.SetDeleteArray(&deleteArray_TBRIK);
00199 instance.SetDestructor(&destruct_TBRIK);
00200 return &instance;
00201 }
00202 TGenericClassInfo *GenerateInitInstance(const ::TBRIK*)
00203 {
00204 return GenerateInitInstanceLocal((::TBRIK*)0);
00205 }
00206
00207 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBRIK*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00208 }
00209
00210 namespace ROOT {
00211 void TTUBE_ShowMembers(void *obj, TMemberInspector &R__insp);
00212 static void *new_TTUBE(void *p = 0);
00213 static void *newArray_TTUBE(Long_t size, void *p);
00214 static void delete_TTUBE(void *p);
00215 static void deleteArray_TTUBE(void *p);
00216 static void destruct_TTUBE(void *p);
00217 static void streamer_TTUBE(TBuffer &buf, void *obj);
00218
00219
00220 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTUBE*)
00221 {
00222 ::TTUBE *ptr = 0;
00223 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTUBE >(0);
00224 static ::ROOT::TGenericClassInfo
00225 instance("TTUBE", ::TTUBE::Class_Version(), "include/TTUBE.h", 34,
00226 typeid(::TTUBE), DefineBehavior(ptr, ptr),
00227 &::TTUBE::Dictionary, isa_proxy, 1,
00228 sizeof(::TTUBE) );
00229 instance.SetNew(&new_TTUBE);
00230 instance.SetNewArray(&newArray_TTUBE);
00231 instance.SetDelete(&delete_TTUBE);
00232 instance.SetDeleteArray(&deleteArray_TTUBE);
00233 instance.SetDestructor(&destruct_TTUBE);
00234 instance.SetStreamerFunc(&streamer_TTUBE);
00235 return &instance;
00236 }
00237 TGenericClassInfo *GenerateInitInstance(const ::TTUBE*)
00238 {
00239 return GenerateInitInstanceLocal((::TTUBE*)0);
00240 }
00241
00242 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTUBE*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00243 }
00244
00245 namespace ROOT {
00246 void TCONE_ShowMembers(void *obj, TMemberInspector &R__insp);
00247 static void *new_TCONE(void *p = 0);
00248 static void *newArray_TCONE(Long_t size, void *p);
00249 static void delete_TCONE(void *p);
00250 static void deleteArray_TCONE(void *p);
00251 static void destruct_TCONE(void *p);
00252
00253
00254 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCONE*)
00255 {
00256 ::TCONE *ptr = 0;
00257 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCONE >(0);
00258 static ::ROOT::TGenericClassInfo
00259 instance("TCONE", ::TCONE::Class_Version(), "include/TCONE.h", 30,
00260 typeid(::TCONE), DefineBehavior(ptr, ptr),
00261 &::TCONE::Dictionary, isa_proxy, 4,
00262 sizeof(::TCONE) );
00263 instance.SetNew(&new_TCONE);
00264 instance.SetNewArray(&newArray_TCONE);
00265 instance.SetDelete(&delete_TCONE);
00266 instance.SetDeleteArray(&deleteArray_TCONE);
00267 instance.SetDestructor(&destruct_TCONE);
00268 return &instance;
00269 }
00270 TGenericClassInfo *GenerateInitInstance(const ::TCONE*)
00271 {
00272 return GenerateInitInstanceLocal((::TCONE*)0);
00273 }
00274
00275 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCONE*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00276 }
00277
00278 namespace ROOT {
00279 void TTUBS_ShowMembers(void *obj, TMemberInspector &R__insp);
00280 static void *new_TTUBS(void *p = 0);
00281 static void *newArray_TTUBS(Long_t size, void *p);
00282 static void delete_TTUBS(void *p);
00283 static void deleteArray_TTUBS(void *p);
00284 static void destruct_TTUBS(void *p);
00285
00286
00287 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTUBS*)
00288 {
00289 ::TTUBS *ptr = 0;
00290 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTUBS >(0);
00291 static ::ROOT::TGenericClassInfo
00292 instance("TTUBS", ::TTUBS::Class_Version(), "include/TTUBS.h", 31,
00293 typeid(::TTUBS), DefineBehavior(ptr, ptr),
00294 &::TTUBS::Dictionary, isa_proxy, 4,
00295 sizeof(::TTUBS) );
00296 instance.SetNew(&new_TTUBS);
00297 instance.SetNewArray(&newArray_TTUBS);
00298 instance.SetDelete(&delete_TTUBS);
00299 instance.SetDeleteArray(&deleteArray_TTUBS);
00300 instance.SetDestructor(&destruct_TTUBS);
00301 return &instance;
00302 }
00303 TGenericClassInfo *GenerateInitInstance(const ::TTUBS*)
00304 {
00305 return GenerateInitInstanceLocal((::TTUBS*)0);
00306 }
00307
00308 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTUBS*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00309 }
00310
00311 namespace ROOT {
00312 void TCONS_ShowMembers(void *obj, TMemberInspector &R__insp);
00313 static void *new_TCONS(void *p = 0);
00314 static void *newArray_TCONS(Long_t size, void *p);
00315 static void delete_TCONS(void *p);
00316 static void deleteArray_TCONS(void *p);
00317 static void destruct_TCONS(void *p);
00318
00319
00320 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCONS*)
00321 {
00322 ::TCONS *ptr = 0;
00323 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCONS >(0);
00324 static ::ROOT::TGenericClassInfo
00325 instance("TCONS", ::TCONS::Class_Version(), "include/TCONS.h", 29,
00326 typeid(::TCONS), DefineBehavior(ptr, ptr),
00327 &::TCONS::Dictionary, isa_proxy, 4,
00328 sizeof(::TCONS) );
00329 instance.SetNew(&new_TCONS);
00330 instance.SetNewArray(&newArray_TCONS);
00331 instance.SetDelete(&delete_TCONS);
00332 instance.SetDeleteArray(&deleteArray_TCONS);
00333 instance.SetDestructor(&destruct_TCONS);
00334 return &instance;
00335 }
00336 TGenericClassInfo *GenerateInitInstance(const ::TCONS*)
00337 {
00338 return GenerateInitInstanceLocal((::TCONS*)0);
00339 }
00340
00341 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCONS*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00342 }
00343
00344 namespace ROOT {
00345 void TCTUB_ShowMembers(void *obj, TMemberInspector &R__insp);
00346 static void *new_TCTUB(void *p = 0);
00347 static void *newArray_TCTUB(Long_t size, void *p);
00348 static void delete_TCTUB(void *p);
00349 static void deleteArray_TCTUB(void *p);
00350 static void destruct_TCTUB(void *p);
00351 static void streamer_TCTUB(TBuffer &buf, void *obj);
00352
00353
00354 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCTUB*)
00355 {
00356 ::TCTUB *ptr = 0;
00357 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCTUB >(0);
00358 static ::ROOT::TGenericClassInfo
00359 instance("TCTUB", ::TCTUB::Class_Version(), "include/TCTUB.h", 31,
00360 typeid(::TCTUB), DefineBehavior(ptr, ptr),
00361 &::TCTUB::Dictionary, isa_proxy, 1,
00362 sizeof(::TCTUB) );
00363 instance.SetNew(&new_TCTUB);
00364 instance.SetNewArray(&newArray_TCTUB);
00365 instance.SetDelete(&delete_TCTUB);
00366 instance.SetDeleteArray(&deleteArray_TCTUB);
00367 instance.SetDestructor(&destruct_TCTUB);
00368 instance.SetStreamerFunc(&streamer_TCTUB);
00369 return &instance;
00370 }
00371 TGenericClassInfo *GenerateInitInstance(const ::TCTUB*)
00372 {
00373 return GenerateInitInstanceLocal((::TCTUB*)0);
00374 }
00375
00376 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCTUB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00377 }
00378
00379 namespace ROOT {
00380 void TELTU_ShowMembers(void *obj, TMemberInspector &R__insp);
00381 static void *new_TELTU(void *p = 0);
00382 static void *newArray_TELTU(Long_t size, void *p);
00383 static void delete_TELTU(void *p);
00384 static void deleteArray_TELTU(void *p);
00385 static void destruct_TELTU(void *p);
00386
00387
00388 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TELTU*)
00389 {
00390 ::TELTU *ptr = 0;
00391 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TELTU >(0);
00392 static ::ROOT::TGenericClassInfo
00393 instance("TELTU", ::TELTU::Class_Version(), "include/TELTU.h", 33,
00394 typeid(::TELTU), DefineBehavior(ptr, ptr),
00395 &::TELTU::Dictionary, isa_proxy, 4,
00396 sizeof(::TELTU) );
00397 instance.SetNew(&new_TELTU);
00398 instance.SetNewArray(&newArray_TELTU);
00399 instance.SetDelete(&delete_TELTU);
00400 instance.SetDeleteArray(&deleteArray_TELTU);
00401 instance.SetDestructor(&destruct_TELTU);
00402 return &instance;
00403 }
00404 TGenericClassInfo *GenerateInitInstance(const ::TELTU*)
00405 {
00406 return GenerateInitInstanceLocal((::TELTU*)0);
00407 }
00408
00409 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TELTU*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00410 }
00411
00412 namespace ROOT {
00413 void TRotMatrix_ShowMembers(void *obj, TMemberInspector &R__insp);
00414 static void *new_TRotMatrix(void *p = 0);
00415 static void *newArray_TRotMatrix(Long_t size, void *p);
00416 static void delete_TRotMatrix(void *p);
00417 static void deleteArray_TRotMatrix(void *p);
00418 static void destruct_TRotMatrix(void *p);
00419 static void streamer_TRotMatrix(TBuffer &buf, void *obj);
00420
00421
00422 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRotMatrix*)
00423 {
00424 ::TRotMatrix *ptr = 0;
00425 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRotMatrix >(0);
00426 static ::ROOT::TGenericClassInfo
00427 instance("TRotMatrix", ::TRotMatrix::Class_Version(), "include/TRotMatrix.h", 30,
00428 typeid(::TRotMatrix), DefineBehavior(ptr, ptr),
00429 &::TRotMatrix::Dictionary, isa_proxy, 1,
00430 sizeof(::TRotMatrix) );
00431 instance.SetNew(&new_TRotMatrix);
00432 instance.SetNewArray(&newArray_TRotMatrix);
00433 instance.SetDelete(&delete_TRotMatrix);
00434 instance.SetDeleteArray(&deleteArray_TRotMatrix);
00435 instance.SetDestructor(&destruct_TRotMatrix);
00436 instance.SetStreamerFunc(&streamer_TRotMatrix);
00437 return &instance;
00438 }
00439 TGenericClassInfo *GenerateInitInstance(const ::TRotMatrix*)
00440 {
00441 return GenerateInitInstanceLocal((::TRotMatrix*)0);
00442 }
00443
00444 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRotMatrix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00445 }
00446
00447 namespace ROOT {
00448 void TGeometry_ShowMembers(void *obj, TMemberInspector &R__insp);
00449 static void *new_TGeometry(void *p = 0);
00450 static void *newArray_TGeometry(Long_t size, void *p);
00451 static void delete_TGeometry(void *p);
00452 static void deleteArray_TGeometry(void *p);
00453 static void destruct_TGeometry(void *p);
00454 static void streamer_TGeometry(TBuffer &buf, void *obj);
00455
00456
00457 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeometry*)
00458 {
00459 ::TGeometry *ptr = 0;
00460 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeometry >(0);
00461 static ::ROOT::TGenericClassInfo
00462 instance("TGeometry", ::TGeometry::Class_Version(), "include/TGeometry.h", 43,
00463 typeid(::TGeometry), DefineBehavior(ptr, ptr),
00464 &::TGeometry::Dictionary, isa_proxy, 1,
00465 sizeof(::TGeometry) );
00466 instance.SetNew(&new_TGeometry);
00467 instance.SetNewArray(&newArray_TGeometry);
00468 instance.SetDelete(&delete_TGeometry);
00469 instance.SetDeleteArray(&deleteArray_TGeometry);
00470 instance.SetDestructor(&destruct_TGeometry);
00471 instance.SetStreamerFunc(&streamer_TGeometry);
00472 return &instance;
00473 }
00474 TGenericClassInfo *GenerateInitInstance(const ::TGeometry*)
00475 {
00476 return GenerateInitInstanceLocal((::TGeometry*)0);
00477 }
00478
00479 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeometry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00480 }
00481
00482 namespace ROOT {
00483 void TGTRA_ShowMembers(void *obj, TMemberInspector &R__insp);
00484 static void *new_TGTRA(void *p = 0);
00485 static void *newArray_TGTRA(Long_t size, void *p);
00486 static void delete_TGTRA(void *p);
00487 static void deleteArray_TGTRA(void *p);
00488 static void destruct_TGTRA(void *p);
00489
00490
00491 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGTRA*)
00492 {
00493 ::TGTRA *ptr = 0;
00494 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGTRA >(0);
00495 static ::ROOT::TGenericClassInfo
00496 instance("TGTRA", ::TGTRA::Class_Version(), "include/TGTRA.h", 29,
00497 typeid(::TGTRA), DefineBehavior(ptr, ptr),
00498 &::TGTRA::Dictionary, isa_proxy, 4,
00499 sizeof(::TGTRA) );
00500 instance.SetNew(&new_TGTRA);
00501 instance.SetNewArray(&newArray_TGTRA);
00502 instance.SetDelete(&delete_TGTRA);
00503 instance.SetDeleteArray(&deleteArray_TGTRA);
00504 instance.SetDestructor(&destruct_TGTRA);
00505 return &instance;
00506 }
00507 TGenericClassInfo *GenerateInitInstance(const ::TGTRA*)
00508 {
00509 return GenerateInitInstanceLocal((::TGTRA*)0);
00510 }
00511
00512 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGTRA*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00513 }
00514
00515 namespace ROOT {
00516 void TPolyLine3D_ShowMembers(void *obj, TMemberInspector &R__insp);
00517 static void *new_TPolyLine3D(void *p = 0);
00518 static void *newArray_TPolyLine3D(Long_t size, void *p);
00519 static void delete_TPolyLine3D(void *p);
00520 static void deleteArray_TPolyLine3D(void *p);
00521 static void destruct_TPolyLine3D(void *p);
00522 static void streamer_TPolyLine3D(TBuffer &buf, void *obj);
00523
00524
00525 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPolyLine3D*)
00526 {
00527 ::TPolyLine3D *ptr = 0;
00528 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPolyLine3D >(0);
00529 static ::ROOT::TGenericClassInfo
00530 instance("TPolyLine3D", ::TPolyLine3D::Class_Version(), "include/TPolyLine3D.h", 42,
00531 typeid(::TPolyLine3D), DefineBehavior(ptr, ptr),
00532 &::TPolyLine3D::Dictionary, isa_proxy, 1,
00533 sizeof(::TPolyLine3D) );
00534 instance.SetNew(&new_TPolyLine3D);
00535 instance.SetNewArray(&newArray_TPolyLine3D);
00536 instance.SetDelete(&delete_TPolyLine3D);
00537 instance.SetDeleteArray(&deleteArray_TPolyLine3D);
00538 instance.SetDestructor(&destruct_TPolyLine3D);
00539 instance.SetStreamerFunc(&streamer_TPolyLine3D);
00540 return &instance;
00541 }
00542 TGenericClassInfo *GenerateInitInstance(const ::TPolyLine3D*)
00543 {
00544 return GenerateInitInstanceLocal((::TPolyLine3D*)0);
00545 }
00546
00547 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPolyLine3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00548 }
00549
00550 namespace ROOT {
00551 void THelix_ShowMembers(void *obj, TMemberInspector &R__insp);
00552 static void *new_THelix(void *p = 0);
00553 static void *newArray_THelix(Long_t size, void *p);
00554 static void delete_THelix(void *p);
00555 static void deleteArray_THelix(void *p);
00556 static void destruct_THelix(void *p);
00557 static void streamer_THelix(TBuffer &buf, void *obj);
00558
00559
00560 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THelix*)
00561 {
00562 ::THelix *ptr = 0;
00563 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THelix >(0);
00564 static ::ROOT::TGenericClassInfo
00565 instance("THelix", ::THelix::Class_Version(), "include/THelix.h", 40,
00566 typeid(::THelix), DefineBehavior(ptr, ptr),
00567 &::THelix::Dictionary, isa_proxy, 1,
00568 sizeof(::THelix) );
00569 instance.SetNew(&new_THelix);
00570 instance.SetNewArray(&newArray_THelix);
00571 instance.SetDelete(&delete_THelix);
00572 instance.SetDeleteArray(&deleteArray_THelix);
00573 instance.SetDestructor(&destruct_THelix);
00574 instance.SetStreamerFunc(&streamer_THelix);
00575 return &instance;
00576 }
00577 TGenericClassInfo *GenerateInitInstance(const ::THelix*)
00578 {
00579 return GenerateInitInstanceLocal((::THelix*)0);
00580 }
00581
00582 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THelix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00583 }
00584
00585 namespace ROOT {
00586 void THYPE_ShowMembers(void *obj, TMemberInspector &R__insp);
00587 static void *new_THYPE(void *p = 0);
00588 static void *newArray_THYPE(Long_t size, void *p);
00589 static void delete_THYPE(void *p);
00590 static void deleteArray_THYPE(void *p);
00591 static void destruct_THYPE(void *p);
00592
00593
00594 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THYPE*)
00595 {
00596 ::THYPE *ptr = 0;
00597 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THYPE >(0);
00598 static ::ROOT::TGenericClassInfo
00599 instance("THYPE", ::THYPE::Class_Version(), "include/THYPE.h", 30,
00600 typeid(::THYPE), DefineBehavior(ptr, ptr),
00601 &::THYPE::Dictionary, isa_proxy, 4,
00602 sizeof(::THYPE) );
00603 instance.SetNew(&new_THYPE);
00604 instance.SetNewArray(&newArray_THYPE);
00605 instance.SetDelete(&delete_THYPE);
00606 instance.SetDeleteArray(&deleteArray_THYPE);
00607 instance.SetDestructor(&destruct_THYPE);
00608 return &instance;
00609 }
00610 TGenericClassInfo *GenerateInitInstance(const ::THYPE*)
00611 {
00612 return GenerateInitInstanceLocal((::THYPE*)0);
00613 }
00614
00615 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THYPE*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00616 }
00617
00618 namespace ROOT {
00619 void TMarker3DBox_ShowMembers(void *obj, TMemberInspector &R__insp);
00620 static void *new_TMarker3DBox(void *p = 0);
00621 static void *newArray_TMarker3DBox(Long_t size, void *p);
00622 static void delete_TMarker3DBox(void *p);
00623 static void deleteArray_TMarker3DBox(void *p);
00624 static void destruct_TMarker3DBox(void *p);
00625 static void streamer_TMarker3DBox(TBuffer &buf, void *obj);
00626
00627
00628 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMarker3DBox*)
00629 {
00630 ::TMarker3DBox *ptr = 0;
00631 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMarker3DBox >(0);
00632 static ::ROOT::TGenericClassInfo
00633 instance("TMarker3DBox", ::TMarker3DBox::Class_Version(), "include/TMarker3DBox.h", 46,
00634 typeid(::TMarker3DBox), DefineBehavior(ptr, ptr),
00635 &::TMarker3DBox::Dictionary, isa_proxy, 1,
00636 sizeof(::TMarker3DBox) );
00637 instance.SetNew(&new_TMarker3DBox);
00638 instance.SetNewArray(&newArray_TMarker3DBox);
00639 instance.SetDelete(&delete_TMarker3DBox);
00640 instance.SetDeleteArray(&deleteArray_TMarker3DBox);
00641 instance.SetDestructor(&destruct_TMarker3DBox);
00642 instance.SetStreamerFunc(&streamer_TMarker3DBox);
00643 return &instance;
00644 }
00645 TGenericClassInfo *GenerateInitInstance(const ::TMarker3DBox*)
00646 {
00647 return GenerateInitInstanceLocal((::TMarker3DBox*)0);
00648 }
00649
00650 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMarker3DBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00651 }
00652
00653 namespace ROOT {
00654 void TMixture_ShowMembers(void *obj, TMemberInspector &R__insp);
00655 static void *new_TMixture(void *p = 0);
00656 static void *newArray_TMixture(Long_t size, void *p);
00657 static void delete_TMixture(void *p);
00658 static void deleteArray_TMixture(void *p);
00659 static void destruct_TMixture(void *p);
00660 static void streamer_TMixture(TBuffer &buf, void *obj);
00661
00662
00663 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMixture*)
00664 {
00665 ::TMixture *ptr = 0;
00666 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMixture >(0);
00667 static ::ROOT::TGenericClassInfo
00668 instance("TMixture", ::TMixture::Class_Version(), "include/TMixture.h", 29,
00669 typeid(::TMixture), DefineBehavior(ptr, ptr),
00670 &::TMixture::Dictionary, isa_proxy, 1,
00671 sizeof(::TMixture) );
00672 instance.SetNew(&new_TMixture);
00673 instance.SetNewArray(&newArray_TMixture);
00674 instance.SetDelete(&delete_TMixture);
00675 instance.SetDeleteArray(&deleteArray_TMixture);
00676 instance.SetDestructor(&destruct_TMixture);
00677 instance.SetStreamerFunc(&streamer_TMixture);
00678 return &instance;
00679 }
00680 TGenericClassInfo *GenerateInitInstance(const ::TMixture*)
00681 {
00682 return GenerateInitInstanceLocal((::TMixture*)0);
00683 }
00684
00685 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMixture*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00686 }
00687
00688 namespace ROOT {
00689 void TNodeDiv_ShowMembers(void *obj, TMemberInspector &R__insp);
00690 static void *new_TNodeDiv(void *p = 0);
00691 static void *newArray_TNodeDiv(Long_t size, void *p);
00692 static void delete_TNodeDiv(void *p);
00693 static void deleteArray_TNodeDiv(void *p);
00694 static void destruct_TNodeDiv(void *p);
00695
00696
00697 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNodeDiv*)
00698 {
00699 ::TNodeDiv *ptr = 0;
00700 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNodeDiv >(0);
00701 static ::ROOT::TGenericClassInfo
00702 instance("TNodeDiv", ::TNodeDiv::Class_Version(), "include/TNodeDiv.h", 30,
00703 typeid(::TNodeDiv), DefineBehavior(ptr, ptr),
00704 &::TNodeDiv::Dictionary, isa_proxy, 4,
00705 sizeof(::TNodeDiv) );
00706 instance.SetNew(&new_TNodeDiv);
00707 instance.SetNewArray(&newArray_TNodeDiv);
00708 instance.SetDelete(&delete_TNodeDiv);
00709 instance.SetDeleteArray(&deleteArray_TNodeDiv);
00710 instance.SetDestructor(&destruct_TNodeDiv);
00711 return &instance;
00712 }
00713 TGenericClassInfo *GenerateInitInstance(const ::TNodeDiv*)
00714 {
00715 return GenerateInitInstanceLocal((::TNodeDiv*)0);
00716 }
00717
00718 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNodeDiv*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00719 }
00720
00721 namespace ROOT {
00722 void TPARA_ShowMembers(void *obj, TMemberInspector &R__insp);
00723 static void *new_TPARA(void *p = 0);
00724 static void *newArray_TPARA(Long_t size, void *p);
00725 static void delete_TPARA(void *p);
00726 static void deleteArray_TPARA(void *p);
00727 static void destruct_TPARA(void *p);
00728
00729
00730 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPARA*)
00731 {
00732 ::TPARA *ptr = 0;
00733 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPARA >(0);
00734 static ::ROOT::TGenericClassInfo
00735 instance("TPARA", ::TPARA::Class_Version(), "include/TPARA.h", 32,
00736 typeid(::TPARA), DefineBehavior(ptr, ptr),
00737 &::TPARA::Dictionary, isa_proxy, 4,
00738 sizeof(::TPARA) );
00739 instance.SetNew(&new_TPARA);
00740 instance.SetNewArray(&newArray_TPARA);
00741 instance.SetDelete(&delete_TPARA);
00742 instance.SetDeleteArray(&deleteArray_TPARA);
00743 instance.SetDestructor(&destruct_TPARA);
00744 return &instance;
00745 }
00746 TGenericClassInfo *GenerateInitInstance(const ::TPARA*)
00747 {
00748 return GenerateInitInstanceLocal((::TPARA*)0);
00749 }
00750
00751 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPARA*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00752 }
00753
00754 namespace ROOT {
00755 void TPCON_ShowMembers(void *obj, TMemberInspector &R__insp);
00756 static void *new_TPCON(void *p = 0);
00757 static void *newArray_TPCON(Long_t size, void *p);
00758 static void delete_TPCON(void *p);
00759 static void deleteArray_TPCON(void *p);
00760 static void destruct_TPCON(void *p);
00761 static void streamer_TPCON(TBuffer &buf, void *obj);
00762
00763
00764 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPCON*)
00765 {
00766 ::TPCON *ptr = 0;
00767 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPCON >(0);
00768 static ::ROOT::TGenericClassInfo
00769 instance("TPCON", ::TPCON::Class_Version(), "include/TPCON.h", 35,
00770 typeid(::TPCON), DefineBehavior(ptr, ptr),
00771 &::TPCON::Dictionary, isa_proxy, 1,
00772 sizeof(::TPCON) );
00773 instance.SetNew(&new_TPCON);
00774 instance.SetNewArray(&newArray_TPCON);
00775 instance.SetDelete(&delete_TPCON);
00776 instance.SetDeleteArray(&deleteArray_TPCON);
00777 instance.SetDestructor(&destruct_TPCON);
00778 instance.SetStreamerFunc(&streamer_TPCON);
00779 return &instance;
00780 }
00781 TGenericClassInfo *GenerateInitInstance(const ::TPCON*)
00782 {
00783 return GenerateInitInstanceLocal((::TPCON*)0);
00784 }
00785
00786 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPCON*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00787 }
00788
00789 namespace ROOT {
00790 void TPGON_ShowMembers(void *obj, TMemberInspector &R__insp);
00791 static void *new_TPGON(void *p = 0);
00792 static void *newArray_TPGON(Long_t size, void *p);
00793 static void delete_TPGON(void *p);
00794 static void deleteArray_TPGON(void *p);
00795 static void destruct_TPGON(void *p);
00796
00797
00798 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPGON*)
00799 {
00800 ::TPGON *ptr = 0;
00801 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPGON >(0);
00802 static ::ROOT::TGenericClassInfo
00803 instance("TPGON", ::TPGON::Class_Version(), "include/TPGON.h", 32,
00804 typeid(::TPGON), DefineBehavior(ptr, ptr),
00805 &::TPGON::Dictionary, isa_proxy, 4,
00806 sizeof(::TPGON) );
00807 instance.SetNew(&new_TPGON);
00808 instance.SetNewArray(&newArray_TPGON);
00809 instance.SetDelete(&delete_TPGON);
00810 instance.SetDeleteArray(&deleteArray_TPGON);
00811 instance.SetDestructor(&destruct_TPGON);
00812 return &instance;
00813 }
00814 TGenericClassInfo *GenerateInitInstance(const ::TPGON*)
00815 {
00816 return GenerateInitInstanceLocal((::TPGON*)0);
00817 }
00818
00819 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPGON*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00820 }
00821
00822 namespace ROOT {
00823 void TPoints3DABC_ShowMembers(void *obj, TMemberInspector &R__insp);
00824 static void delete_TPoints3DABC(void *p);
00825 static void deleteArray_TPoints3DABC(void *p);
00826 static void destruct_TPoints3DABC(void *p);
00827 static void streamer_TPoints3DABC(TBuffer &buf, void *obj);
00828
00829
00830 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPoints3DABC*)
00831 {
00832 ::TPoints3DABC *ptr = 0;
00833 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPoints3DABC >(0);
00834 static ::ROOT::TGenericClassInfo
00835 instance("TPoints3DABC", ::TPoints3DABC::Class_Version(), "include/TPoints3DABC.h", 27,
00836 typeid(::TPoints3DABC), DefineBehavior(ptr, ptr),
00837 &::TPoints3DABC::Dictionary, isa_proxy, 0,
00838 sizeof(::TPoints3DABC) );
00839 instance.SetDelete(&delete_TPoints3DABC);
00840 instance.SetDeleteArray(&deleteArray_TPoints3DABC);
00841 instance.SetDestructor(&destruct_TPoints3DABC);
00842 instance.SetStreamerFunc(&streamer_TPoints3DABC);
00843 return &instance;
00844 }
00845 TGenericClassInfo *GenerateInitInstance(const ::TPoints3DABC*)
00846 {
00847 return GenerateInitInstanceLocal((::TPoints3DABC*)0);
00848 }
00849
00850 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPoints3DABC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00851 }
00852
00853 namespace ROOT {
00854 void TPolyMarker3D_ShowMembers(void *obj, TMemberInspector &R__insp);
00855 static void *new_TPolyMarker3D(void *p = 0);
00856 static void *newArray_TPolyMarker3D(Long_t size, void *p);
00857 static void delete_TPolyMarker3D(void *p);
00858 static void deleteArray_TPolyMarker3D(void *p);
00859 static void destruct_TPolyMarker3D(void *p);
00860 static void streamer_TPolyMarker3D(TBuffer &buf, void *obj);
00861
00862
00863 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPolyMarker3D*)
00864 {
00865 ::TPolyMarker3D *ptr = 0;
00866 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPolyMarker3D >(0);
00867 static ::ROOT::TGenericClassInfo
00868 instance("TPolyMarker3D", ::TPolyMarker3D::Class_Version(), "include/TPolyMarker3D.h", 41,
00869 typeid(::TPolyMarker3D), DefineBehavior(ptr, ptr),
00870 &::TPolyMarker3D::Dictionary, isa_proxy, 1,
00871 sizeof(::TPolyMarker3D) );
00872 instance.SetNew(&new_TPolyMarker3D);
00873 instance.SetNewArray(&newArray_TPolyMarker3D);
00874 instance.SetDelete(&delete_TPolyMarker3D);
00875 instance.SetDeleteArray(&deleteArray_TPolyMarker3D);
00876 instance.SetDestructor(&destruct_TPolyMarker3D);
00877 instance.SetStreamerFunc(&streamer_TPolyMarker3D);
00878 return &instance;
00879 }
00880 TGenericClassInfo *GenerateInitInstance(const ::TPolyMarker3D*)
00881 {
00882 return GenerateInitInstanceLocal((::TPolyMarker3D*)0);
00883 }
00884
00885 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPolyMarker3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00886 }
00887
00888 namespace ROOT {
00889 void TPointSet3D_ShowMembers(void *obj, TMemberInspector &R__insp);
00890 static void *new_TPointSet3D(void *p = 0);
00891 static void *newArray_TPointSet3D(Long_t size, void *p);
00892 static void delete_TPointSet3D(void *p);
00893 static void deleteArray_TPointSet3D(void *p);
00894 static void destruct_TPointSet3D(void *p);
00895 static void streamer_TPointSet3D(TBuffer &buf, void *obj);
00896
00897
00898 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPointSet3D*)
00899 {
00900 ::TPointSet3D *ptr = 0;
00901 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPointSet3D >(0);
00902 static ::ROOT::TGenericClassInfo
00903 instance("TPointSet3D", ::TPointSet3D::Class_Version(), "include/TPointSet3D.h", 26,
00904 typeid(::TPointSet3D), DefineBehavior(ptr, ptr),
00905 &::TPointSet3D::Dictionary, isa_proxy, 1,
00906 sizeof(::TPointSet3D) );
00907 instance.SetNew(&new_TPointSet3D);
00908 instance.SetNewArray(&newArray_TPointSet3D);
00909 instance.SetDelete(&delete_TPointSet3D);
00910 instance.SetDeleteArray(&deleteArray_TPointSet3D);
00911 instance.SetDestructor(&destruct_TPointSet3D);
00912 instance.SetStreamerFunc(&streamer_TPointSet3D);
00913 return &instance;
00914 }
00915 TGenericClassInfo *GenerateInitInstance(const ::TPointSet3D*)
00916 {
00917 return GenerateInitInstanceLocal((::TPointSet3D*)0);
00918 }
00919
00920 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPointSet3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00921 }
00922
00923 namespace ROOT {
00924 void TSPHE_ShowMembers(void *obj, TMemberInspector &R__insp);
00925 static void *new_TSPHE(void *p = 0);
00926 static void *newArray_TSPHE(Long_t size, void *p);
00927 static void delete_TSPHE(void *p);
00928 static void deleteArray_TSPHE(void *p);
00929 static void destruct_TSPHE(void *p);
00930 static void streamer_TSPHE(TBuffer &buf, void *obj);
00931
00932
00933 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSPHE*)
00934 {
00935 ::TSPHE *ptr = 0;
00936 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSPHE >(0);
00937 static ::ROOT::TGenericClassInfo
00938 instance("TSPHE", ::TSPHE::Class_Version(), "include/TSPHE.h", 30,
00939 typeid(::TSPHE), DefineBehavior(ptr, ptr),
00940 &::TSPHE::Dictionary, isa_proxy, 1,
00941 sizeof(::TSPHE) );
00942 instance.SetNew(&new_TSPHE);
00943 instance.SetNewArray(&newArray_TSPHE);
00944 instance.SetDelete(&delete_TSPHE);
00945 instance.SetDeleteArray(&deleteArray_TSPHE);
00946 instance.SetDestructor(&destruct_TSPHE);
00947 instance.SetStreamerFunc(&streamer_TSPHE);
00948 return &instance;
00949 }
00950 TGenericClassInfo *GenerateInitInstance(const ::TSPHE*)
00951 {
00952 return GenerateInitInstanceLocal((::TSPHE*)0);
00953 }
00954
00955 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSPHE*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00956 }
00957
00958 namespace ROOT {
00959 void TTRAP_ShowMembers(void *obj, TMemberInspector &R__insp);
00960 static void *new_TTRAP(void *p = 0);
00961 static void *newArray_TTRAP(Long_t size, void *p);
00962 static void delete_TTRAP(void *p);
00963 static void deleteArray_TTRAP(void *p);
00964 static void destruct_TTRAP(void *p);
00965
00966
00967 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTRAP*)
00968 {
00969 ::TTRAP *ptr = 0;
00970 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTRAP >(0);
00971 static ::ROOT::TGenericClassInfo
00972 instance("TTRAP", ::TTRAP::Class_Version(), "include/TTRAP.h", 35,
00973 typeid(::TTRAP), DefineBehavior(ptr, ptr),
00974 &::TTRAP::Dictionary, isa_proxy, 4,
00975 sizeof(::TTRAP) );
00976 instance.SetNew(&new_TTRAP);
00977 instance.SetNewArray(&newArray_TTRAP);
00978 instance.SetDelete(&delete_TTRAP);
00979 instance.SetDeleteArray(&deleteArray_TTRAP);
00980 instance.SetDestructor(&destruct_TTRAP);
00981 return &instance;
00982 }
00983 TGenericClassInfo *GenerateInitInstance(const ::TTRAP*)
00984 {
00985 return GenerateInitInstanceLocal((::TTRAP*)0);
00986 }
00987
00988 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTRAP*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00989 }
00990
00991 namespace ROOT {
00992 void TTRD1_ShowMembers(void *obj, TMemberInspector &R__insp);
00993 static void *new_TTRD1(void *p = 0);
00994 static void *newArray_TTRD1(Long_t size, void *p);
00995 static void delete_TTRD1(void *p);
00996 static void deleteArray_TTRD1(void *p);
00997 static void destruct_TTRD1(void *p);
00998
00999
01000 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTRD1*)
01001 {
01002 ::TTRD1 *ptr = 0;
01003 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTRD1 >(0);
01004 static ::ROOT::TGenericClassInfo
01005 instance("TTRD1", ::TTRD1::Class_Version(), "include/TTRD1.h", 30,
01006 typeid(::TTRD1), DefineBehavior(ptr, ptr),
01007 &::TTRD1::Dictionary, isa_proxy, 4,
01008 sizeof(::TTRD1) );
01009 instance.SetNew(&new_TTRD1);
01010 instance.SetNewArray(&newArray_TTRD1);
01011 instance.SetDelete(&delete_TTRD1);
01012 instance.SetDeleteArray(&deleteArray_TTRD1);
01013 instance.SetDestructor(&destruct_TTRD1);
01014 return &instance;
01015 }
01016 TGenericClassInfo *GenerateInitInstance(const ::TTRD1*)
01017 {
01018 return GenerateInitInstanceLocal((::TTRD1*)0);
01019 }
01020
01021 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTRD1*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01022 }
01023
01024 namespace ROOT {
01025 void TTRD2_ShowMembers(void *obj, TMemberInspector &R__insp);
01026 static void *new_TTRD2(void *p = 0);
01027 static void *newArray_TTRD2(Long_t size, void *p);
01028 static void delete_TTRD2(void *p);
01029 static void deleteArray_TTRD2(void *p);
01030 static void destruct_TTRD2(void *p);
01031
01032
01033 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTRD2*)
01034 {
01035 ::TTRD2 *ptr = 0;
01036 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTRD2 >(0);
01037 static ::ROOT::TGenericClassInfo
01038 instance("TTRD2", ::TTRD2::Class_Version(), "include/TTRD2.h", 31,
01039 typeid(::TTRD2), DefineBehavior(ptr, ptr),
01040 &::TTRD2::Dictionary, isa_proxy, 4,
01041 sizeof(::TTRD2) );
01042 instance.SetNew(&new_TTRD2);
01043 instance.SetNewArray(&newArray_TTRD2);
01044 instance.SetDelete(&delete_TTRD2);
01045 instance.SetDeleteArray(&deleteArray_TTRD2);
01046 instance.SetDestructor(&destruct_TTRD2);
01047 return &instance;
01048 }
01049 TGenericClassInfo *GenerateInitInstance(const ::TTRD2*)
01050 {
01051 return GenerateInitInstanceLocal((::TTRD2*)0);
01052 }
01053
01054 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTRD2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01055 }
01056
01057 namespace ROOT {
01058 void TView3D_ShowMembers(void *obj, TMemberInspector &R__insp);
01059 static void *new_TView3D(void *p = 0);
01060 static void *newArray_TView3D(Long_t size, void *p);
01061 static void delete_TView3D(void *p);
01062 static void deleteArray_TView3D(void *p);
01063 static void destruct_TView3D(void *p);
01064 static void streamer_TView3D(TBuffer &buf, void *obj);
01065
01066
01067 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TView3D*)
01068 {
01069 ::TView3D *ptr = 0;
01070 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TView3D >(0);
01071 static ::ROOT::TGenericClassInfo
01072 instance("TView3D", ::TView3D::Class_Version(), "include/TView3D.h", 31,
01073 typeid(::TView3D), DefineBehavior(ptr, ptr),
01074 &::TView3D::Dictionary, isa_proxy, 1,
01075 sizeof(::TView3D) );
01076 instance.SetNew(&new_TView3D);
01077 instance.SetNewArray(&newArray_TView3D);
01078 instance.SetDelete(&delete_TView3D);
01079 instance.SetDeleteArray(&deleteArray_TView3D);
01080 instance.SetDestructor(&destruct_TView3D);
01081 instance.SetStreamerFunc(&streamer_TView3D);
01082 return &instance;
01083 }
01084 TGenericClassInfo *GenerateInitInstance(const ::TView3D*)
01085 {
01086 return GenerateInitInstanceLocal((::TView3D*)0);
01087 }
01088
01089 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TView3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01090 }
01091
01092 namespace ROOT {
01093 void TXTRU_ShowMembers(void *obj, TMemberInspector &R__insp);
01094 static void *new_TXTRU(void *p = 0);
01095 static void *newArray_TXTRU(Long_t size, void *p);
01096 static void delete_TXTRU(void *p);
01097 static void deleteArray_TXTRU(void *p);
01098 static void destruct_TXTRU(void *p);
01099
01100
01101 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TXTRU*)
01102 {
01103 ::TXTRU *ptr = 0;
01104 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TXTRU >(0);
01105 static ::ROOT::TGenericClassInfo
01106 instance("TXTRU", ::TXTRU::Class_Version(), "include/TXTRU.h", 24,
01107 typeid(::TXTRU), DefineBehavior(ptr, ptr),
01108 &::TXTRU::Dictionary, isa_proxy, 4,
01109 sizeof(::TXTRU) );
01110 instance.SetNew(&new_TXTRU);
01111 instance.SetNewArray(&newArray_TXTRU);
01112 instance.SetDelete(&delete_TXTRU);
01113 instance.SetDeleteArray(&deleteArray_TXTRU);
01114 instance.SetDestructor(&destruct_TXTRU);
01115 return &instance;
01116 }
01117 TGenericClassInfo *GenerateInitInstance(const ::TXTRU*)
01118 {
01119 return GenerateInitInstanceLocal((::TXTRU*)0);
01120 }
01121
01122 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TXTRU*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01123 }
01124
01125
01126 TClass *TAxis3D::fgIsA = 0;
01127
01128
01129 const char *TAxis3D::Class_Name()
01130 {
01131 return "TAxis3D";
01132 }
01133
01134
01135 const char *TAxis3D::ImplFileName()
01136 {
01137 return ::ROOT::GenerateInitInstanceLocal((const ::TAxis3D*)0x0)->GetImplFileName();
01138 }
01139
01140
01141 int TAxis3D::ImplFileLine()
01142 {
01143 return ::ROOT::GenerateInitInstanceLocal((const ::TAxis3D*)0x0)->GetImplFileLine();
01144 }
01145
01146
01147 void TAxis3D::Dictionary()
01148 {
01149 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAxis3D*)0x0)->GetClass();
01150 }
01151
01152
01153 TClass *TAxis3D::Class()
01154 {
01155 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAxis3D*)0x0)->GetClass();
01156 return fgIsA;
01157 }
01158
01159
01160 TClass *TMaterial::fgIsA = 0;
01161
01162
01163 const char *TMaterial::Class_Name()
01164 {
01165 return "TMaterial";
01166 }
01167
01168
01169 const char *TMaterial::ImplFileName()
01170 {
01171 return ::ROOT::GenerateInitInstanceLocal((const ::TMaterial*)0x0)->GetImplFileName();
01172 }
01173
01174
01175 int TMaterial::ImplFileLine()
01176 {
01177 return ::ROOT::GenerateInitInstanceLocal((const ::TMaterial*)0x0)->GetImplFileLine();
01178 }
01179
01180
01181 void TMaterial::Dictionary()
01182 {
01183 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMaterial*)0x0)->GetClass();
01184 }
01185
01186
01187 TClass *TMaterial::Class()
01188 {
01189 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMaterial*)0x0)->GetClass();
01190 return fgIsA;
01191 }
01192
01193
01194 TClass *TNode::fgIsA = 0;
01195
01196
01197 const char *TNode::Class_Name()
01198 {
01199 return "TNode";
01200 }
01201
01202
01203 const char *TNode::ImplFileName()
01204 {
01205 return ::ROOT::GenerateInitInstanceLocal((const ::TNode*)0x0)->GetImplFileName();
01206 }
01207
01208
01209 int TNode::ImplFileLine()
01210 {
01211 return ::ROOT::GenerateInitInstanceLocal((const ::TNode*)0x0)->GetImplFileLine();
01212 }
01213
01214
01215 void TNode::Dictionary()
01216 {
01217 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNode*)0x0)->GetClass();
01218 }
01219
01220
01221 TClass *TNode::Class()
01222 {
01223 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNode*)0x0)->GetClass();
01224 return fgIsA;
01225 }
01226
01227
01228 TClass *TShape::fgIsA = 0;
01229
01230
01231 const char *TShape::Class_Name()
01232 {
01233 return "TShape";
01234 }
01235
01236
01237 const char *TShape::ImplFileName()
01238 {
01239 return ::ROOT::GenerateInitInstanceLocal((const ::TShape*)0x0)->GetImplFileName();
01240 }
01241
01242
01243 int TShape::ImplFileLine()
01244 {
01245 return ::ROOT::GenerateInitInstanceLocal((const ::TShape*)0x0)->GetImplFileLine();
01246 }
01247
01248
01249 void TShape::Dictionary()
01250 {
01251 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TShape*)0x0)->GetClass();
01252 }
01253
01254
01255 TClass *TShape::Class()
01256 {
01257 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TShape*)0x0)->GetClass();
01258 return fgIsA;
01259 }
01260
01261
01262 TClass *TBRIK::fgIsA = 0;
01263
01264
01265 const char *TBRIK::Class_Name()
01266 {
01267 return "TBRIK";
01268 }
01269
01270
01271 const char *TBRIK::ImplFileName()
01272 {
01273 return ::ROOT::GenerateInitInstanceLocal((const ::TBRIK*)0x0)->GetImplFileName();
01274 }
01275
01276
01277 int TBRIK::ImplFileLine()
01278 {
01279 return ::ROOT::GenerateInitInstanceLocal((const ::TBRIK*)0x0)->GetImplFileLine();
01280 }
01281
01282
01283 void TBRIK::Dictionary()
01284 {
01285 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBRIK*)0x0)->GetClass();
01286 }
01287
01288
01289 TClass *TBRIK::Class()
01290 {
01291 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBRIK*)0x0)->GetClass();
01292 return fgIsA;
01293 }
01294
01295
01296 TClass *TTUBE::fgIsA = 0;
01297
01298
01299 const char *TTUBE::Class_Name()
01300 {
01301 return "TTUBE";
01302 }
01303
01304
01305 const char *TTUBE::ImplFileName()
01306 {
01307 return ::ROOT::GenerateInitInstanceLocal((const ::TTUBE*)0x0)->GetImplFileName();
01308 }
01309
01310
01311 int TTUBE::ImplFileLine()
01312 {
01313 return ::ROOT::GenerateInitInstanceLocal((const ::TTUBE*)0x0)->GetImplFileLine();
01314 }
01315
01316
01317 void TTUBE::Dictionary()
01318 {
01319 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTUBE*)0x0)->GetClass();
01320 }
01321
01322
01323 TClass *TTUBE::Class()
01324 {
01325 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTUBE*)0x0)->GetClass();
01326 return fgIsA;
01327 }
01328
01329
01330 TClass *TCONE::fgIsA = 0;
01331
01332
01333 const char *TCONE::Class_Name()
01334 {
01335 return "TCONE";
01336 }
01337
01338
01339 const char *TCONE::ImplFileName()
01340 {
01341 return ::ROOT::GenerateInitInstanceLocal((const ::TCONE*)0x0)->GetImplFileName();
01342 }
01343
01344
01345 int TCONE::ImplFileLine()
01346 {
01347 return ::ROOT::GenerateInitInstanceLocal((const ::TCONE*)0x0)->GetImplFileLine();
01348 }
01349
01350
01351 void TCONE::Dictionary()
01352 {
01353 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCONE*)0x0)->GetClass();
01354 }
01355
01356
01357 TClass *TCONE::Class()
01358 {
01359 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCONE*)0x0)->GetClass();
01360 return fgIsA;
01361 }
01362
01363
01364 TClass *TTUBS::fgIsA = 0;
01365
01366
01367 const char *TTUBS::Class_Name()
01368 {
01369 return "TTUBS";
01370 }
01371
01372
01373 const char *TTUBS::ImplFileName()
01374 {
01375 return ::ROOT::GenerateInitInstanceLocal((const ::TTUBS*)0x0)->GetImplFileName();
01376 }
01377
01378
01379 int TTUBS::ImplFileLine()
01380 {
01381 return ::ROOT::GenerateInitInstanceLocal((const ::TTUBS*)0x0)->GetImplFileLine();
01382 }
01383
01384
01385 void TTUBS::Dictionary()
01386 {
01387 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTUBS*)0x0)->GetClass();
01388 }
01389
01390
01391 TClass *TTUBS::Class()
01392 {
01393 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTUBS*)0x0)->GetClass();
01394 return fgIsA;
01395 }
01396
01397
01398 TClass *TCONS::fgIsA = 0;
01399
01400
01401 const char *TCONS::Class_Name()
01402 {
01403 return "TCONS";
01404 }
01405
01406
01407 const char *TCONS::ImplFileName()
01408 {
01409 return ::ROOT::GenerateInitInstanceLocal((const ::TCONS*)0x0)->GetImplFileName();
01410 }
01411
01412
01413 int TCONS::ImplFileLine()
01414 {
01415 return ::ROOT::GenerateInitInstanceLocal((const ::TCONS*)0x0)->GetImplFileLine();
01416 }
01417
01418
01419 void TCONS::Dictionary()
01420 {
01421 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCONS*)0x0)->GetClass();
01422 }
01423
01424
01425 TClass *TCONS::Class()
01426 {
01427 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCONS*)0x0)->GetClass();
01428 return fgIsA;
01429 }
01430
01431
01432 TClass *TCTUB::fgIsA = 0;
01433
01434
01435 const char *TCTUB::Class_Name()
01436 {
01437 return "TCTUB";
01438 }
01439
01440
01441 const char *TCTUB::ImplFileName()
01442 {
01443 return ::ROOT::GenerateInitInstanceLocal((const ::TCTUB*)0x0)->GetImplFileName();
01444 }
01445
01446
01447 int TCTUB::ImplFileLine()
01448 {
01449 return ::ROOT::GenerateInitInstanceLocal((const ::TCTUB*)0x0)->GetImplFileLine();
01450 }
01451
01452
01453 void TCTUB::Dictionary()
01454 {
01455 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCTUB*)0x0)->GetClass();
01456 }
01457
01458
01459 TClass *TCTUB::Class()
01460 {
01461 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCTUB*)0x0)->GetClass();
01462 return fgIsA;
01463 }
01464
01465
01466 TClass *TELTU::fgIsA = 0;
01467
01468
01469 const char *TELTU::Class_Name()
01470 {
01471 return "TELTU";
01472 }
01473
01474
01475 const char *TELTU::ImplFileName()
01476 {
01477 return ::ROOT::GenerateInitInstanceLocal((const ::TELTU*)0x0)->GetImplFileName();
01478 }
01479
01480
01481 int TELTU::ImplFileLine()
01482 {
01483 return ::ROOT::GenerateInitInstanceLocal((const ::TELTU*)0x0)->GetImplFileLine();
01484 }
01485
01486
01487 void TELTU::Dictionary()
01488 {
01489 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TELTU*)0x0)->GetClass();
01490 }
01491
01492
01493 TClass *TELTU::Class()
01494 {
01495 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TELTU*)0x0)->GetClass();
01496 return fgIsA;
01497 }
01498
01499
01500 TClass *TRotMatrix::fgIsA = 0;
01501
01502
01503 const char *TRotMatrix::Class_Name()
01504 {
01505 return "TRotMatrix";
01506 }
01507
01508
01509 const char *TRotMatrix::ImplFileName()
01510 {
01511 return ::ROOT::GenerateInitInstanceLocal((const ::TRotMatrix*)0x0)->GetImplFileName();
01512 }
01513
01514
01515 int TRotMatrix::ImplFileLine()
01516 {
01517 return ::ROOT::GenerateInitInstanceLocal((const ::TRotMatrix*)0x0)->GetImplFileLine();
01518 }
01519
01520
01521 void TRotMatrix::Dictionary()
01522 {
01523 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRotMatrix*)0x0)->GetClass();
01524 }
01525
01526
01527 TClass *TRotMatrix::Class()
01528 {
01529 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRotMatrix*)0x0)->GetClass();
01530 return fgIsA;
01531 }
01532
01533
01534 TClass *TGeometry::fgIsA = 0;
01535
01536
01537 const char *TGeometry::Class_Name()
01538 {
01539 return "TGeometry";
01540 }
01541
01542
01543 const char *TGeometry::ImplFileName()
01544 {
01545 return ::ROOT::GenerateInitInstanceLocal((const ::TGeometry*)0x0)->GetImplFileName();
01546 }
01547
01548
01549 int TGeometry::ImplFileLine()
01550 {
01551 return ::ROOT::GenerateInitInstanceLocal((const ::TGeometry*)0x0)->GetImplFileLine();
01552 }
01553
01554
01555 void TGeometry::Dictionary()
01556 {
01557 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeometry*)0x0)->GetClass();
01558 }
01559
01560
01561 TClass *TGeometry::Class()
01562 {
01563 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeometry*)0x0)->GetClass();
01564 return fgIsA;
01565 }
01566
01567
01568 TClass *TGTRA::fgIsA = 0;
01569
01570
01571 const char *TGTRA::Class_Name()
01572 {
01573 return "TGTRA";
01574 }
01575
01576
01577 const char *TGTRA::ImplFileName()
01578 {
01579 return ::ROOT::GenerateInitInstanceLocal((const ::TGTRA*)0x0)->GetImplFileName();
01580 }
01581
01582
01583 int TGTRA::ImplFileLine()
01584 {
01585 return ::ROOT::GenerateInitInstanceLocal((const ::TGTRA*)0x0)->GetImplFileLine();
01586 }
01587
01588
01589 void TGTRA::Dictionary()
01590 {
01591 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGTRA*)0x0)->GetClass();
01592 }
01593
01594
01595 TClass *TGTRA::Class()
01596 {
01597 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGTRA*)0x0)->GetClass();
01598 return fgIsA;
01599 }
01600
01601
01602 TClass *TPolyLine3D::fgIsA = 0;
01603
01604
01605 const char *TPolyLine3D::Class_Name()
01606 {
01607 return "TPolyLine3D";
01608 }
01609
01610
01611 const char *TPolyLine3D::ImplFileName()
01612 {
01613 return ::ROOT::GenerateInitInstanceLocal((const ::TPolyLine3D*)0x0)->GetImplFileName();
01614 }
01615
01616
01617 int TPolyLine3D::ImplFileLine()
01618 {
01619 return ::ROOT::GenerateInitInstanceLocal((const ::TPolyLine3D*)0x0)->GetImplFileLine();
01620 }
01621
01622
01623 void TPolyLine3D::Dictionary()
01624 {
01625 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPolyLine3D*)0x0)->GetClass();
01626 }
01627
01628
01629 TClass *TPolyLine3D::Class()
01630 {
01631 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPolyLine3D*)0x0)->GetClass();
01632 return fgIsA;
01633 }
01634
01635
01636 TClass *THelix::fgIsA = 0;
01637
01638
01639 const char *THelix::Class_Name()
01640 {
01641 return "THelix";
01642 }
01643
01644
01645 const char *THelix::ImplFileName()
01646 {
01647 return ::ROOT::GenerateInitInstanceLocal((const ::THelix*)0x0)->GetImplFileName();
01648 }
01649
01650
01651 int THelix::ImplFileLine()
01652 {
01653 return ::ROOT::GenerateInitInstanceLocal((const ::THelix*)0x0)->GetImplFileLine();
01654 }
01655
01656
01657 void THelix::Dictionary()
01658 {
01659 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THelix*)0x0)->GetClass();
01660 }
01661
01662
01663 TClass *THelix::Class()
01664 {
01665 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THelix*)0x0)->GetClass();
01666 return fgIsA;
01667 }
01668
01669
01670 TClass *THYPE::fgIsA = 0;
01671
01672
01673 const char *THYPE::Class_Name()
01674 {
01675 return "THYPE";
01676 }
01677
01678
01679 const char *THYPE::ImplFileName()
01680 {
01681 return ::ROOT::GenerateInitInstanceLocal((const ::THYPE*)0x0)->GetImplFileName();
01682 }
01683
01684
01685 int THYPE::ImplFileLine()
01686 {
01687 return ::ROOT::GenerateInitInstanceLocal((const ::THYPE*)0x0)->GetImplFileLine();
01688 }
01689
01690
01691 void THYPE::Dictionary()
01692 {
01693 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THYPE*)0x0)->GetClass();
01694 }
01695
01696
01697 TClass *THYPE::Class()
01698 {
01699 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THYPE*)0x0)->GetClass();
01700 return fgIsA;
01701 }
01702
01703
01704 TClass *TMarker3DBox::fgIsA = 0;
01705
01706
01707 const char *TMarker3DBox::Class_Name()
01708 {
01709 return "TMarker3DBox";
01710 }
01711
01712
01713 const char *TMarker3DBox::ImplFileName()
01714 {
01715 return ::ROOT::GenerateInitInstanceLocal((const ::TMarker3DBox*)0x0)->GetImplFileName();
01716 }
01717
01718
01719 int TMarker3DBox::ImplFileLine()
01720 {
01721 return ::ROOT::GenerateInitInstanceLocal((const ::TMarker3DBox*)0x0)->GetImplFileLine();
01722 }
01723
01724
01725 void TMarker3DBox::Dictionary()
01726 {
01727 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMarker3DBox*)0x0)->GetClass();
01728 }
01729
01730
01731 TClass *TMarker3DBox::Class()
01732 {
01733 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMarker3DBox*)0x0)->GetClass();
01734 return fgIsA;
01735 }
01736
01737
01738 TClass *TMixture::fgIsA = 0;
01739
01740
01741 const char *TMixture::Class_Name()
01742 {
01743 return "TMixture";
01744 }
01745
01746
01747 const char *TMixture::ImplFileName()
01748 {
01749 return ::ROOT::GenerateInitInstanceLocal((const ::TMixture*)0x0)->GetImplFileName();
01750 }
01751
01752
01753 int TMixture::ImplFileLine()
01754 {
01755 return ::ROOT::GenerateInitInstanceLocal((const ::TMixture*)0x0)->GetImplFileLine();
01756 }
01757
01758
01759 void TMixture::Dictionary()
01760 {
01761 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMixture*)0x0)->GetClass();
01762 }
01763
01764
01765 TClass *TMixture::Class()
01766 {
01767 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMixture*)0x0)->GetClass();
01768 return fgIsA;
01769 }
01770
01771
01772 TClass *TNodeDiv::fgIsA = 0;
01773
01774
01775 const char *TNodeDiv::Class_Name()
01776 {
01777 return "TNodeDiv";
01778 }
01779
01780
01781 const char *TNodeDiv::ImplFileName()
01782 {
01783 return ::ROOT::GenerateInitInstanceLocal((const ::TNodeDiv*)0x0)->GetImplFileName();
01784 }
01785
01786
01787 int TNodeDiv::ImplFileLine()
01788 {
01789 return ::ROOT::GenerateInitInstanceLocal((const ::TNodeDiv*)0x0)->GetImplFileLine();
01790 }
01791
01792
01793 void TNodeDiv::Dictionary()
01794 {
01795 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNodeDiv*)0x0)->GetClass();
01796 }
01797
01798
01799 TClass *TNodeDiv::Class()
01800 {
01801 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TNodeDiv*)0x0)->GetClass();
01802 return fgIsA;
01803 }
01804
01805
01806 TClass *TPARA::fgIsA = 0;
01807
01808
01809 const char *TPARA::Class_Name()
01810 {
01811 return "TPARA";
01812 }
01813
01814
01815 const char *TPARA::ImplFileName()
01816 {
01817 return ::ROOT::GenerateInitInstanceLocal((const ::TPARA*)0x0)->GetImplFileName();
01818 }
01819
01820
01821 int TPARA::ImplFileLine()
01822 {
01823 return ::ROOT::GenerateInitInstanceLocal((const ::TPARA*)0x0)->GetImplFileLine();
01824 }
01825
01826
01827 void TPARA::Dictionary()
01828 {
01829 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPARA*)0x0)->GetClass();
01830 }
01831
01832
01833 TClass *TPARA::Class()
01834 {
01835 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPARA*)0x0)->GetClass();
01836 return fgIsA;
01837 }
01838
01839
01840 TClass *TPCON::fgIsA = 0;
01841
01842
01843 const char *TPCON::Class_Name()
01844 {
01845 return "TPCON";
01846 }
01847
01848
01849 const char *TPCON::ImplFileName()
01850 {
01851 return ::ROOT::GenerateInitInstanceLocal((const ::TPCON*)0x0)->GetImplFileName();
01852 }
01853
01854
01855 int TPCON::ImplFileLine()
01856 {
01857 return ::ROOT::GenerateInitInstanceLocal((const ::TPCON*)0x0)->GetImplFileLine();
01858 }
01859
01860
01861 void TPCON::Dictionary()
01862 {
01863 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPCON*)0x0)->GetClass();
01864 }
01865
01866
01867 TClass *TPCON::Class()
01868 {
01869 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPCON*)0x0)->GetClass();
01870 return fgIsA;
01871 }
01872
01873
01874 TClass *TPGON::fgIsA = 0;
01875
01876
01877 const char *TPGON::Class_Name()
01878 {
01879 return "TPGON";
01880 }
01881
01882
01883 const char *TPGON::ImplFileName()
01884 {
01885 return ::ROOT::GenerateInitInstanceLocal((const ::TPGON*)0x0)->GetImplFileName();
01886 }
01887
01888
01889 int TPGON::ImplFileLine()
01890 {
01891 return ::ROOT::GenerateInitInstanceLocal((const ::TPGON*)0x0)->GetImplFileLine();
01892 }
01893
01894
01895 void TPGON::Dictionary()
01896 {
01897 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPGON*)0x0)->GetClass();
01898 }
01899
01900
01901 TClass *TPGON::Class()
01902 {
01903 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPGON*)0x0)->GetClass();
01904 return fgIsA;
01905 }
01906
01907
01908 TClass *TPoints3DABC::fgIsA = 0;
01909
01910
01911 const char *TPoints3DABC::Class_Name()
01912 {
01913 return "TPoints3DABC";
01914 }
01915
01916
01917 const char *TPoints3DABC::ImplFileName()
01918 {
01919 return ::ROOT::GenerateInitInstanceLocal((const ::TPoints3DABC*)0x0)->GetImplFileName();
01920 }
01921
01922
01923 int TPoints3DABC::ImplFileLine()
01924 {
01925 return ::ROOT::GenerateInitInstanceLocal((const ::TPoints3DABC*)0x0)->GetImplFileLine();
01926 }
01927
01928
01929 void TPoints3DABC::Dictionary()
01930 {
01931 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPoints3DABC*)0x0)->GetClass();
01932 }
01933
01934
01935 TClass *TPoints3DABC::Class()
01936 {
01937 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPoints3DABC*)0x0)->GetClass();
01938 return fgIsA;
01939 }
01940
01941
01942 TClass *TPolyMarker3D::fgIsA = 0;
01943
01944
01945 const char *TPolyMarker3D::Class_Name()
01946 {
01947 return "TPolyMarker3D";
01948 }
01949
01950
01951 const char *TPolyMarker3D::ImplFileName()
01952 {
01953 return ::ROOT::GenerateInitInstanceLocal((const ::TPolyMarker3D*)0x0)->GetImplFileName();
01954 }
01955
01956
01957 int TPolyMarker3D::ImplFileLine()
01958 {
01959 return ::ROOT::GenerateInitInstanceLocal((const ::TPolyMarker3D*)0x0)->GetImplFileLine();
01960 }
01961
01962
01963 void TPolyMarker3D::Dictionary()
01964 {
01965 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPolyMarker3D*)0x0)->GetClass();
01966 }
01967
01968
01969 TClass *TPolyMarker3D::Class()
01970 {
01971 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPolyMarker3D*)0x0)->GetClass();
01972 return fgIsA;
01973 }
01974
01975
01976 TClass *TPointSet3D::fgIsA = 0;
01977
01978
01979 const char *TPointSet3D::Class_Name()
01980 {
01981 return "TPointSet3D";
01982 }
01983
01984
01985 const char *TPointSet3D::ImplFileName()
01986 {
01987 return ::ROOT::GenerateInitInstanceLocal((const ::TPointSet3D*)0x0)->GetImplFileName();
01988 }
01989
01990
01991 int TPointSet3D::ImplFileLine()
01992 {
01993 return ::ROOT::GenerateInitInstanceLocal((const ::TPointSet3D*)0x0)->GetImplFileLine();
01994 }
01995
01996
01997 void TPointSet3D::Dictionary()
01998 {
01999 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPointSet3D*)0x0)->GetClass();
02000 }
02001
02002
02003 TClass *TPointSet3D::Class()
02004 {
02005 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPointSet3D*)0x0)->GetClass();
02006 return fgIsA;
02007 }
02008
02009
02010 TClass *TSPHE::fgIsA = 0;
02011
02012
02013 const char *TSPHE::Class_Name()
02014 {
02015 return "TSPHE";
02016 }
02017
02018
02019 const char *TSPHE::ImplFileName()
02020 {
02021 return ::ROOT::GenerateInitInstanceLocal((const ::TSPHE*)0x0)->GetImplFileName();
02022 }
02023
02024
02025 int TSPHE::ImplFileLine()
02026 {
02027 return ::ROOT::GenerateInitInstanceLocal((const ::TSPHE*)0x0)->GetImplFileLine();
02028 }
02029
02030
02031 void TSPHE::Dictionary()
02032 {
02033 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSPHE*)0x0)->GetClass();
02034 }
02035
02036
02037 TClass *TSPHE::Class()
02038 {
02039 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSPHE*)0x0)->GetClass();
02040 return fgIsA;
02041 }
02042
02043
02044 TClass *TTRAP::fgIsA = 0;
02045
02046
02047 const char *TTRAP::Class_Name()
02048 {
02049 return "TTRAP";
02050 }
02051
02052
02053 const char *TTRAP::ImplFileName()
02054 {
02055 return ::ROOT::GenerateInitInstanceLocal((const ::TTRAP*)0x0)->GetImplFileName();
02056 }
02057
02058
02059 int TTRAP::ImplFileLine()
02060 {
02061 return ::ROOT::GenerateInitInstanceLocal((const ::TTRAP*)0x0)->GetImplFileLine();
02062 }
02063
02064
02065 void TTRAP::Dictionary()
02066 {
02067 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTRAP*)0x0)->GetClass();
02068 }
02069
02070
02071 TClass *TTRAP::Class()
02072 {
02073 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTRAP*)0x0)->GetClass();
02074 return fgIsA;
02075 }
02076
02077
02078 TClass *TTRD1::fgIsA = 0;
02079
02080
02081 const char *TTRD1::Class_Name()
02082 {
02083 return "TTRD1";
02084 }
02085
02086
02087 const char *TTRD1::ImplFileName()
02088 {
02089 return ::ROOT::GenerateInitInstanceLocal((const ::TTRD1*)0x0)->GetImplFileName();
02090 }
02091
02092
02093 int TTRD1::ImplFileLine()
02094 {
02095 return ::ROOT::GenerateInitInstanceLocal((const ::TTRD1*)0x0)->GetImplFileLine();
02096 }
02097
02098
02099 void TTRD1::Dictionary()
02100 {
02101 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTRD1*)0x0)->GetClass();
02102 }
02103
02104
02105 TClass *TTRD1::Class()
02106 {
02107 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTRD1*)0x0)->GetClass();
02108 return fgIsA;
02109 }
02110
02111
02112 TClass *TTRD2::fgIsA = 0;
02113
02114
02115 const char *TTRD2::Class_Name()
02116 {
02117 return "TTRD2";
02118 }
02119
02120
02121 const char *TTRD2::ImplFileName()
02122 {
02123 return ::ROOT::GenerateInitInstanceLocal((const ::TTRD2*)0x0)->GetImplFileName();
02124 }
02125
02126
02127 int TTRD2::ImplFileLine()
02128 {
02129 return ::ROOT::GenerateInitInstanceLocal((const ::TTRD2*)0x0)->GetImplFileLine();
02130 }
02131
02132
02133 void TTRD2::Dictionary()
02134 {
02135 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTRD2*)0x0)->GetClass();
02136 }
02137
02138
02139 TClass *TTRD2::Class()
02140 {
02141 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTRD2*)0x0)->GetClass();
02142 return fgIsA;
02143 }
02144
02145
02146 TClass *TView3D::fgIsA = 0;
02147
02148
02149 const char *TView3D::Class_Name()
02150 {
02151 return "TView3D";
02152 }
02153
02154
02155 const char *TView3D::ImplFileName()
02156 {
02157 return ::ROOT::GenerateInitInstanceLocal((const ::TView3D*)0x0)->GetImplFileName();
02158 }
02159
02160
02161 int TView3D::ImplFileLine()
02162 {
02163 return ::ROOT::GenerateInitInstanceLocal((const ::TView3D*)0x0)->GetImplFileLine();
02164 }
02165
02166
02167 void TView3D::Dictionary()
02168 {
02169 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TView3D*)0x0)->GetClass();
02170 }
02171
02172
02173 TClass *TView3D::Class()
02174 {
02175 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TView3D*)0x0)->GetClass();
02176 return fgIsA;
02177 }
02178
02179
02180 TClass *TXTRU::fgIsA = 0;
02181
02182
02183 const char *TXTRU::Class_Name()
02184 {
02185 return "TXTRU";
02186 }
02187
02188
02189 const char *TXTRU::ImplFileName()
02190 {
02191 return ::ROOT::GenerateInitInstanceLocal((const ::TXTRU*)0x0)->GetImplFileName();
02192 }
02193
02194
02195 int TXTRU::ImplFileLine()
02196 {
02197 return ::ROOT::GenerateInitInstanceLocal((const ::TXTRU*)0x0)->GetImplFileLine();
02198 }
02199
02200
02201 void TXTRU::Dictionary()
02202 {
02203 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TXTRU*)0x0)->GetClass();
02204 }
02205
02206
02207 TClass *TXTRU::Class()
02208 {
02209 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TXTRU*)0x0)->GetClass();
02210 return fgIsA;
02211 }
02212
02213
02214 void TAxis3D::Streamer(TBuffer &R__b)
02215 {
02216
02217
02218 if (R__b.IsReading()) {
02219 R__b.ReadClassBuffer(TAxis3D::Class(),this);
02220 } else {
02221 R__b.WriteClassBuffer(TAxis3D::Class(),this);
02222 }
02223 }
02224
02225
02226 void TAxis3D::ShowMembers(TMemberInspector &R__insp)
02227 {
02228
02229 TClass *R__cl = ::TAxis3D::IsA();
02230 if (R__cl || R__insp.IsA()) { }
02231 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis[3]", fAxis);
02232 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
02233 R__insp.InspectMember(fOption, "fOption.");
02234 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelected", &fSelected);
02235 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoomMode", &fZoomMode);
02236 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStickyZoom", &fStickyZoom);
02237 TNamed::ShowMembers(R__insp);
02238 }
02239
02240 namespace ROOT {
02241
02242 static void *new_TAxis3D(void *p) {
02243 return p ? new(p) ::TAxis3D : new ::TAxis3D;
02244 }
02245 static void *newArray_TAxis3D(Long_t nElements, void *p) {
02246 return p ? new(p) ::TAxis3D[nElements] : new ::TAxis3D[nElements];
02247 }
02248
02249 static void delete_TAxis3D(void *p) {
02250 delete ((::TAxis3D*)p);
02251 }
02252 static void deleteArray_TAxis3D(void *p) {
02253 delete [] ((::TAxis3D*)p);
02254 }
02255 static void destruct_TAxis3D(void *p) {
02256 typedef ::TAxis3D current_t;
02257 ((current_t*)p)->~current_t();
02258 }
02259 }
02260
02261
02262 void TBRIK::Streamer(TBuffer &R__b)
02263 {
02264
02265
02266 if (R__b.IsReading()) {
02267 R__b.ReadClassBuffer(TBRIK::Class(),this);
02268 } else {
02269 R__b.WriteClassBuffer(TBRIK::Class(),this);
02270 }
02271 }
02272
02273
02274 void TBRIK::ShowMembers(TMemberInspector &R__insp)
02275 {
02276
02277 TClass *R__cl = ::TBRIK::IsA();
02278 if (R__cl || R__insp.IsA()) { }
02279 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx", &fDx);
02280 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDy", &fDy);
02281 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
02282 TShape::ShowMembers(R__insp);
02283 }
02284
02285 namespace ROOT {
02286
02287 static void *new_TBRIK(void *p) {
02288 return p ? new(p) ::TBRIK : new ::TBRIK;
02289 }
02290 static void *newArray_TBRIK(Long_t nElements, void *p) {
02291 return p ? new(p) ::TBRIK[nElements] : new ::TBRIK[nElements];
02292 }
02293
02294 static void delete_TBRIK(void *p) {
02295 delete ((::TBRIK*)p);
02296 }
02297 static void deleteArray_TBRIK(void *p) {
02298 delete [] ((::TBRIK*)p);
02299 }
02300 static void destruct_TBRIK(void *p) {
02301 typedef ::TBRIK current_t;
02302 ((current_t*)p)->~current_t();
02303 }
02304 }
02305
02306
02307 void TCONE::Streamer(TBuffer &R__b)
02308 {
02309
02310
02311 if (R__b.IsReading()) {
02312 R__b.ReadClassBuffer(TCONE::Class(),this);
02313 } else {
02314 R__b.WriteClassBuffer(TCONE::Class(),this);
02315 }
02316 }
02317
02318
02319 void TCONE::ShowMembers(TMemberInspector &R__insp)
02320 {
02321
02322 TClass *R__cl = ::TCONE::IsA();
02323 if (R__cl || R__insp.IsA()) { }
02324 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin2", &fRmin2);
02325 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax2", &fRmax2);
02326 TTUBE::ShowMembers(R__insp);
02327 }
02328
02329 namespace ROOT {
02330
02331 static void *new_TCONE(void *p) {
02332 return p ? new(p) ::TCONE : new ::TCONE;
02333 }
02334 static void *newArray_TCONE(Long_t nElements, void *p) {
02335 return p ? new(p) ::TCONE[nElements] : new ::TCONE[nElements];
02336 }
02337
02338 static void delete_TCONE(void *p) {
02339 delete ((::TCONE*)p);
02340 }
02341 static void deleteArray_TCONE(void *p) {
02342 delete [] ((::TCONE*)p);
02343 }
02344 static void destruct_TCONE(void *p) {
02345 typedef ::TCONE current_t;
02346 ((current_t*)p)->~current_t();
02347 }
02348 }
02349
02350
02351 void TCONS::Streamer(TBuffer &R__b)
02352 {
02353
02354
02355 if (R__b.IsReading()) {
02356 R__b.ReadClassBuffer(TCONS::Class(),this);
02357 } else {
02358 R__b.WriteClassBuffer(TCONS::Class(),this);
02359 }
02360 }
02361
02362
02363 void TCONS::ShowMembers(TMemberInspector &R__insp)
02364 {
02365
02366 TClass *R__cl = ::TCONS::IsA();
02367 if (R__cl || R__insp.IsA()) { }
02368 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin2", &fRmin2);
02369 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax2", &fRmax2);
02370 TTUBS::ShowMembers(R__insp);
02371 }
02372
02373 namespace ROOT {
02374
02375 static void *new_TCONS(void *p) {
02376 return p ? new(p) ::TCONS : new ::TCONS;
02377 }
02378 static void *newArray_TCONS(Long_t nElements, void *p) {
02379 return p ? new(p) ::TCONS[nElements] : new ::TCONS[nElements];
02380 }
02381
02382 static void delete_TCONS(void *p) {
02383 delete ((::TCONS*)p);
02384 }
02385 static void deleteArray_TCONS(void *p) {
02386 delete [] ((::TCONS*)p);
02387 }
02388 static void destruct_TCONS(void *p) {
02389 typedef ::TCONS current_t;
02390 ((current_t*)p)->~current_t();
02391 }
02392 }
02393
02394
02395 void TCTUB::ShowMembers(TMemberInspector &R__insp)
02396 {
02397
02398 TClass *R__cl = ::TCTUB::IsA();
02399 if (R__cl || R__insp.IsA()) { }
02400 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosLow[3]", fCosLow);
02401 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosHigh[3]", fCosHigh);
02402 TTUBS::ShowMembers(R__insp);
02403 }
02404
02405 namespace ROOT {
02406
02407 static void *new_TCTUB(void *p) {
02408 return p ? new(p) ::TCTUB : new ::TCTUB;
02409 }
02410 static void *newArray_TCTUB(Long_t nElements, void *p) {
02411 return p ? new(p) ::TCTUB[nElements] : new ::TCTUB[nElements];
02412 }
02413
02414 static void delete_TCTUB(void *p) {
02415 delete ((::TCTUB*)p);
02416 }
02417 static void deleteArray_TCTUB(void *p) {
02418 delete [] ((::TCTUB*)p);
02419 }
02420 static void destruct_TCTUB(void *p) {
02421 typedef ::TCTUB current_t;
02422 ((current_t*)p)->~current_t();
02423 }
02424
02425 static void streamer_TCTUB(TBuffer &buf, void *obj) {
02426 ((::TCTUB*)obj)->::TCTUB::Streamer(buf);
02427 }
02428 }
02429
02430
02431 void TELTU::Streamer(TBuffer &R__b)
02432 {
02433
02434
02435 if (R__b.IsReading()) {
02436 R__b.ReadClassBuffer(TELTU::Class(),this);
02437 } else {
02438 R__b.WriteClassBuffer(TELTU::Class(),this);
02439 }
02440 }
02441
02442
02443 void TELTU::ShowMembers(TMemberInspector &R__insp)
02444 {
02445
02446 TClass *R__cl = ::TELTU::IsA();
02447 if (R__cl || R__insp.IsA()) { }
02448 TTUBE::ShowMembers(R__insp);
02449 }
02450
02451 namespace ROOT {
02452
02453 static void *new_TELTU(void *p) {
02454 return p ? new(p) ::TELTU : new ::TELTU;
02455 }
02456 static void *newArray_TELTU(Long_t nElements, void *p) {
02457 return p ? new(p) ::TELTU[nElements] : new ::TELTU[nElements];
02458 }
02459
02460 static void delete_TELTU(void *p) {
02461 delete ((::TELTU*)p);
02462 }
02463 static void deleteArray_TELTU(void *p) {
02464 delete [] ((::TELTU*)p);
02465 }
02466 static void destruct_TELTU(void *p) {
02467 typedef ::TELTU current_t;
02468 ((current_t*)p)->~current_t();
02469 }
02470 }
02471
02472
02473 void TGTRA::Streamer(TBuffer &R__b)
02474 {
02475
02476
02477 if (R__b.IsReading()) {
02478 R__b.ReadClassBuffer(TGTRA::Class(),this);
02479 } else {
02480 R__b.WriteClassBuffer(TGTRA::Class(),this);
02481 }
02482 }
02483
02484
02485 void TGTRA::ShowMembers(TMemberInspector &R__insp)
02486 {
02487
02488 TClass *R__cl = ::TGTRA::IsA();
02489 if (R__cl || R__insp.IsA()) { }
02490 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTwist", &fTwist);
02491 R__insp.Inspect(R__cl, R__insp.GetParent(), "fH1", &fH1);
02492 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl1", &fBl1);
02493 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl1", &fTl1);
02494 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha1", &fAlpha1);
02495 R__insp.Inspect(R__cl, R__insp.GetParent(), "fH2", &fH2);
02496 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl2", &fBl2);
02497 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl2", &fTl2);
02498 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha2", &fAlpha2);
02499 TBRIK::ShowMembers(R__insp);
02500 }
02501
02502 namespace ROOT {
02503
02504 static void *new_TGTRA(void *p) {
02505 return p ? new(p) ::TGTRA : new ::TGTRA;
02506 }
02507 static void *newArray_TGTRA(Long_t nElements, void *p) {
02508 return p ? new(p) ::TGTRA[nElements] : new ::TGTRA[nElements];
02509 }
02510
02511 static void delete_TGTRA(void *p) {
02512 delete ((::TGTRA*)p);
02513 }
02514 static void deleteArray_TGTRA(void *p) {
02515 delete [] ((::TGTRA*)p);
02516 }
02517 static void destruct_TGTRA(void *p) {
02518 typedef ::TGTRA current_t;
02519 ((current_t*)p)->~current_t();
02520 }
02521 }
02522
02523
02524 void TGeometry::ShowMembers(TMemberInspector &R__insp)
02525 {
02526
02527 TClass *R__cl = ::TGeometry::IsA();
02528 if (R__cl || R__insp.IsA()) { }
02529 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterials", &fMaterials);
02530 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrices", &fMatrices);
02531 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapes", &fShapes);
02532 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
02533 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
02534 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentNode", &fCurrentNode);
02535 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialPointer", &fMaterialPointer);
02536 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixPointer", &fMatrixPointer);
02537 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapePointer", &fShapePointer);
02538 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBomb", &fBomb);
02539 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGeomLevel", &fGeomLevel);
02540 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
02541 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
02542 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
02543 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTranslation[20][3]", fTranslation);
02544 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRotMatrix[20][9]", fRotMatrix);
02545 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsReflection[20]", fIsReflection);
02546 TNamed::ShowMembers(R__insp);
02547 }
02548
02549 namespace ROOT {
02550
02551 static void *new_TGeometry(void *p) {
02552 return p ? new(p) ::TGeometry : new ::TGeometry;
02553 }
02554 static void *newArray_TGeometry(Long_t nElements, void *p) {
02555 return p ? new(p) ::TGeometry[nElements] : new ::TGeometry[nElements];
02556 }
02557
02558 static void delete_TGeometry(void *p) {
02559 delete ((::TGeometry*)p);
02560 }
02561 static void deleteArray_TGeometry(void *p) {
02562 delete [] ((::TGeometry*)p);
02563 }
02564 static void destruct_TGeometry(void *p) {
02565 typedef ::TGeometry current_t;
02566 ((current_t*)p)->~current_t();
02567 }
02568
02569 static void streamer_TGeometry(TBuffer &buf, void *obj) {
02570 ((::TGeometry*)obj)->::TGeometry::Streamer(buf);
02571 }
02572 }
02573
02574
02575 void THelix::ShowMembers(TMemberInspector &R__insp)
02576 {
02577
02578 TClass *R__cl = ::THelix::IsA();
02579 if (R__cl || R__insp.IsA()) { }
02580 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &fX0);
02581 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY0", &fY0);
02582 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ0", &fZ0);
02583 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVt", &fVt);
02584 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi0", &fPhi0);
02585 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVz", &fVz);
02586 R__insp.Inspect(R__cl, R__insp.GetParent(), "fW", &fW);
02587 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis[3]", fAxis);
02588 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotMat", &fRotMat);
02589 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRange[2]", fRange);
02590 TPolyLine3D::ShowMembers(R__insp);
02591 }
02592
02593 namespace ROOT {
02594
02595 static void *new_THelix(void *p) {
02596 return p ? new(p) ::THelix : new ::THelix;
02597 }
02598 static void *newArray_THelix(Long_t nElements, void *p) {
02599 return p ? new(p) ::THelix[nElements] : new ::THelix[nElements];
02600 }
02601
02602 static void delete_THelix(void *p) {
02603 delete ((::THelix*)p);
02604 }
02605 static void deleteArray_THelix(void *p) {
02606 delete [] ((::THelix*)p);
02607 }
02608 static void destruct_THelix(void *p) {
02609 typedef ::THelix current_t;
02610 ((current_t*)p)->~current_t();
02611 }
02612
02613 static void streamer_THelix(TBuffer &buf, void *obj) {
02614 ((::THelix*)obj)->::THelix::Streamer(buf);
02615 }
02616 }
02617
02618
02619 void THYPE::Streamer(TBuffer &R__b)
02620 {
02621
02622
02623 if (R__b.IsReading()) {
02624 R__b.ReadClassBuffer(THYPE::Class(),this);
02625 } else {
02626 R__b.WriteClassBuffer(THYPE::Class(),this);
02627 }
02628 }
02629
02630
02631 void THYPE::ShowMembers(TMemberInspector &R__insp)
02632 {
02633
02634 TClass *R__cl = ::THYPE::IsA();
02635 if (R__cl || R__insp.IsA()) { }
02636 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
02637 TTUBE::ShowMembers(R__insp);
02638 }
02639
02640 namespace ROOT {
02641
02642 static void *new_THYPE(void *p) {
02643 return p ? new(p) ::THYPE : new ::THYPE;
02644 }
02645 static void *newArray_THYPE(Long_t nElements, void *p) {
02646 return p ? new(p) ::THYPE[nElements] : new ::THYPE[nElements];
02647 }
02648
02649 static void delete_THYPE(void *p) {
02650 delete ((::THYPE*)p);
02651 }
02652 static void deleteArray_THYPE(void *p) {
02653 delete [] ((::THYPE*)p);
02654 }
02655 static void destruct_THYPE(void *p) {
02656 typedef ::THYPE current_t;
02657 ((current_t*)p)->~current_t();
02658 }
02659 }
02660
02661
02662 void TMaterial::ShowMembers(TMemberInspector &R__insp)
02663 {
02664
02665 TClass *R__cl = ::TMaterial::IsA();
02666 if (R__cl || R__insp.IsA()) { }
02667 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
02668 R__insp.Inspect(R__cl, R__insp.GetParent(), "fA", &fA);
02669 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
02670 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDensity", &fDensity);
02671 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadLength", &fRadLength);
02672 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterLength", &fInterLength);
02673 TNamed::ShowMembers(R__insp);
02674 TAttFill::ShowMembers(R__insp);
02675 }
02676
02677 namespace ROOT {
02678
02679 static void *new_TMaterial(void *p) {
02680 return p ? new(p) ::TMaterial : new ::TMaterial;
02681 }
02682 static void *newArray_TMaterial(Long_t nElements, void *p) {
02683 return p ? new(p) ::TMaterial[nElements] : new ::TMaterial[nElements];
02684 }
02685
02686 static void delete_TMaterial(void *p) {
02687 delete ((::TMaterial*)p);
02688 }
02689 static void deleteArray_TMaterial(void *p) {
02690 delete [] ((::TMaterial*)p);
02691 }
02692 static void destruct_TMaterial(void *p) {
02693 typedef ::TMaterial current_t;
02694 ((current_t*)p)->~current_t();
02695 }
02696
02697 static void streamer_TMaterial(TBuffer &buf, void *obj) {
02698 ((::TMaterial*)obj)->::TMaterial::Streamer(buf);
02699 }
02700 }
02701
02702
02703 void TMixture::ShowMembers(TMemberInspector &R__insp)
02704 {
02705
02706 TClass *R__cl = ::TMixture::IsA();
02707 if (R__cl || R__insp.IsA()) { }
02708 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmixt", &fNmixt);
02709 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAmixt", &fAmixt);
02710 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZmixt", &fZmixt);
02711 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWmixt", &fWmixt);
02712 TMaterial::ShowMembers(R__insp);
02713 }
02714
02715 namespace ROOT {
02716
02717 static void *new_TMixture(void *p) {
02718 return p ? new(p) ::TMixture : new ::TMixture;
02719 }
02720 static void *newArray_TMixture(Long_t nElements, void *p) {
02721 return p ? new(p) ::TMixture[nElements] : new ::TMixture[nElements];
02722 }
02723
02724 static void delete_TMixture(void *p) {
02725 delete ((::TMixture*)p);
02726 }
02727 static void deleteArray_TMixture(void *p) {
02728 delete [] ((::TMixture*)p);
02729 }
02730 static void destruct_TMixture(void *p) {
02731 typedef ::TMixture current_t;
02732 ((current_t*)p)->~current_t();
02733 }
02734
02735 static void streamer_TMixture(TBuffer &buf, void *obj) {
02736 ((::TMixture*)obj)->::TMixture::Streamer(buf);
02737 }
02738 }
02739
02740
02741 void TNode::ShowMembers(TMemberInspector &R__insp)
02742 {
02743
02744 TClass *R__cl = ::TNode::IsA();
02745 if (R__cl || R__insp.IsA()) { }
02746 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
02747 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
02748 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
02749 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
02750 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02751 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
02752 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
02753 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
02754 R__insp.InspectMember(fOption, "fOption.");
02755 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisibility", &fVisibility);
02756 TNamed::ShowMembers(R__insp);
02757 TAttLine::ShowMembers(R__insp);
02758 TAttFill::ShowMembers(R__insp);
02759 TAtt3D::ShowMembers(R__insp);
02760 }
02761
02762 namespace ROOT {
02763
02764 static void *new_TNode(void *p) {
02765 return p ? new(p) ::TNode : new ::TNode;
02766 }
02767 static void *newArray_TNode(Long_t nElements, void *p) {
02768 return p ? new(p) ::TNode[nElements] : new ::TNode[nElements];
02769 }
02770
02771 static void delete_TNode(void *p) {
02772 delete ((::TNode*)p);
02773 }
02774 static void deleteArray_TNode(void *p) {
02775 delete [] ((::TNode*)p);
02776 }
02777 static void destruct_TNode(void *p) {
02778 typedef ::TNode current_t;
02779 ((current_t*)p)->~current_t();
02780 }
02781
02782 static void streamer_TNode(TBuffer &buf, void *obj) {
02783 ((::TNode*)obj)->::TNode::Streamer(buf);
02784 }
02785 }
02786
02787
02788 void TNodeDiv::Streamer(TBuffer &R__b)
02789 {
02790
02791
02792 if (R__b.IsReading()) {
02793 R__b.ReadClassBuffer(TNodeDiv::Class(),this);
02794 } else {
02795 R__b.WriteClassBuffer(TNodeDiv::Class(),this);
02796 }
02797 }
02798
02799
02800 void TNodeDiv::ShowMembers(TMemberInspector &R__insp)
02801 {
02802
02803 TClass *R__cl = ::TNodeDiv::IsA();
02804 if (R__cl || R__insp.IsA()) { }
02805 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiv", &fNdiv);
02806 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis", &fAxis);
02807 TNode::ShowMembers(R__insp);
02808 }
02809
02810 namespace ROOT {
02811
02812 static void *new_TNodeDiv(void *p) {
02813 return p ? new(p) ::TNodeDiv : new ::TNodeDiv;
02814 }
02815 static void *newArray_TNodeDiv(Long_t nElements, void *p) {
02816 return p ? new(p) ::TNodeDiv[nElements] : new ::TNodeDiv[nElements];
02817 }
02818
02819 static void delete_TNodeDiv(void *p) {
02820 delete ((::TNodeDiv*)p);
02821 }
02822 static void deleteArray_TNodeDiv(void *p) {
02823 delete [] ((::TNodeDiv*)p);
02824 }
02825 static void destruct_TNodeDiv(void *p) {
02826 typedef ::TNodeDiv current_t;
02827 ((current_t*)p)->~current_t();
02828 }
02829 }
02830
02831
02832 void TPARA::Streamer(TBuffer &R__b)
02833 {
02834
02835
02836 if (R__b.IsReading()) {
02837 R__b.ReadClassBuffer(TPARA::Class(),this);
02838 } else {
02839 R__b.WriteClassBuffer(TPARA::Class(),this);
02840 }
02841 }
02842
02843
02844 void TPARA::ShowMembers(TMemberInspector &R__insp)
02845 {
02846
02847 TClass *R__cl = ::TPARA::IsA();
02848 if (R__cl || R__insp.IsA()) { }
02849 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &fAlpha);
02850 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
02851 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
02852 TBRIK::ShowMembers(R__insp);
02853 }
02854
02855 namespace ROOT {
02856
02857 static void *new_TPARA(void *p) {
02858 return p ? new(p) ::TPARA : new ::TPARA;
02859 }
02860 static void *newArray_TPARA(Long_t nElements, void *p) {
02861 return p ? new(p) ::TPARA[nElements] : new ::TPARA[nElements];
02862 }
02863
02864 static void delete_TPARA(void *p) {
02865 delete ((::TPARA*)p);
02866 }
02867 static void deleteArray_TPARA(void *p) {
02868 delete [] ((::TPARA*)p);
02869 }
02870 static void destruct_TPARA(void *p) {
02871 typedef ::TPARA current_t;
02872 ((current_t*)p)->~current_t();
02873 }
02874 }
02875
02876
02877 void TPCON::ShowMembers(TMemberInspector &R__insp)
02878 {
02879
02880 TClass *R__cl = ::TPCON::IsA();
02881 if (R__cl || R__insp.IsA()) { }
02882 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSiTab", &fSiTab);
02883 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoTab", &fCoTab);
02884 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1", &fPhi1);
02885 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDphi1", &fDphi1);
02886 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiv", &fNdiv);
02887 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
02888 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmin", &fRmin);
02889 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmax", &fRmax);
02890 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDz", &fDz);
02891 TShape::ShowMembers(R__insp);
02892 }
02893
02894 namespace ROOT {
02895
02896 static void *new_TPCON(void *p) {
02897 return p ? new(p) ::TPCON : new ::TPCON;
02898 }
02899 static void *newArray_TPCON(Long_t nElements, void *p) {
02900 return p ? new(p) ::TPCON[nElements] : new ::TPCON[nElements];
02901 }
02902
02903 static void delete_TPCON(void *p) {
02904 delete ((::TPCON*)p);
02905 }
02906 static void deleteArray_TPCON(void *p) {
02907 delete [] ((::TPCON*)p);
02908 }
02909 static void destruct_TPCON(void *p) {
02910 typedef ::TPCON current_t;
02911 ((current_t*)p)->~current_t();
02912 }
02913
02914 static void streamer_TPCON(TBuffer &buf, void *obj) {
02915 ((::TPCON*)obj)->::TPCON::Streamer(buf);
02916 }
02917 }
02918
02919
02920 void TPGON::Streamer(TBuffer &R__b)
02921 {
02922
02923
02924 if (R__b.IsReading()) {
02925 R__b.ReadClassBuffer(TPGON::Class(),this);
02926 } else {
02927 R__b.WriteClassBuffer(TPGON::Class(),this);
02928 }
02929 }
02930
02931
02932 void TPGON::ShowMembers(TMemberInspector &R__insp)
02933 {
02934
02935 TClass *R__cl = ::TPGON::IsA();
02936 if (R__cl || R__insp.IsA()) { }
02937 TPCON::ShowMembers(R__insp);
02938 }
02939
02940 namespace ROOT {
02941
02942 static void *new_TPGON(void *p) {
02943 return p ? new(p) ::TPGON : new ::TPGON;
02944 }
02945 static void *newArray_TPGON(Long_t nElements, void *p) {
02946 return p ? new(p) ::TPGON[nElements] : new ::TPGON[nElements];
02947 }
02948
02949 static void delete_TPGON(void *p) {
02950 delete ((::TPGON*)p);
02951 }
02952 static void deleteArray_TPGON(void *p) {
02953 delete [] ((::TPGON*)p);
02954 }
02955 static void destruct_TPGON(void *p) {
02956 typedef ::TPGON current_t;
02957 ((current_t*)p)->~current_t();
02958 }
02959 }
02960
02961
02962 void TPolyLine3D::ShowMembers(TMemberInspector &R__insp)
02963 {
02964
02965 TClass *R__cl = ::TPolyLine3D::IsA();
02966 if (R__cl || R__insp.IsA()) { }
02967 R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
02968 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fP", &fP);
02969 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
02970 R__insp.InspectMember(fOption, "fOption.");
02971 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPoint", &fLastPoint);
02972 TObject::ShowMembers(R__insp);
02973 TAttLine::ShowMembers(R__insp);
02974 TAtt3D::ShowMembers(R__insp);
02975 }
02976
02977 namespace ROOT {
02978
02979 static void *new_TPolyLine3D(void *p) {
02980 return p ? new(p) ::TPolyLine3D : new ::TPolyLine3D;
02981 }
02982 static void *newArray_TPolyLine3D(Long_t nElements, void *p) {
02983 return p ? new(p) ::TPolyLine3D[nElements] : new ::TPolyLine3D[nElements];
02984 }
02985
02986 static void delete_TPolyLine3D(void *p) {
02987 delete ((::TPolyLine3D*)p);
02988 }
02989 static void deleteArray_TPolyLine3D(void *p) {
02990 delete [] ((::TPolyLine3D*)p);
02991 }
02992 static void destruct_TPolyLine3D(void *p) {
02993 typedef ::TPolyLine3D current_t;
02994 ((current_t*)p)->~current_t();
02995 }
02996
02997 static void streamer_TPolyLine3D(TBuffer &buf, void *obj) {
02998 ((::TPolyLine3D*)obj)->::TPolyLine3D::Streamer(buf);
02999 }
03000 }
03001
03002
03003 void TPolyMarker3D::ShowMembers(TMemberInspector &R__insp)
03004 {
03005
03006 TClass *R__cl = ::TPolyMarker3D::IsA();
03007 if (R__cl || R__insp.IsA()) { }
03008 R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
03009 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fP", &fP);
03010 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
03011 R__insp.InspectMember(fOption, "fOption.");
03012 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPoint", &fLastPoint);
03013 R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
03014 R__insp.InspectMember(fName, "fName.");
03015 TObject::ShowMembers(R__insp);
03016 TAttMarker::ShowMembers(R__insp);
03017 TAtt3D::ShowMembers(R__insp);
03018 }
03019
03020 namespace ROOT {
03021
03022 static void *new_TPolyMarker3D(void *p) {
03023 return p ? new(p) ::TPolyMarker3D : new ::TPolyMarker3D;
03024 }
03025 static void *newArray_TPolyMarker3D(Long_t nElements, void *p) {
03026 return p ? new(p) ::TPolyMarker3D[nElements] : new ::TPolyMarker3D[nElements];
03027 }
03028
03029 static void delete_TPolyMarker3D(void *p) {
03030 delete ((::TPolyMarker3D*)p);
03031 }
03032 static void deleteArray_TPolyMarker3D(void *p) {
03033 delete [] ((::TPolyMarker3D*)p);
03034 }
03035 static void destruct_TPolyMarker3D(void *p) {
03036 typedef ::TPolyMarker3D current_t;
03037 ((current_t*)p)->~current_t();
03038 }
03039
03040 static void streamer_TPolyMarker3D(TBuffer &buf, void *obj) {
03041 ((::TPolyMarker3D*)obj)->::TPolyMarker3D::Streamer(buf);
03042 }
03043 }
03044
03045
03046 void TPointSet3D::ShowMembers(TMemberInspector &R__insp)
03047 {
03048
03049 TClass *R__cl = ::TPointSet3D::IsA();
03050 if (R__cl || R__insp.IsA()) { }
03051 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnIds", &fOwnIds);
03052 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIds", &fIds);
03053 R__insp.InspectMember(fIds, "fIds.");
03054 TPolyMarker3D::ShowMembers(R__insp);
03055 TAttBBox::ShowMembers(R__insp);
03056 }
03057
03058 namespace ROOT {
03059
03060 static void *new_TPointSet3D(void *p) {
03061 return p ? new(p) ::TPointSet3D : new ::TPointSet3D;
03062 }
03063 static void *newArray_TPointSet3D(Long_t nElements, void *p) {
03064 return p ? new(p) ::TPointSet3D[nElements] : new ::TPointSet3D[nElements];
03065 }
03066
03067 static void delete_TPointSet3D(void *p) {
03068 delete ((::TPointSet3D*)p);
03069 }
03070 static void deleteArray_TPointSet3D(void *p) {
03071 delete [] ((::TPointSet3D*)p);
03072 }
03073 static void destruct_TPointSet3D(void *p) {
03074 typedef ::TPointSet3D current_t;
03075 ((current_t*)p)->~current_t();
03076 }
03077
03078 static void streamer_TPointSet3D(TBuffer &buf, void *obj) {
03079 ((::TPointSet3D*)obj)->::TPointSet3D::Streamer(buf);
03080 }
03081 }
03082
03083
03084 void TRotMatrix::ShowMembers(TMemberInspector &R__insp)
03085 {
03086
03087 TClass *R__cl = ::TRotMatrix::IsA();
03088 if (R__cl || R__insp.IsA()) { }
03089 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
03090 R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
03091 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
03092 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
03093 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsi", &fPsi);
03094 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMatrix[9]", fMatrix);
03095 TNamed::ShowMembers(R__insp);
03096 }
03097
03098 namespace ROOT {
03099
03100 static void *new_TRotMatrix(void *p) {
03101 return p ? new(p) ::TRotMatrix : new ::TRotMatrix;
03102 }
03103 static void *newArray_TRotMatrix(Long_t nElements, void *p) {
03104 return p ? new(p) ::TRotMatrix[nElements] : new ::TRotMatrix[nElements];
03105 }
03106
03107 static void delete_TRotMatrix(void *p) {
03108 delete ((::TRotMatrix*)p);
03109 }
03110 static void deleteArray_TRotMatrix(void *p) {
03111 delete [] ((::TRotMatrix*)p);
03112 }
03113 static void destruct_TRotMatrix(void *p) {
03114 typedef ::TRotMatrix current_t;
03115 ((current_t*)p)->~current_t();
03116 }
03117
03118 static void streamer_TRotMatrix(TBuffer &buf, void *obj) {
03119 ((::TRotMatrix*)obj)->::TRotMatrix::Streamer(buf);
03120 }
03121 }
03122
03123
03124 void TShape::ShowMembers(TMemberInspector &R__insp)
03125 {
03126
03127 TClass *R__cl = ::TShape::IsA();
03128 if (R__cl || R__insp.IsA()) { }
03129 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
03130 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisibility", &fVisibility);
03131 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterial", &fMaterial);
03132 TNamed::ShowMembers(R__insp);
03133 TAttLine::ShowMembers(R__insp);
03134 TAttFill::ShowMembers(R__insp);
03135 TAtt3D::ShowMembers(R__insp);
03136 }
03137
03138 namespace ROOT {
03139
03140 static void *new_TShape(void *p) {
03141 return p ? new(p) ::TShape : new ::TShape;
03142 }
03143 static void *newArray_TShape(Long_t nElements, void *p) {
03144 return p ? new(p) ::TShape[nElements] : new ::TShape[nElements];
03145 }
03146
03147 static void delete_TShape(void *p) {
03148 delete ((::TShape*)p);
03149 }
03150 static void deleteArray_TShape(void *p) {
03151 delete [] ((::TShape*)p);
03152 }
03153 static void destruct_TShape(void *p) {
03154 typedef ::TShape current_t;
03155 ((current_t*)p)->~current_t();
03156 }
03157
03158 static void streamer_TShape(TBuffer &buf, void *obj) {
03159 ((::TShape*)obj)->::TShape::Streamer(buf);
03160 }
03161 }
03162
03163
03164 void TSPHE::ShowMembers(TMemberInspector &R__insp)
03165 {
03166
03167 TClass *R__cl = ::TSPHE::IsA();
03168 if (R__cl || R__insp.IsA()) { }
03169 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSiTab", &fSiTab);
03170 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoTab", &fCoTab);
03171 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoThetaTab", &fCoThetaTab);
03172 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiv", &fNdiv);
03173 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
03174 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAspectRatio", &fAspectRatio);
03175 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin", &fRmin);
03176 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax", &fRmax);
03177 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThemin", &fThemin);
03178 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThemax", &fThemax);
03179 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhimin", &fPhimin);
03180 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhimax", &fPhimax);
03181 R__insp.Inspect(R__cl, R__insp.GetParent(), "faX", &faX);
03182 R__insp.Inspect(R__cl, R__insp.GetParent(), "faY", &faY);
03183 R__insp.Inspect(R__cl, R__insp.GetParent(), "faZ", &faZ);
03184 TShape::ShowMembers(R__insp);
03185 }
03186
03187 namespace ROOT {
03188
03189 static void *new_TSPHE(void *p) {
03190 return p ? new(p) ::TSPHE : new ::TSPHE;
03191 }
03192 static void *newArray_TSPHE(Long_t nElements, void *p) {
03193 return p ? new(p) ::TSPHE[nElements] : new ::TSPHE[nElements];
03194 }
03195
03196 static void delete_TSPHE(void *p) {
03197 delete ((::TSPHE*)p);
03198 }
03199 static void deleteArray_TSPHE(void *p) {
03200 delete [] ((::TSPHE*)p);
03201 }
03202 static void destruct_TSPHE(void *p) {
03203 typedef ::TSPHE current_t;
03204 ((current_t*)p)->~current_t();
03205 }
03206
03207 static void streamer_TSPHE(TBuffer &buf, void *obj) {
03208 ((::TSPHE*)obj)->::TSPHE::Streamer(buf);
03209 }
03210 }
03211
03212
03213 void TTRAP::Streamer(TBuffer &R__b)
03214 {
03215
03216
03217 if (R__b.IsReading()) {
03218 R__b.ReadClassBuffer(TTRAP::Class(),this);
03219 } else {
03220 R__b.WriteClassBuffer(TTRAP::Class(),this);
03221 }
03222 }
03223
03224
03225 void TTRAP::ShowMembers(TMemberInspector &R__insp)
03226 {
03227
03228 TClass *R__cl = ::TTRAP::IsA();
03229 if (R__cl || R__insp.IsA()) { }
03230 R__insp.Inspect(R__cl, R__insp.GetParent(), "fH1", &fH1);
03231 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl1", &fBl1);
03232 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl1", &fTl1);
03233 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha1", &fAlpha1);
03234 R__insp.Inspect(R__cl, R__insp.GetParent(), "fH2", &fH2);
03235 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl2", &fBl2);
03236 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl2", &fTl2);
03237 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha2", &fAlpha2);
03238 TBRIK::ShowMembers(R__insp);
03239 }
03240
03241 namespace ROOT {
03242
03243 static void *new_TTRAP(void *p) {
03244 return p ? new(p) ::TTRAP : new ::TTRAP;
03245 }
03246 static void *newArray_TTRAP(Long_t nElements, void *p) {
03247 return p ? new(p) ::TTRAP[nElements] : new ::TTRAP[nElements];
03248 }
03249
03250 static void delete_TTRAP(void *p) {
03251 delete ((::TTRAP*)p);
03252 }
03253 static void deleteArray_TTRAP(void *p) {
03254 delete [] ((::TTRAP*)p);
03255 }
03256 static void destruct_TTRAP(void *p) {
03257 typedef ::TTRAP current_t;
03258 ((current_t*)p)->~current_t();
03259 }
03260 }
03261
03262
03263 void TTRD1::Streamer(TBuffer &R__b)
03264 {
03265
03266
03267 if (R__b.IsReading()) {
03268 R__b.ReadClassBuffer(TTRD1::Class(),this);
03269 } else {
03270 R__b.WriteClassBuffer(TTRD1::Class(),this);
03271 }
03272 }
03273
03274
03275 void TTRD1::ShowMembers(TMemberInspector &R__insp)
03276 {
03277
03278 TClass *R__cl = ::TTRD1::IsA();
03279 if (R__cl || R__insp.IsA()) { }
03280 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx2", &fDx2);
03281 TBRIK::ShowMembers(R__insp);
03282 }
03283
03284 namespace ROOT {
03285
03286 static void *new_TTRD1(void *p) {
03287 return p ? new(p) ::TTRD1 : new ::TTRD1;
03288 }
03289 static void *newArray_TTRD1(Long_t nElements, void *p) {
03290 return p ? new(p) ::TTRD1[nElements] : new ::TTRD1[nElements];
03291 }
03292
03293 static void delete_TTRD1(void *p) {
03294 delete ((::TTRD1*)p);
03295 }
03296 static void deleteArray_TTRD1(void *p) {
03297 delete [] ((::TTRD1*)p);
03298 }
03299 static void destruct_TTRD1(void *p) {
03300 typedef ::TTRD1 current_t;
03301 ((current_t*)p)->~current_t();
03302 }
03303 }
03304
03305
03306 void TTRD2::Streamer(TBuffer &R__b)
03307 {
03308
03309
03310 if (R__b.IsReading()) {
03311 R__b.ReadClassBuffer(TTRD2::Class(),this);
03312 } else {
03313 R__b.WriteClassBuffer(TTRD2::Class(),this);
03314 }
03315 }
03316
03317
03318 void TTRD2::ShowMembers(TMemberInspector &R__insp)
03319 {
03320
03321 TClass *R__cl = ::TTRD2::IsA();
03322 if (R__cl || R__insp.IsA()) { }
03323 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx2", &fDx2);
03324 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDy2", &fDy2);
03325 TBRIK::ShowMembers(R__insp);
03326 }
03327
03328 namespace ROOT {
03329
03330 static void *new_TTRD2(void *p) {
03331 return p ? new(p) ::TTRD2 : new ::TTRD2;
03332 }
03333 static void *newArray_TTRD2(Long_t nElements, void *p) {
03334 return p ? new(p) ::TTRD2[nElements] : new ::TTRD2[nElements];
03335 }
03336
03337 static void delete_TTRD2(void *p) {
03338 delete ((::TTRD2*)p);
03339 }
03340 static void deleteArray_TTRD2(void *p) {
03341 delete [] ((::TTRD2*)p);
03342 }
03343 static void destruct_TTRD2(void *p) {
03344 typedef ::TTRD2 current_t;
03345 ((current_t*)p)->~current_t();
03346 }
03347 }
03348
03349
03350 void TTUBE::ShowMembers(TMemberInspector &R__insp)
03351 {
03352
03353 TClass *R__cl = ::TTUBE::IsA();
03354 if (R__cl || R__insp.IsA()) { }
03355 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin", &fRmin);
03356 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax", &fRmax);
03357 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
03358 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiv", &fNdiv);
03359 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAspectRatio", &fAspectRatio);
03360 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSiTab", &fSiTab);
03361 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoTab", &fCoTab);
03362 TShape::ShowMembers(R__insp);
03363 }
03364
03365 namespace ROOT {
03366
03367 static void *new_TTUBE(void *p) {
03368 return p ? new(p) ::TTUBE : new ::TTUBE;
03369 }
03370 static void *newArray_TTUBE(Long_t nElements, void *p) {
03371 return p ? new(p) ::TTUBE[nElements] : new ::TTUBE[nElements];
03372 }
03373
03374 static void delete_TTUBE(void *p) {
03375 delete ((::TTUBE*)p);
03376 }
03377 static void deleteArray_TTUBE(void *p) {
03378 delete [] ((::TTUBE*)p);
03379 }
03380 static void destruct_TTUBE(void *p) {
03381 typedef ::TTUBE current_t;
03382 ((current_t*)p)->~current_t();
03383 }
03384
03385 static void streamer_TTUBE(TBuffer &buf, void *obj) {
03386 ((::TTUBE*)obj)->::TTUBE::Streamer(buf);
03387 }
03388 }
03389
03390
03391 void TTUBS::Streamer(TBuffer &R__b)
03392 {
03393
03394
03395 if (R__b.IsReading()) {
03396 R__b.ReadClassBuffer(TTUBS::Class(),this);
03397 } else {
03398 R__b.WriteClassBuffer(TTUBS::Class(),this);
03399 }
03400 }
03401
03402
03403 void TTUBS::ShowMembers(TMemberInspector &R__insp)
03404 {
03405
03406 TClass *R__cl = ::TTUBS::IsA();
03407 if (R__cl || R__insp.IsA()) { }
03408 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1", &fPhi1);
03409 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi2", &fPhi2);
03410 TTUBE::ShowMembers(R__insp);
03411 }
03412
03413 namespace ROOT {
03414
03415 static void *new_TTUBS(void *p) {
03416 return p ? new(p) ::TTUBS : new ::TTUBS;
03417 }
03418 static void *newArray_TTUBS(Long_t nElements, void *p) {
03419 return p ? new(p) ::TTUBS[nElements] : new ::TTUBS[nElements];
03420 }
03421
03422 static void delete_TTUBS(void *p) {
03423 delete ((::TTUBS*)p);
03424 }
03425 static void deleteArray_TTUBS(void *p) {
03426 delete [] ((::TTUBS*)p);
03427 }
03428 static void destruct_TTUBS(void *p) {
03429 typedef ::TTUBS current_t;
03430 ((current_t*)p)->~current_t();
03431 }
03432 }
03433
03434
03435 void TMarker3DBox::ShowMembers(TMemberInspector &R__insp)
03436 {
03437
03438 TClass *R__cl = ::TMarker3DBox::IsA();
03439 if (R__cl || R__insp.IsA()) { }
03440 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
03441 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
03442 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
03443 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx", &fDx);
03444 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDy", &fDy);
03445 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
03446 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
03447 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
03448 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefObject", &fRefObject);
03449 TObject::ShowMembers(R__insp);
03450 TAttLine::ShowMembers(R__insp);
03451 TAttFill::ShowMembers(R__insp);
03452 TAtt3D::ShowMembers(R__insp);
03453 }
03454
03455 namespace ROOT {
03456
03457 static void *new_TMarker3DBox(void *p) {
03458 return p ? new(p) ::TMarker3DBox : new ::TMarker3DBox;
03459 }
03460 static void *newArray_TMarker3DBox(Long_t nElements, void *p) {
03461 return p ? new(p) ::TMarker3DBox[nElements] : new ::TMarker3DBox[nElements];
03462 }
03463
03464 static void delete_TMarker3DBox(void *p) {
03465 delete ((::TMarker3DBox*)p);
03466 }
03467 static void deleteArray_TMarker3DBox(void *p) {
03468 delete [] ((::TMarker3DBox*)p);
03469 }
03470 static void destruct_TMarker3DBox(void *p) {
03471 typedef ::TMarker3DBox current_t;
03472 ((current_t*)p)->~current_t();
03473 }
03474
03475 static void streamer_TMarker3DBox(TBuffer &buf, void *obj) {
03476 ((::TMarker3DBox*)obj)->::TMarker3DBox::Streamer(buf);
03477 }
03478 }
03479
03480
03481 void TPoints3DABC::Streamer(TBuffer &R__b)
03482 {
03483
03484
03485 TObject::Streamer(R__b);
03486 }
03487
03488
03489 void TPoints3DABC::ShowMembers(TMemberInspector &R__insp)
03490 {
03491
03492 TClass *R__cl = ::TPoints3DABC::IsA();
03493 if (R__cl || R__insp.IsA()) { }
03494 TObject::ShowMembers(R__insp);
03495 }
03496
03497 namespace ROOT {
03498
03499 static void delete_TPoints3DABC(void *p) {
03500 delete ((::TPoints3DABC*)p);
03501 }
03502 static void deleteArray_TPoints3DABC(void *p) {
03503 delete [] ((::TPoints3DABC*)p);
03504 }
03505 static void destruct_TPoints3DABC(void *p) {
03506 typedef ::TPoints3DABC current_t;
03507 ((current_t*)p)->~current_t();
03508 }
03509
03510 static void streamer_TPoints3DABC(TBuffer &buf, void *obj) {
03511 ((::TPoints3DABC*)obj)->::TPoints3DABC::Streamer(buf);
03512 }
03513 }
03514
03515
03516 void TXTRU::Streamer(TBuffer &R__b)
03517 {
03518
03519
03520 if (R__b.IsReading()) {
03521 R__b.ReadClassBuffer(TXTRU::Class(),this);
03522 } else {
03523 R__b.WriteClassBuffer(TXTRU::Class(),this);
03524 }
03525 }
03526
03527
03528 void TXTRU::ShowMembers(TMemberInspector &R__insp)
03529 {
03530
03531 TClass *R__cl = ::TXTRU::IsA();
03532 if (R__cl || R__insp.IsA()) { }
03533 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNxy", &fNxy);
03534 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNxyAlloc", &fNxyAlloc);
03535 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
03536 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNzAlloc", &fNzAlloc);
03537 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXvtx", &fXvtx);
03538 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYvtx", &fYvtx);
03539 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZ", &fZ);
03540 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScale", &fScale);
03541 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX0", &fX0);
03542 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY0", &fY0);
03543 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolygonShape", &fPolygonShape);
03544 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZOrdering", &fZOrdering);
03545 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSplitConcave", &fSplitConcave);
03546 TShape::ShowMembers(R__insp);
03547 }
03548
03549 namespace ROOT {
03550
03551 static void *new_TXTRU(void *p) {
03552 return p ? new(p) ::TXTRU : new ::TXTRU;
03553 }
03554 static void *newArray_TXTRU(Long_t nElements, void *p) {
03555 return p ? new(p) ::TXTRU[nElements] : new ::TXTRU[nElements];
03556 }
03557
03558 static void delete_TXTRU(void *p) {
03559 delete ((::TXTRU*)p);
03560 }
03561 static void deleteArray_TXTRU(void *p) {
03562 delete [] ((::TXTRU*)p);
03563 }
03564 static void destruct_TXTRU(void *p) {
03565 typedef ::TXTRU current_t;
03566 ((current_t*)p)->~current_t();
03567 }
03568 }
03569
03570
03571 void TView3D::ShowMembers(TMemberInspector &R__insp)
03572 {
03573
03574 TClass *R__cl = ::TView3D::IsA();
03575 if (R__cl || R__insp.IsA()) { }
03576 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatitude", &fLatitude);
03577 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLongitude", &fLongitude);
03578 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsi", &fPsi);
03579 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDview", &fDview);
03580 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDproj", &fDproj);
03581 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpix", &fUpix);
03582 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVpix", &fVpix);
03583 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTN[16]", fTN);
03584 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTB[16]", fTB);
03585 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax[3]", fRmax);
03586 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin[3]", fRmin);
03587 R__insp.Inspect(R__cl, R__insp.GetParent(), "fUVcoord[4]", fUVcoord);
03588 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTnorm[16]", fTnorm);
03589 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTback[16]", fTback);
03590 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX1[3]", fX1);
03591 R__insp.Inspect(R__cl, R__insp.GetParent(), "fX2[3]", fX2);
03592 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY1[3]", fY1);
03593 R__insp.Inspect(R__cl, R__insp.GetParent(), "fY2[3]", fY2);
03594 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ1[3]", fZ1);
03595 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ2[3]", fZ2);
03596 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSystem", &fSystem);
03597 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutline", &fOutline);
03598 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultOutline", &fDefaultOutline);
03599 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoRange", &fAutoRange);
03600 R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanged", &fChanged);
03601 TView::ShowMembers(R__insp);
03602 }
03603
03604 namespace ROOT {
03605
03606 static void *new_TView3D(void *p) {
03607 return p ? new(p) ::TView3D : new ::TView3D;
03608 }
03609 static void *newArray_TView3D(Long_t nElements, void *p) {
03610 return p ? new(p) ::TView3D[nElements] : new ::TView3D[nElements];
03611 }
03612
03613 static void delete_TView3D(void *p) {
03614 delete ((::TView3D*)p);
03615 }
03616 static void deleteArray_TView3D(void *p) {
03617 delete [] ((::TView3D*)p);
03618 }
03619 static void destruct_TView3D(void *p) {
03620 typedef ::TView3D current_t;
03621 ((current_t*)p)->~current_t();
03622 }
03623
03624 static void streamer_TView3D(TBuffer &buf, void *obj) {
03625 ((::TView3D*)obj)->::TView3D::Streamer(buf);
03626 }
03627 }
03628
03629
03630
03631
03632
03633
03634
03635
03636 #ifdef G__MEMTEST
03637 #undef malloc
03638 #undef free
03639 #endif
03640
03641 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
03642 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
03643 #endif
03644
03645 extern "C" void G__cpp_reset_tagtableG__G3D();
03646
03647 extern "C" void G__set_cpp_environmentG__G3D() {
03648 G__add_compiledheader("TObject.h");
03649 G__add_compiledheader("TMemberInspector.h");
03650 G__add_compiledheader("TAxis3D.h");
03651 G__add_compiledheader("TBRIK.h");
03652 G__add_compiledheader("TCONE.h");
03653 G__add_compiledheader("TCONS.h");
03654 G__add_compiledheader("TCTUB.h");
03655 G__add_compiledheader("TELTU.h");
03656 G__add_compiledheader("TGeometry.h");
03657 G__add_compiledheader("TGTRA.h");
03658 G__add_compiledheader("THelix.h");
03659 G__add_compiledheader("THYPE.h");
03660 G__add_compiledheader("TMarker3DBox.h");
03661 G__add_compiledheader("TMaterial.h");
03662 G__add_compiledheader("TMixture.h");
03663 G__add_compiledheader("TNodeDiv.h");
03664 G__add_compiledheader("TNode.h");
03665 G__add_compiledheader("TPARA.h");
03666 G__add_compiledheader("TPCON.h");
03667 G__add_compiledheader("TPGON.h");
03668 G__add_compiledheader("TPoints3DABC.h");
03669 G__add_compiledheader("TPointSet3D.h");
03670 G__add_compiledheader("TPolyLine3D.h");
03671 G__add_compiledheader("TPolyMarker3D.h");
03672 G__add_compiledheader("TRotMatrix.h");
03673 G__add_compiledheader("TShape.h");
03674 G__add_compiledheader("TSPHE.h");
03675 G__add_compiledheader("TTRAP.h");
03676 G__add_compiledheader("TTRD1.h");
03677 G__add_compiledheader("TTRD2.h");
03678 G__add_compiledheader("TTUBE.h");
03679 G__add_compiledheader("TTUBS.h");
03680 G__add_compiledheader("TView3D.h");
03681 G__add_compiledheader("TXTRU.h");
03682 G__cpp_reset_tagtableG__G3D();
03683 }
03684 #include <new>
03685 extern "C" int G__cpp_dllrevG__G3D() { return(30051515); }
03686
03687
03688
03689
03690
03691
03692 static int G__G__G3D_120_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03693 {
03694 TAxis3D* p = NULL;
03695 char* gvp = (char*) G__getgvp();
03696 int n = G__getaryconstruct();
03697 if (n) {
03698 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03699 p = new TAxis3D[n];
03700 } else {
03701 p = new((void*) gvp) TAxis3D[n];
03702 }
03703 } else {
03704 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03705 p = new TAxis3D;
03706 } else {
03707 p = new((void*) gvp) TAxis3D;
03708 }
03709 }
03710 result7->obj.i = (long) p;
03711 result7->ref = (long) p;
03712 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TAxis3D));
03713 return(1 || funcname || hash || result7 || libp) ;
03714 }
03715
03716 static int G__G__G3D_120_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03717 {
03718 TAxis3D* p = NULL;
03719 char* gvp = (char*) G__getgvp();
03720
03721 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03722 p = new TAxis3D((Option_t*) G__int(libp->para[0]));
03723 } else {
03724 p = new((void*) gvp) TAxis3D((Option_t*) G__int(libp->para[0]));
03725 }
03726 result7->obj.i = (long) p;
03727 result7->ref = (long) p;
03728 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TAxis3D));
03729 return(1 || funcname || hash || result7 || libp) ;
03730 }
03731
03732 static int G__G__G3D_120_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03733 {
03734 TAxis3D* p = NULL;
03735 char* gvp = (char*) G__getgvp();
03736
03737 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03738 p = new TAxis3D(*(TAxis3D*) libp->para[0].ref);
03739 } else {
03740 p = new((void*) gvp) TAxis3D(*(TAxis3D*) libp->para[0].ref);
03741 }
03742 result7->obj.i = (long) p;
03743 result7->ref = (long) p;
03744 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TAxis3D));
03745 return(1 || funcname || hash || result7 || libp) ;
03746 }
03747
03748 static int G__G__G3D_120_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03749 {
03750 {
03751 const Bool_t& obj = ((TAxis3D*) G__getstructoffset())->StickyZoom();
03752 result7->ref = (long) (&obj);
03753 G__letint(result7, 'g', (long)obj);
03754 }
03755 return(1 || funcname || hash || result7 || libp) ;
03756 }
03757
03758 static int G__G__G3D_120_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03759 {
03760 {
03761 const Bool_t& obj = ((TAxis3D*) G__getstructoffset())->Zoom();
03762 result7->ref = (long) (&obj);
03763 G__letint(result7, 'g', (long)obj);
03764 }
03765 return(1 || funcname || hash || result7 || libp) ;
03766 }
03767
03768 static int G__G__G3D_120_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03769 {
03770 switch (libp->paran) {
03771 case 1:
03772 G__letint(result7, 105, (long) ((const TAxis3D*) G__getstructoffset())->GetNdivisions((Option_t*) G__int(libp->para[0])));
03773 break;
03774 case 0:
03775 G__letint(result7, 105, (long) ((const TAxis3D*) G__getstructoffset())->GetNdivisions());
03776 break;
03777 }
03778 return(1 || funcname || hash || result7 || libp) ;
03779 }
03780
03781 static int G__G__G3D_120_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03782 {
03783 switch (libp->paran) {
03784 case 1:
03785 G__letint(result7, 115, (long) ((const TAxis3D*) G__getstructoffset())->GetAxisColor((Option_t*) G__int(libp->para[0])));
03786 break;
03787 case 0:
03788 G__letint(result7, 115, (long) ((const TAxis3D*) G__getstructoffset())->GetAxisColor());
03789 break;
03790 }
03791 return(1 || funcname || hash || result7 || libp) ;
03792 }
03793
03794 static int G__G__G3D_120_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03795 {
03796 switch (libp->paran) {
03797 case 1:
03798 G__letint(result7, 115, (long) ((const TAxis3D*) G__getstructoffset())->GetLabelColor((Option_t*) G__int(libp->para[0])));
03799 break;
03800 case 0:
03801 G__letint(result7, 115, (long) ((const TAxis3D*) G__getstructoffset())->GetLabelColor());
03802 break;
03803 }
03804 return(1 || funcname || hash || result7 || libp) ;
03805 }
03806
03807 static int G__G__G3D_120_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03808 {
03809 switch (libp->paran) {
03810 case 1:
03811 G__letint(result7, 115, (long) ((const TAxis3D*) G__getstructoffset())->GetLabelFont((Option_t*) G__int(libp->para[0])));
03812 break;
03813 case 0:
03814 G__letint(result7, 115, (long) ((const TAxis3D*) G__getstructoffset())->GetLabelFont());
03815 break;
03816 }
03817 return(1 || funcname || hash || result7 || libp) ;
03818 }
03819
03820 static int G__G__G3D_120_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03821 {
03822 switch (libp->paran) {
03823 case 1:
03824 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetLabelOffset((Option_t*) G__int(libp->para[0])));
03825 break;
03826 case 0:
03827 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetLabelOffset());
03828 break;
03829 }
03830 return(1 || funcname || hash || result7 || libp) ;
03831 }
03832
03833 static int G__G__G3D_120_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03834 {
03835 switch (libp->paran) {
03836 case 1:
03837 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetLabelSize((Option_t*) G__int(libp->para[0])));
03838 break;
03839 case 0:
03840 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetLabelSize());
03841 break;
03842 }
03843 return(1 || funcname || hash || result7 || libp) ;
03844 }
03845
03846 static int G__G__G3D_120_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03847 {
03848 switch (libp->paran) {
03849 case 1:
03850 G__letint(result7, 85, (long) TAxis3D::GetPadAxis((TVirtualPad*) G__int(libp->para[0])));
03851 break;
03852 case 0:
03853 G__letint(result7, 85, (long) TAxis3D::GetPadAxis());
03854 break;
03855 }
03856 return(1 || funcname || hash || result7 || libp) ;
03857 }
03858
03859 static int G__G__G3D_120_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03860 {
03861 switch (libp->paran) {
03862 case 1:
03863 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetTitleOffset((Option_t*) G__int(libp->para[0])));
03864 break;
03865 case 0:
03866 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetTitleOffset());
03867 break;
03868 }
03869 return(1 || funcname || hash || result7 || libp) ;
03870 }
03871
03872 static int G__G__G3D_120_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03873 {
03874 switch (libp->paran) {
03875 case 1:
03876 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetTickLength((Option_t*) G__int(libp->para[0])));
03877 break;
03878 case 0:
03879 G__letdouble(result7, 102, (double) ((const TAxis3D*) G__getstructoffset())->GetTickLength());
03880 break;
03881 }
03882 return(1 || funcname || hash || result7 || libp) ;
03883 }
03884
03885 static int G__G__G3D_120_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03886 {
03887 ((TAxis3D*) G__getstructoffset())->GetCenter((Axis_t*) G__int(libp->para[0]));
03888 G__setnull(result7);
03889 return(1 || funcname || hash || result7 || libp) ;
03890 }
03891
03892 static int G__G__G3D_120_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03893 {
03894 ((TAxis3D*) G__getstructoffset())->GetLowEdge((Axis_t*) G__int(libp->para[0]));
03895 G__setnull(result7);
03896 return(1 || funcname || hash || result7 || libp) ;
03897 }
03898
03899 static int G__G__G3D_120_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03900 {
03901 G__letint(result7, 85, (long) ((TAxis3D*) G__getstructoffset())->GetXaxis());
03902 return(1 || funcname || hash || result7 || libp) ;
03903 }
03904
03905 static int G__G__G3D_120_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03906 {
03907 G__letint(result7, 85, (long) ((TAxis3D*) G__getstructoffset())->GetYaxis());
03908 return(1 || funcname || hash || result7 || libp) ;
03909 }
03910
03911 static int G__G__G3D_120_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03912 {
03913 G__letint(result7, 85, (long) ((TAxis3D*) G__getstructoffset())->GetZaxis());
03914 return(1 || funcname || hash || result7 || libp) ;
03915 }
03916
03917 static int G__G__G3D_120_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03918 {
03919 ((TAxis3D*) G__getstructoffset())->PaintAxis((TGaxis*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
03920 G__setnull(result7);
03921 return(1 || funcname || hash || result7 || libp) ;
03922 }
03923
03924 static int G__G__G3D_120_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03925 {
03926 switch (libp->paran) {
03927 case 4:
03928 G__letint(result7, 68, (long) TAxis3D::PixeltoXYZ((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
03929 , (Double_t*) G__int(libp->para[2]), (TView*) G__int(libp->para[3])));
03930 break;
03931 case 3:
03932 G__letint(result7, 68, (long) TAxis3D::PixeltoXYZ((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
03933 , (Double_t*) G__int(libp->para[2])));
03934 break;
03935 }
03936 return(1 || funcname || hash || result7 || libp) ;
03937 }
03938
03939 static int G__G__G3D_120_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03940 {
03941 switch (libp->paran) {
03942 case 2:
03943 ((TAxis3D*) G__getstructoffset())->SetAxisColor((Color_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
03944 G__setnull(result7);
03945 break;
03946 case 1:
03947 ((TAxis3D*) G__getstructoffset())->SetAxisColor((Color_t) G__int(libp->para[0]));
03948 G__setnull(result7);
03949 break;
03950 case 0:
03951 ((TAxis3D*) G__getstructoffset())->SetAxisColor();
03952 G__setnull(result7);
03953 break;
03954 }
03955 return(1 || funcname || hash || result7 || libp) ;
03956 }
03957
03958 static int G__G__G3D_120_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03959 {
03960 switch (libp->paran) {
03961 case 3:
03962 ((TAxis3D*) G__getstructoffset())->SetAxisRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
03963 , (Option_t*) G__int(libp->para[2]));
03964 G__setnull(result7);
03965 break;
03966 case 2:
03967 ((TAxis3D*) G__getstructoffset())->SetAxisRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
03968 G__setnull(result7);
03969 break;
03970 }
03971 return(1 || funcname || hash || result7 || libp) ;
03972 }
03973
03974 static int G__G__G3D_120_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03975 {
03976 switch (libp->paran) {
03977 case 2:
03978 ((TAxis3D*) G__getstructoffset())->SetLabelColor((Color_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
03979 G__setnull(result7);
03980 break;
03981 case 1:
03982 ((TAxis3D*) G__getstructoffset())->SetLabelColor((Color_t) G__int(libp->para[0]));
03983 G__setnull(result7);
03984 break;
03985 case 0:
03986 ((TAxis3D*) G__getstructoffset())->SetLabelColor();
03987 G__setnull(result7);
03988 break;
03989 }
03990 return(1 || funcname || hash || result7 || libp) ;
03991 }
03992
03993 static int G__G__G3D_120_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03994 {
03995 switch (libp->paran) {
03996 case 2:
03997 ((TAxis3D*) G__getstructoffset())->SetLabelFont((Style_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
03998 G__setnull(result7);
03999 break;
04000 case 1:
04001 ((TAxis3D*) G__getstructoffset())->SetLabelFont((Style_t) G__int(libp->para[0]));
04002 G__setnull(result7);
04003 break;
04004 case 0:
04005 ((TAxis3D*) G__getstructoffset())->SetLabelFont();
04006 G__setnull(result7);
04007 break;
04008 }
04009 return(1 || funcname || hash || result7 || libp) ;
04010 }
04011
04012 static int G__G__G3D_120_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04013 {
04014 switch (libp->paran) {
04015 case 2:
04016 ((TAxis3D*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
04017 G__setnull(result7);
04018 break;
04019 case 1:
04020 ((TAxis3D*) G__getstructoffset())->SetLabelOffset((Float_t) G__double(libp->para[0]));
04021 G__setnull(result7);
04022 break;
04023 case 0:
04024 ((TAxis3D*) G__getstructoffset())->SetLabelOffset();
04025 G__setnull(result7);
04026 break;
04027 }
04028 return(1 || funcname || hash || result7 || libp) ;
04029 }
04030
04031 static int G__G__G3D_120_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04032 {
04033 switch (libp->paran) {
04034 case 2:
04035 ((TAxis3D*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
04036 G__setnull(result7);
04037 break;
04038 case 1:
04039 ((TAxis3D*) G__getstructoffset())->SetLabelSize((Float_t) G__double(libp->para[0]));
04040 G__setnull(result7);
04041 break;
04042 case 0:
04043 ((TAxis3D*) G__getstructoffset())->SetLabelSize();
04044 G__setnull(result7);
04045 break;
04046 }
04047 return(1 || funcname || hash || result7 || libp) ;
04048 }
04049
04050 static int G__G__G3D_120_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04051 {
04052 switch (libp->paran) {
04053 case 2:
04054 ((TAxis3D*) G__getstructoffset())->SetNdivisions((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
04055 G__setnull(result7);
04056 break;
04057 case 1:
04058 ((TAxis3D*) G__getstructoffset())->SetNdivisions((Int_t) G__int(libp->para[0]));
04059 G__setnull(result7);
04060 break;
04061 case 0:
04062 ((TAxis3D*) G__getstructoffset())->SetNdivisions();
04063 G__setnull(result7);
04064 break;
04065 }
04066 return(1 || funcname || hash || result7 || libp) ;
04067 }
04068
04069 static int G__G__G3D_120_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04070 {
04071 switch (libp->paran) {
04072 case 1:
04073 ((TAxis3D*) G__getstructoffset())->SetOption((Option_t*) G__int(libp->para[0]));
04074 G__setnull(result7);
04075 break;
04076 case 0:
04077 ((TAxis3D*) G__getstructoffset())->SetOption();
04078 G__setnull(result7);
04079 break;
04080 }
04081 return(1 || funcname || hash || result7 || libp) ;
04082 }
04083
04084 static int G__G__G3D_120_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04085 {
04086 switch (libp->paran) {
04087 case 2:
04088 ((TAxis3D*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
04089 G__setnull(result7);
04090 break;
04091 case 1:
04092 ((TAxis3D*) G__getstructoffset())->SetTickLength((Float_t) G__double(libp->para[0]));
04093 G__setnull(result7);
04094 break;
04095 case 0:
04096 ((TAxis3D*) G__getstructoffset())->SetTickLength();
04097 G__setnull(result7);
04098 break;
04099 }
04100 return(1 || funcname || hash || result7 || libp) ;
04101 }
04102
04103 static int G__G__G3D_120_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04104 {
04105 switch (libp->paran) {
04106 case 2:
04107 ((TAxis3D*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
04108 G__setnull(result7);
04109 break;
04110 case 1:
04111 ((TAxis3D*) G__getstructoffset())->SetTitleOffset((Float_t) G__double(libp->para[0]));
04112 G__setnull(result7);
04113 break;
04114 case 0:
04115 ((TAxis3D*) G__getstructoffset())->SetTitleOffset();
04116 G__setnull(result7);
04117 break;
04118 }
04119 return(1 || funcname || hash || result7 || libp) ;
04120 }
04121
04122 static int G__G__G3D_120_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04123 {
04124 ((TAxis3D*) G__getstructoffset())->SetXTitle((const char*) G__int(libp->para[0]));
04125 G__setnull(result7);
04126 return(1 || funcname || hash || result7 || libp) ;
04127 }
04128
04129 static int G__G__G3D_120_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04130 {
04131 ((TAxis3D*) G__getstructoffset())->SetYTitle((const char*) G__int(libp->para[0]));
04132 G__setnull(result7);
04133 return(1 || funcname || hash || result7 || libp) ;
04134 }
04135
04136 static int G__G__G3D_120_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04137 {
04138 ((TAxis3D*) G__getstructoffset())->SetZTitle((const char*) G__int(libp->para[0]));
04139 G__setnull(result7);
04140 return(1 || funcname || hash || result7 || libp) ;
04141 }
04142
04143 static int G__G__G3D_120_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04144 {
04145 switch (libp->paran) {
04146 case 1:
04147 G__letint(result7, 85, (long) TAxis3D::ToggleRulers((TVirtualPad*) G__int(libp->para[0])));
04148 break;
04149 case 0:
04150 G__letint(result7, 85, (long) TAxis3D::ToggleRulers());
04151 break;
04152 }
04153 return(1 || funcname || hash || result7 || libp) ;
04154 }
04155
04156 static int G__G__G3D_120_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04157 {
04158 switch (libp->paran) {
04159 case 1:
04160 G__letint(result7, 85, (long) TAxis3D::ToggleZoom((TVirtualPad*) G__int(libp->para[0])));
04161 break;
04162 case 0:
04163 G__letint(result7, 85, (long) TAxis3D::ToggleZoom());
04164 break;
04165 }
04166 return(1 || funcname || hash || result7 || libp) ;
04167 }
04168
04169 static int G__G__G3D_120_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04170 {
04171 G__letint(result7, 85, (long) TAxis3D::Class());
04172 return(1 || funcname || hash || result7 || libp) ;
04173 }
04174
04175 static int G__G__G3D_120_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04176 {
04177 G__letint(result7, 67, (long) TAxis3D::Class_Name());
04178 return(1 || funcname || hash || result7 || libp) ;
04179 }
04180
04181 static int G__G__G3D_120_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04182 {
04183 G__letint(result7, 115, (long) TAxis3D::Class_Version());
04184 return(1 || funcname || hash || result7 || libp) ;
04185 }
04186
04187 static int G__G__G3D_120_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04188 {
04189 TAxis3D::Dictionary();
04190 G__setnull(result7);
04191 return(1 || funcname || hash || result7 || libp) ;
04192 }
04193
04194 static int G__G__G3D_120_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04195 {
04196 ((TAxis3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04197 G__setnull(result7);
04198 return(1 || funcname || hash || result7 || libp) ;
04199 }
04200
04201 static int G__G__G3D_120_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04202 {
04203 G__letint(result7, 67, (long) TAxis3D::DeclFileName());
04204 return(1 || funcname || hash || result7 || libp) ;
04205 }
04206
04207 static int G__G__G3D_120_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04208 {
04209 G__letint(result7, 105, (long) TAxis3D::ImplFileLine());
04210 return(1 || funcname || hash || result7 || libp) ;
04211 }
04212
04213 static int G__G__G3D_120_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04214 {
04215 G__letint(result7, 67, (long) TAxis3D::ImplFileName());
04216 return(1 || funcname || hash || result7 || libp) ;
04217 }
04218
04219 static int G__G__G3D_120_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04220 {
04221 G__letint(result7, 105, (long) TAxis3D::DeclFileLine());
04222 return(1 || funcname || hash || result7 || libp) ;
04223 }
04224
04225
04226 typedef TAxis3D G__TTAxis3D;
04227 static int G__G__G3D_120_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04228 {
04229 char* gvp = (char*) G__getgvp();
04230 long soff = G__getstructoffset();
04231 int n = G__getaryconstruct();
04232
04233
04234
04235
04236
04237 if (!soff) {
04238 return(1);
04239 }
04240 if (n) {
04241 if (gvp == (char*)G__PVOID) {
04242 delete[] (TAxis3D*) soff;
04243 } else {
04244 G__setgvp((long) G__PVOID);
04245 for (int i = n - 1; i >= 0; --i) {
04246 ((TAxis3D*) (soff+(sizeof(TAxis3D)*i)))->~G__TTAxis3D();
04247 }
04248 G__setgvp((long)gvp);
04249 }
04250 } else {
04251 if (gvp == (char*)G__PVOID) {
04252 delete (TAxis3D*) soff;
04253 } else {
04254 G__setgvp((long) G__PVOID);
04255 ((TAxis3D*) (soff))->~G__TTAxis3D();
04256 G__setgvp((long)gvp);
04257 }
04258 }
04259 G__setnull(result7);
04260 return(1 || funcname || hash || result7 || libp) ;
04261 }
04262
04263
04264
04265 static int G__G__G3D_122_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04266 {
04267 TMaterial* p = NULL;
04268 char* gvp = (char*) G__getgvp();
04269 int n = G__getaryconstruct();
04270 if (n) {
04271 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04272 p = new TMaterial[n];
04273 } else {
04274 p = new((void*) gvp) TMaterial[n];
04275 }
04276 } else {
04277 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04278 p = new TMaterial;
04279 } else {
04280 p = new((void*) gvp) TMaterial;
04281 }
04282 }
04283 result7->obj.i = (long) p;
04284 result7->ref = (long) p;
04285 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMaterial));
04286 return(1 || funcname || hash || result7 || libp) ;
04287 }
04288
04289 static int G__G__G3D_122_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04290 {
04291 TMaterial* p = NULL;
04292 char* gvp = (char*) G__getgvp();
04293
04294 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04295 p = new TMaterial(
04296 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04297 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
04298 , (Float_t) G__double(libp->para[4]));
04299 } else {
04300 p = new((void*) gvp) TMaterial(
04301 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04302 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
04303 , (Float_t) G__double(libp->para[4]));
04304 }
04305 result7->obj.i = (long) p;
04306 result7->ref = (long) p;
04307 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMaterial));
04308 return(1 || funcname || hash || result7 || libp) ;
04309 }
04310
04311 static int G__G__G3D_122_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04312 {
04313 TMaterial* p = NULL;
04314 char* gvp = (char*) G__getgvp();
04315
04316 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04317 p = new TMaterial(
04318 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04319 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
04320 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
04321 , (Float_t) G__double(libp->para[6]));
04322 } else {
04323 p = new((void*) gvp) TMaterial(
04324 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04325 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
04326 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
04327 , (Float_t) G__double(libp->para[6]));
04328 }
04329 result7->obj.i = (long) p;
04330 result7->ref = (long) p;
04331 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMaterial));
04332 return(1 || funcname || hash || result7 || libp) ;
04333 }
04334
04335 static int G__G__G3D_122_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04336 {
04337 G__letint(result7, 105, (long) ((const TMaterial*) G__getstructoffset())->GetNumber());
04338 return(1 || funcname || hash || result7 || libp) ;
04339 }
04340
04341 static int G__G__G3D_122_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04342 {
04343 G__letdouble(result7, 102, (double) ((const TMaterial*) G__getstructoffset())->GetA());
04344 return(1 || funcname || hash || result7 || libp) ;
04345 }
04346
04347 static int G__G__G3D_122_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04348 {
04349 G__letdouble(result7, 102, (double) ((const TMaterial*) G__getstructoffset())->GetZ());
04350 return(1 || funcname || hash || result7 || libp) ;
04351 }
04352
04353 static int G__G__G3D_122_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04354 {
04355 G__letdouble(result7, 102, (double) ((const TMaterial*) G__getstructoffset())->GetDensity());
04356 return(1 || funcname || hash || result7 || libp) ;
04357 }
04358
04359 static int G__G__G3D_122_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04360 {
04361 G__letdouble(result7, 102, (double) ((const TMaterial*) G__getstructoffset())->GetRadLength());
04362 return(1 || funcname || hash || result7 || libp) ;
04363 }
04364
04365 static int G__G__G3D_122_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04366 {
04367 G__letdouble(result7, 102, (double) ((const TMaterial*) G__getstructoffset())->GetInterLength());
04368 return(1 || funcname || hash || result7 || libp) ;
04369 }
04370
04371 static int G__G__G3D_122_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04372 {
04373 G__letint(result7, 85, (long) TMaterial::Class());
04374 return(1 || funcname || hash || result7 || libp) ;
04375 }
04376
04377 static int G__G__G3D_122_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04378 {
04379 G__letint(result7, 67, (long) TMaterial::Class_Name());
04380 return(1 || funcname || hash || result7 || libp) ;
04381 }
04382
04383 static int G__G__G3D_122_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04384 {
04385 G__letint(result7, 115, (long) TMaterial::Class_Version());
04386 return(1 || funcname || hash || result7 || libp) ;
04387 }
04388
04389 static int G__G__G3D_122_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04390 {
04391 TMaterial::Dictionary();
04392 G__setnull(result7);
04393 return(1 || funcname || hash || result7 || libp) ;
04394 }
04395
04396 static int G__G__G3D_122_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04397 {
04398 ((TMaterial*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04399 G__setnull(result7);
04400 return(1 || funcname || hash || result7 || libp) ;
04401 }
04402
04403 static int G__G__G3D_122_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04404 {
04405 G__letint(result7, 67, (long) TMaterial::DeclFileName());
04406 return(1 || funcname || hash || result7 || libp) ;
04407 }
04408
04409 static int G__G__G3D_122_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04410 {
04411 G__letint(result7, 105, (long) TMaterial::ImplFileLine());
04412 return(1 || funcname || hash || result7 || libp) ;
04413 }
04414
04415 static int G__G__G3D_122_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04416 {
04417 G__letint(result7, 67, (long) TMaterial::ImplFileName());
04418 return(1 || funcname || hash || result7 || libp) ;
04419 }
04420
04421 static int G__G__G3D_122_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04422 {
04423 G__letint(result7, 105, (long) TMaterial::DeclFileLine());
04424 return(1 || funcname || hash || result7 || libp) ;
04425 }
04426
04427
04428 static int G__G__G3D_122_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04429
04430 {
04431 TMaterial* p;
04432 void* tmp = (void*) G__int(libp->para[0]);
04433 p = new TMaterial(*(TMaterial*) tmp);
04434 result7->obj.i = (long) p;
04435 result7->ref = (long) p;
04436 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMaterial));
04437 return(1 || funcname || hash || result7 || libp) ;
04438 }
04439
04440
04441 typedef TMaterial G__TTMaterial;
04442 static int G__G__G3D_122_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04443 {
04444 char* gvp = (char*) G__getgvp();
04445 long soff = G__getstructoffset();
04446 int n = G__getaryconstruct();
04447
04448
04449
04450
04451
04452 if (!soff) {
04453 return(1);
04454 }
04455 if (n) {
04456 if (gvp == (char*)G__PVOID) {
04457 delete[] (TMaterial*) soff;
04458 } else {
04459 G__setgvp((long) G__PVOID);
04460 for (int i = n - 1; i >= 0; --i) {
04461 ((TMaterial*) (soff+(sizeof(TMaterial)*i)))->~G__TTMaterial();
04462 }
04463 G__setgvp((long)gvp);
04464 }
04465 } else {
04466 if (gvp == (char*)G__PVOID) {
04467 delete (TMaterial*) soff;
04468 } else {
04469 G__setgvp((long) G__PVOID);
04470 ((TMaterial*) (soff))->~G__TTMaterial();
04471 G__setgvp((long)gvp);
04472 }
04473 }
04474 G__setnull(result7);
04475 return(1 || funcname || hash || result7 || libp) ;
04476 }
04477
04478
04479 static int G__G__G3D_122_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04480 {
04481 TMaterial* dest = (TMaterial*) G__getstructoffset();
04482 *dest = *(TMaterial*) libp->para[0].ref;
04483 const TMaterial& obj = *dest;
04484 result7->ref = (long) (&obj);
04485 result7->obj.i = (long) (&obj);
04486 return(1 || funcname || hash || result7 || libp) ;
04487 }
04488
04489
04490
04491 static int G__G__G3D_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04492 {
04493 TNode* p = NULL;
04494 char* gvp = (char*) G__getgvp();
04495 int n = G__getaryconstruct();
04496 if (n) {
04497 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04498 p = new TNode[n];
04499 } else {
04500 p = new((void*) gvp) TNode[n];
04501 }
04502 } else {
04503 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04504 p = new TNode;
04505 } else {
04506 p = new((void*) gvp) TNode;
04507 }
04508 }
04509 result7->obj.i = (long) p;
04510 result7->ref = (long) p;
04511 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNode));
04512 return(1 || funcname || hash || result7 || libp) ;
04513 }
04514
04515 static int G__G__G3D_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04516 {
04517 TNode* p = NULL;
04518 char* gvp = (char*) G__getgvp();
04519 switch (libp->paran) {
04520 case 8:
04521
04522 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04523 p = new TNode(
04524 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04525 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04526 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04527 , (const char*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
04528 } else {
04529 p = new((void*) gvp) TNode(
04530 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04531 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04532 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04533 , (const char*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
04534 }
04535 break;
04536 case 7:
04537
04538 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04539 p = new TNode(
04540 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04541 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04542 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04543 , (const char*) G__int(libp->para[6]));
04544 } else {
04545 p = new((void*) gvp) TNode(
04546 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04547 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04548 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04549 , (const char*) G__int(libp->para[6]));
04550 }
04551 break;
04552 case 6:
04553
04554 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04555 p = new TNode(
04556 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04557 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04558 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
04559 } else {
04560 p = new((void*) gvp) TNode(
04561 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04562 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04563 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
04564 }
04565 break;
04566 case 5:
04567
04568 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04569 p = new TNode(
04570 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04571 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04572 , (Double_t) G__double(libp->para[4]));
04573 } else {
04574 p = new((void*) gvp) TNode(
04575 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04576 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04577 , (Double_t) G__double(libp->para[4]));
04578 }
04579 break;
04580 case 4:
04581
04582 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04583 p = new TNode(
04584 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04585 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
04586 } else {
04587 p = new((void*) gvp) TNode(
04588 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04589 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
04590 }
04591 break;
04592 case 3:
04593
04594 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04595 p = new TNode(
04596 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04597 , (const char*) G__int(libp->para[2]));
04598 } else {
04599 p = new((void*) gvp) TNode(
04600 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04601 , (const char*) G__int(libp->para[2]));
04602 }
04603 break;
04604 }
04605 result7->obj.i = (long) p;
04606 result7->ref = (long) p;
04607 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNode));
04608 return(1 || funcname || hash || result7 || libp) ;
04609 }
04610
04611 static int G__G__G3D_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04612 {
04613 TNode* p = NULL;
04614 char* gvp = (char*) G__getgvp();
04615 switch (libp->paran) {
04616 case 8:
04617
04618 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04619 p = new TNode(
04620 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04621 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04622 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04623 , (TRotMatrix*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
04624 } else {
04625 p = new((void*) gvp) TNode(
04626 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04627 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04628 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04629 , (TRotMatrix*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
04630 }
04631 break;
04632 case 7:
04633
04634 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04635 p = new TNode(
04636 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04637 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04638 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04639 , (TRotMatrix*) G__int(libp->para[6]));
04640 } else {
04641 p = new((void*) gvp) TNode(
04642 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04643 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04644 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
04645 , (TRotMatrix*) G__int(libp->para[6]));
04646 }
04647 break;
04648 case 6:
04649
04650 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04651 p = new TNode(
04652 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04653 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04654 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
04655 } else {
04656 p = new((void*) gvp) TNode(
04657 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04658 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04659 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
04660 }
04661 break;
04662 case 5:
04663
04664 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04665 p = new TNode(
04666 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04667 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04668 , (Double_t) G__double(libp->para[4]));
04669 } else {
04670 p = new((void*) gvp) TNode(
04671 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04672 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
04673 , (Double_t) G__double(libp->para[4]));
04674 }
04675 break;
04676 case 4:
04677
04678 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04679 p = new TNode(
04680 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04681 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
04682 } else {
04683 p = new((void*) gvp) TNode(
04684 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04685 , (TShape*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
04686 }
04687 break;
04688 case 3:
04689
04690 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04691 p = new TNode(
04692 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04693 , (TShape*) G__int(libp->para[2]));
04694 } else {
04695 p = new((void*) gvp) TNode(
04696 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04697 , (TShape*) G__int(libp->para[2]));
04698 }
04699 break;
04700 }
04701 result7->obj.i = (long) p;
04702 result7->ref = (long) p;
04703 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNode));
04704 return(1 || funcname || hash || result7 || libp) ;
04705 }
04706
04707 static int G__G__G3D_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04708 {
04709 ((TNode*) G__getstructoffset())->BuildListOfNodes();
04710 G__setnull(result7);
04711 return(1 || funcname || hash || result7 || libp) ;
04712 }
04713
04714 static int G__G__G3D_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04715 {
04716 switch (libp->paran) {
04717 case 1:
04718 ((TNode*) G__getstructoffset())->cd((const char*) G__int(libp->para[0]));
04719 G__setnull(result7);
04720 break;
04721 case 0:
04722 ((TNode*) G__getstructoffset())->cd();
04723 G__setnull(result7);
04724 break;
04725 }
04726 return(1 || funcname || hash || result7 || libp) ;
04727 }
04728
04729 static int G__G__G3D_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04730 {
04731 switch (libp->paran) {
04732 case 1:
04733 ((TNode*) G__getstructoffset())->DrawOnly((Option_t*) G__int(libp->para[0]));
04734 G__setnull(result7);
04735 break;
04736 case 0:
04737 ((TNode*) G__getstructoffset())->DrawOnly();
04738 G__setnull(result7);
04739 break;
04740 }
04741 return(1 || funcname || hash || result7 || libp) ;
04742 }
04743
04744 static int G__G__G3D_129_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04745 {
04746 G__letint(result7, 85, (long) ((const TNode*) G__getstructoffset())->GetListOfNodes());
04747 return(1 || funcname || hash || result7 || libp) ;
04748 }
04749
04750 static int G__G__G3D_129_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04751 {
04752 G__letint(result7, 85, (long) ((const TNode*) G__getstructoffset())->GetMatrix());
04753 return(1 || funcname || hash || result7 || libp) ;
04754 }
04755
04756 static int G__G__G3D_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04757 {
04758 G__letint(result7, 85, (long) ((const TNode*) G__getstructoffset())->GetNode((const char*) G__int(libp->para[0])));
04759 return(1 || funcname || hash || result7 || libp) ;
04760 }
04761
04762 static int G__G__G3D_129_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04763 {
04764 G__letint(result7, 67, (long) ((const TNode*) G__getstructoffset())->GetOption());
04765 return(1 || funcname || hash || result7 || libp) ;
04766 }
04767
04768 static int G__G__G3D_129_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04769 {
04770 G__letint(result7, 85, (long) ((const TNode*) G__getstructoffset())->GetParent());
04771 return(1 || funcname || hash || result7 || libp) ;
04772 }
04773
04774 static int G__G__G3D_129_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04775 {
04776 G__letint(result7, 85, (long) ((const TNode*) G__getstructoffset())->GetShape());
04777 return(1 || funcname || hash || result7 || libp) ;
04778 }
04779
04780 static int G__G__G3D_129_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04781 {
04782 G__letint(result7, 105, (long) ((const TNode*) G__getstructoffset())->GetVisibility());
04783 return(1 || funcname || hash || result7 || libp) ;
04784 }
04785
04786 static int G__G__G3D_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04787 {
04788 G__letdouble(result7, 100, (double) ((const TNode*) G__getstructoffset())->GetX());
04789 return(1 || funcname || hash || result7 || libp) ;
04790 }
04791
04792 static int G__G__G3D_129_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04793 {
04794 G__letdouble(result7, 100, (double) ((const TNode*) G__getstructoffset())->GetY());
04795 return(1 || funcname || hash || result7 || libp) ;
04796 }
04797
04798 static int G__G__G3D_129_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04799 {
04800 G__letdouble(result7, 100, (double) ((const TNode*) G__getstructoffset())->GetZ());
04801 return(1 || funcname || hash || result7 || libp) ;
04802 }
04803
04804 static int G__G__G3D_129_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04805 {
04806 ((TNode*) G__getstructoffset())->ImportShapeAttributes();
04807 G__setnull(result7);
04808 return(1 || funcname || hash || result7 || libp) ;
04809 }
04810
04811 static int G__G__G3D_129_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04812 {
04813 ((TNode*) G__getstructoffset())->Local2Master((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
04814 G__setnull(result7);
04815 return(1 || funcname || hash || result7 || libp) ;
04816 }
04817
04818 static int G__G__G3D_129_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04819 {
04820 ((TNode*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
04821 G__setnull(result7);
04822 return(1 || funcname || hash || result7 || libp) ;
04823 }
04824
04825 static int G__G__G3D_129_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04826 {
04827 ((TNode*) G__getstructoffset())->Master2Local((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
04828 G__setnull(result7);
04829 return(1 || funcname || hash || result7 || libp) ;
04830 }
04831
04832 static int G__G__G3D_129_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04833 {
04834 ((TNode*) G__getstructoffset())->Master2Local((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
04835 G__setnull(result7);
04836 return(1 || funcname || hash || result7 || libp) ;
04837 }
04838
04839 static int G__G__G3D_129_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04840 {
04841 switch (libp->paran) {
04842 case 1:
04843 ((TNode*) G__getstructoffset())->SetMatrix((TRotMatrix*) G__int(libp->para[0]));
04844 G__setnull(result7);
04845 break;
04846 case 0:
04847 ((TNode*) G__getstructoffset())->SetMatrix();
04848 G__setnull(result7);
04849 break;
04850 }
04851 return(1 || funcname || hash || result7 || libp) ;
04852 }
04853
04854 static int G__G__G3D_129_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04855 {
04856 ((TNode*) G__getstructoffset())->SetParent((TNode*) G__int(libp->para[0]));
04857 G__setnull(result7);
04858 return(1 || funcname || hash || result7 || libp) ;
04859 }
04860
04861 static int G__G__G3D_129_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04862 {
04863 switch (libp->paran) {
04864 case 3:
04865 ((TNode*) G__getstructoffset())->SetPosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
04866 , (Double_t) G__double(libp->para[2]));
04867 G__setnull(result7);
04868 break;
04869 case 2:
04870 ((TNode*) G__getstructoffset())->SetPosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
04871 G__setnull(result7);
04872 break;
04873 case 1:
04874 ((TNode*) G__getstructoffset())->SetPosition((Double_t) G__double(libp->para[0]));
04875 G__setnull(result7);
04876 break;
04877 case 0:
04878 ((TNode*) G__getstructoffset())->SetPosition();
04879 G__setnull(result7);
04880 break;
04881 }
04882 return(1 || funcname || hash || result7 || libp) ;
04883 }
04884
04885 static int G__G__G3D_129_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04886 {
04887 switch (libp->paran) {
04888 case 1:
04889 ((TNode*) G__getstructoffset())->SetVisibility((Int_t) G__int(libp->para[0]));
04890 G__setnull(result7);
04891 break;
04892 case 0:
04893 ((TNode*) G__getstructoffset())->SetVisibility();
04894 G__setnull(result7);
04895 break;
04896 }
04897 return(1 || funcname || hash || result7 || libp) ;
04898 }
04899
04900 static int G__G__G3D_129_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04901 {
04902 ((TNode*) G__getstructoffset())->UpdateMatrix();
04903 G__setnull(result7);
04904 return(1 || funcname || hash || result7 || libp) ;
04905 }
04906
04907 static int G__G__G3D_129_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04908 {
04909 ((TNode*) G__getstructoffset())->UpdateTempMatrix(
04910 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
04911 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
04912 , (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])
04913 , (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
04914 G__setnull(result7);
04915 return(1 || funcname || hash || result7 || libp) ;
04916 }
04917
04918 static int G__G__G3D_129_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04919 {
04920 G__letint(result7, 85, (long) TNode::Class());
04921 return(1 || funcname || hash || result7 || libp) ;
04922 }
04923
04924 static int G__G__G3D_129_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04925 {
04926 G__letint(result7, 67, (long) TNode::Class_Name());
04927 return(1 || funcname || hash || result7 || libp) ;
04928 }
04929
04930 static int G__G__G3D_129_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04931 {
04932 G__letint(result7, 115, (long) TNode::Class_Version());
04933 return(1 || funcname || hash || result7 || libp) ;
04934 }
04935
04936 static int G__G__G3D_129_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04937 {
04938 TNode::Dictionary();
04939 G__setnull(result7);
04940 return(1 || funcname || hash || result7 || libp) ;
04941 }
04942
04943 static int G__G__G3D_129_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04944 {
04945 ((TNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04946 G__setnull(result7);
04947 return(1 || funcname || hash || result7 || libp) ;
04948 }
04949
04950 static int G__G__G3D_129_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04951 {
04952 G__letint(result7, 67, (long) TNode::DeclFileName());
04953 return(1 || funcname || hash || result7 || libp) ;
04954 }
04955
04956 static int G__G__G3D_129_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04957 {
04958 G__letint(result7, 105, (long) TNode::ImplFileLine());
04959 return(1 || funcname || hash || result7 || libp) ;
04960 }
04961
04962 static int G__G__G3D_129_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04963 {
04964 G__letint(result7, 67, (long) TNode::ImplFileName());
04965 return(1 || funcname || hash || result7 || libp) ;
04966 }
04967
04968 static int G__G__G3D_129_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04969 {
04970 G__letint(result7, 105, (long) TNode::DeclFileLine());
04971 return(1 || funcname || hash || result7 || libp) ;
04972 }
04973
04974
04975 typedef TNode G__TTNode;
04976 static int G__G__G3D_129_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04977 {
04978 char* gvp = (char*) G__getgvp();
04979 long soff = G__getstructoffset();
04980 int n = G__getaryconstruct();
04981
04982
04983
04984
04985
04986 if (!soff) {
04987 return(1);
04988 }
04989 if (n) {
04990 if (gvp == (char*)G__PVOID) {
04991 delete[] (TNode*) soff;
04992 } else {
04993 G__setgvp((long) G__PVOID);
04994 for (int i = n - 1; i >= 0; --i) {
04995 ((TNode*) (soff+(sizeof(TNode)*i)))->~G__TTNode();
04996 }
04997 G__setgvp((long)gvp);
04998 }
04999 } else {
05000 if (gvp == (char*)G__PVOID) {
05001 delete (TNode*) soff;
05002 } else {
05003 G__setgvp((long) G__PVOID);
05004 ((TNode*) (soff))->~G__TTNode();
05005 G__setgvp((long)gvp);
05006 }
05007 }
05008 G__setnull(result7);
05009 return(1 || funcname || hash || result7 || libp) ;
05010 }
05011
05012
05013
05014 static int G__G__G3D_130_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05015 {
05016 TShape* p = NULL;
05017 char* gvp = (char*) G__getgvp();
05018 int n = G__getaryconstruct();
05019 if (n) {
05020 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05021 p = new TShape[n];
05022 } else {
05023 p = new((void*) gvp) TShape[n];
05024 }
05025 } else {
05026 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05027 p = new TShape;
05028 } else {
05029 p = new((void*) gvp) TShape;
05030 }
05031 }
05032 result7->obj.i = (long) p;
05033 result7->ref = (long) p;
05034 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TShape));
05035 return(1 || funcname || hash || result7 || libp) ;
05036 }
05037
05038 static int G__G__G3D_130_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05039 {
05040 TShape* p = NULL;
05041 char* gvp = (char*) G__getgvp();
05042
05043 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05044 p = new TShape(
05045 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05046 , (const char*) G__int(libp->para[2]));
05047 } else {
05048 p = new((void*) gvp) TShape(
05049 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05050 , (const char*) G__int(libp->para[2]));
05051 }
05052 result7->obj.i = (long) p;
05053 result7->ref = (long) p;
05054 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TShape));
05055 return(1 || funcname || hash || result7 || libp) ;
05056 }
05057
05058 static int G__G__G3D_130_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05059 {
05060 TShape* p = NULL;
05061 char* gvp = (char*) G__getgvp();
05062
05063 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05064 p = new TShape(*(TShape*) libp->para[0].ref);
05065 } else {
05066 p = new((void*) gvp) TShape(*(TShape*) libp->para[0].ref);
05067 }
05068 result7->obj.i = (long) p;
05069 result7->ref = (long) p;
05070 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TShape));
05071 return(1 || funcname || hash || result7 || libp) ;
05072 }
05073
05074 static int G__G__G3D_130_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05075 {
05076 {
05077 const TShape& obj = ((TShape*) G__getstructoffset())->operator=(*(TShape*) libp->para[0].ref);
05078 result7->ref = (long) (&obj);
05079 result7->obj.i = (long) (&obj);
05080 }
05081 return(1 || funcname || hash || result7 || libp) ;
05082 }
05083
05084 static int G__G__G3D_130_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05085 {
05086 {
05087 const TBuffer3D& obj = ((const TShape*) G__getstructoffset())->GetBuffer3D((Int_t) G__int(libp->para[0]));
05088 result7->ref = (long) (&obj);
05089 result7->obj.i = (long) (&obj);
05090 }
05091 return(1 || funcname || hash || result7 || libp) ;
05092 }
05093
05094 static int G__G__G3D_130_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05095 {
05096 G__letint(result7, 85, (long) ((const TShape*) G__getstructoffset())->GetMaterial());
05097 return(1 || funcname || hash || result7 || libp) ;
05098 }
05099
05100 static int G__G__G3D_130_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05101 {
05102 G__letint(result7, 105, (long) ((const TShape*) G__getstructoffset())->GetNumber());
05103 return(1 || funcname || hash || result7 || libp) ;
05104 }
05105
05106 static int G__G__G3D_130_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05107 {
05108 G__letint(result7, 105, (long) ((const TShape*) G__getstructoffset())->GetVisibility());
05109 return(1 || funcname || hash || result7 || libp) ;
05110 }
05111
05112 static int G__G__G3D_130_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05113 {
05114 ((const TShape*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
05115 G__setnull(result7);
05116 return(1 || funcname || hash || result7 || libp) ;
05117 }
05118
05119 static int G__G__G3D_130_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05120 {
05121 ((TShape*) G__getstructoffset())->SetVisibility((Int_t) G__int(libp->para[0]));
05122 G__setnull(result7);
05123 return(1 || funcname || hash || result7 || libp) ;
05124 }
05125
05126 static int G__G__G3D_130_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05127 {
05128 ((const TShape*) G__getstructoffset())->TransformPoints((Double_t*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
05129 G__setnull(result7);
05130 return(1 || funcname || hash || result7 || libp) ;
05131 }
05132
05133 static int G__G__G3D_130_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05134 {
05135 G__letint(result7, 85, (long) TShape::Class());
05136 return(1 || funcname || hash || result7 || libp) ;
05137 }
05138
05139 static int G__G__G3D_130_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05140 {
05141 G__letint(result7, 67, (long) TShape::Class_Name());
05142 return(1 || funcname || hash || result7 || libp) ;
05143 }
05144
05145 static int G__G__G3D_130_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05146 {
05147 G__letint(result7, 115, (long) TShape::Class_Version());
05148 return(1 || funcname || hash || result7 || libp) ;
05149 }
05150
05151 static int G__G__G3D_130_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05152 {
05153 TShape::Dictionary();
05154 G__setnull(result7);
05155 return(1 || funcname || hash || result7 || libp) ;
05156 }
05157
05158 static int G__G__G3D_130_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05159 {
05160 ((TShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05161 G__setnull(result7);
05162 return(1 || funcname || hash || result7 || libp) ;
05163 }
05164
05165 static int G__G__G3D_130_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05166 {
05167 G__letint(result7, 67, (long) TShape::DeclFileName());
05168 return(1 || funcname || hash || result7 || libp) ;
05169 }
05170
05171 static int G__G__G3D_130_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05172 {
05173 G__letint(result7, 105, (long) TShape::ImplFileLine());
05174 return(1 || funcname || hash || result7 || libp) ;
05175 }
05176
05177 static int G__G__G3D_130_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05178 {
05179 G__letint(result7, 67, (long) TShape::ImplFileName());
05180 return(1 || funcname || hash || result7 || libp) ;
05181 }
05182
05183 static int G__G__G3D_130_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05184 {
05185 G__letint(result7, 105, (long) TShape::DeclFileLine());
05186 return(1 || funcname || hash || result7 || libp) ;
05187 }
05188
05189
05190 typedef TShape G__TTShape;
05191 static int G__G__G3D_130_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05192 {
05193 char* gvp = (char*) G__getgvp();
05194 long soff = G__getstructoffset();
05195 int n = G__getaryconstruct();
05196
05197
05198
05199
05200
05201 if (!soff) {
05202 return(1);
05203 }
05204 if (n) {
05205 if (gvp == (char*)G__PVOID) {
05206 delete[] (TShape*) soff;
05207 } else {
05208 G__setgvp((long) G__PVOID);
05209 for (int i = n - 1; i >= 0; --i) {
05210 ((TShape*) (soff+(sizeof(TShape)*i)))->~G__TTShape();
05211 }
05212 G__setgvp((long)gvp);
05213 }
05214 } else {
05215 if (gvp == (char*)G__PVOID) {
05216 delete (TShape*) soff;
05217 } else {
05218 G__setgvp((long) G__PVOID);
05219 ((TShape*) (soff))->~G__TTShape();
05220 G__setgvp((long)gvp);
05221 }
05222 }
05223 G__setnull(result7);
05224 return(1 || funcname || hash || result7 || libp) ;
05225 }
05226
05227
05228
05229 static int G__G__G3D_131_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05230 {
05231 TBRIK* p = NULL;
05232 char* gvp = (char*) G__getgvp();
05233 int n = G__getaryconstruct();
05234 if (n) {
05235 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05236 p = new TBRIK[n];
05237 } else {
05238 p = new((void*) gvp) TBRIK[n];
05239 }
05240 } else {
05241 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05242 p = new TBRIK;
05243 } else {
05244 p = new((void*) gvp) TBRIK;
05245 }
05246 }
05247 result7->obj.i = (long) p;
05248 result7->ref = (long) p;
05249 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TBRIK));
05250 return(1 || funcname || hash || result7 || libp) ;
05251 }
05252
05253 static int G__G__G3D_131_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05254 {
05255 TBRIK* p = NULL;
05256 char* gvp = (char*) G__getgvp();
05257
05258 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05259 p = new TBRIK(
05260 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05261 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05262 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
05263 } else {
05264 p = new((void*) gvp) TBRIK(
05265 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05266 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05267 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
05268 }
05269 result7->obj.i = (long) p;
05270 result7->ref = (long) p;
05271 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TBRIK));
05272 return(1 || funcname || hash || result7 || libp) ;
05273 }
05274
05275 static int G__G__G3D_131_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05276 {
05277 G__letdouble(result7, 102, (double) ((const TBRIK*) G__getstructoffset())->GetDx());
05278 return(1 || funcname || hash || result7 || libp) ;
05279 }
05280
05281 static int G__G__G3D_131_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05282 {
05283 G__letdouble(result7, 102, (double) ((const TBRIK*) G__getstructoffset())->GetDy());
05284 return(1 || funcname || hash || result7 || libp) ;
05285 }
05286
05287 static int G__G__G3D_131_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05288 {
05289 G__letdouble(result7, 102, (double) ((const TBRIK*) G__getstructoffset())->GetDz());
05290 return(1 || funcname || hash || result7 || libp) ;
05291 }
05292
05293 static int G__G__G3D_131_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05294 {
05295 G__letint(result7, 85, (long) TBRIK::Class());
05296 return(1 || funcname || hash || result7 || libp) ;
05297 }
05298
05299 static int G__G__G3D_131_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05300 {
05301 G__letint(result7, 67, (long) TBRIK::Class_Name());
05302 return(1 || funcname || hash || result7 || libp) ;
05303 }
05304
05305 static int G__G__G3D_131_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05306 {
05307 G__letint(result7, 115, (long) TBRIK::Class_Version());
05308 return(1 || funcname || hash || result7 || libp) ;
05309 }
05310
05311 static int G__G__G3D_131_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05312 {
05313 TBRIK::Dictionary();
05314 G__setnull(result7);
05315 return(1 || funcname || hash || result7 || libp) ;
05316 }
05317
05318 static int G__G__G3D_131_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05319 {
05320 ((TBRIK*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05321 G__setnull(result7);
05322 return(1 || funcname || hash || result7 || libp) ;
05323 }
05324
05325 static int G__G__G3D_131_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05326 {
05327 G__letint(result7, 67, (long) TBRIK::DeclFileName());
05328 return(1 || funcname || hash || result7 || libp) ;
05329 }
05330
05331 static int G__G__G3D_131_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05332 {
05333 G__letint(result7, 105, (long) TBRIK::ImplFileLine());
05334 return(1 || funcname || hash || result7 || libp) ;
05335 }
05336
05337 static int G__G__G3D_131_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05338 {
05339 G__letint(result7, 67, (long) TBRIK::ImplFileName());
05340 return(1 || funcname || hash || result7 || libp) ;
05341 }
05342
05343 static int G__G__G3D_131_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05344 {
05345 G__letint(result7, 105, (long) TBRIK::DeclFileLine());
05346 return(1 || funcname || hash || result7 || libp) ;
05347 }
05348
05349
05350 static int G__G__G3D_131_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05351
05352 {
05353 TBRIK* p;
05354 void* tmp = (void*) G__int(libp->para[0]);
05355 p = new TBRIK(*(TBRIK*) tmp);
05356 result7->obj.i = (long) p;
05357 result7->ref = (long) p;
05358 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TBRIK));
05359 return(1 || funcname || hash || result7 || libp) ;
05360 }
05361
05362
05363 typedef TBRIK G__TTBRIK;
05364 static int G__G__G3D_131_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05365 {
05366 char* gvp = (char*) G__getgvp();
05367 long soff = G__getstructoffset();
05368 int n = G__getaryconstruct();
05369
05370
05371
05372
05373
05374 if (!soff) {
05375 return(1);
05376 }
05377 if (n) {
05378 if (gvp == (char*)G__PVOID) {
05379 delete[] (TBRIK*) soff;
05380 } else {
05381 G__setgvp((long) G__PVOID);
05382 for (int i = n - 1; i >= 0; --i) {
05383 ((TBRIK*) (soff+(sizeof(TBRIK)*i)))->~G__TTBRIK();
05384 }
05385 G__setgvp((long)gvp);
05386 }
05387 } else {
05388 if (gvp == (char*)G__PVOID) {
05389 delete (TBRIK*) soff;
05390 } else {
05391 G__setgvp((long) G__PVOID);
05392 ((TBRIK*) (soff))->~G__TTBRIK();
05393 G__setgvp((long)gvp);
05394 }
05395 }
05396 G__setnull(result7);
05397 return(1 || funcname || hash || result7 || libp) ;
05398 }
05399
05400
05401 static int G__G__G3D_131_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05402 {
05403 TBRIK* dest = (TBRIK*) G__getstructoffset();
05404 *dest = *(TBRIK*) libp->para[0].ref;
05405 const TBRIK& obj = *dest;
05406 result7->ref = (long) (&obj);
05407 result7->obj.i = (long) (&obj);
05408 return(1 || funcname || hash || result7 || libp) ;
05409 }
05410
05411
05412
05413 static int G__G__G3D_132_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05414 {
05415 TTUBE* p = NULL;
05416 char* gvp = (char*) G__getgvp();
05417 int n = G__getaryconstruct();
05418 if (n) {
05419 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05420 p = new TTUBE[n];
05421 } else {
05422 p = new((void*) gvp) TTUBE[n];
05423 }
05424 } else {
05425 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05426 p = new TTUBE;
05427 } else {
05428 p = new((void*) gvp) TTUBE;
05429 }
05430 }
05431 result7->obj.i = (long) p;
05432 result7->ref = (long) p;
05433 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBE));
05434 return(1 || funcname || hash || result7 || libp) ;
05435 }
05436
05437 static int G__G__G3D_132_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05438 {
05439 TTUBE* p = NULL;
05440 char* gvp = (char*) G__getgvp();
05441 switch (libp->paran) {
05442 case 7:
05443
05444 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05445 p = new TTUBE(
05446 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05447 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05448 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05449 , (Float_t) G__double(libp->para[6]));
05450 } else {
05451 p = new((void*) gvp) TTUBE(
05452 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05453 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05454 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05455 , (Float_t) G__double(libp->para[6]));
05456 }
05457 break;
05458 case 6:
05459
05460 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05461 p = new TTUBE(
05462 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05463 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05464 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
05465 } else {
05466 p = new((void*) gvp) TTUBE(
05467 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05468 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05469 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
05470 }
05471 break;
05472 }
05473 result7->obj.i = (long) p;
05474 result7->ref = (long) p;
05475 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBE));
05476 return(1 || funcname || hash || result7 || libp) ;
05477 }
05478
05479 static int G__G__G3D_132_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05480 {
05481 TTUBE* p = NULL;
05482 char* gvp = (char*) G__getgvp();
05483
05484 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05485 p = new TTUBE(
05486 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05487 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05488 , (Float_t) G__double(libp->para[4]));
05489 } else {
05490 p = new((void*) gvp) TTUBE(
05491 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05492 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05493 , (Float_t) G__double(libp->para[4]));
05494 }
05495 result7->obj.i = (long) p;
05496 result7->ref = (long) p;
05497 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBE));
05498 return(1 || funcname || hash || result7 || libp) ;
05499 }
05500
05501 static int G__G__G3D_132_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05502 {
05503 G__letdouble(result7, 102, (double) ((const TTUBE*) G__getstructoffset())->GetRmin());
05504 return(1 || funcname || hash || result7 || libp) ;
05505 }
05506
05507 static int G__G__G3D_132_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05508 {
05509 G__letdouble(result7, 102, (double) ((const TTUBE*) G__getstructoffset())->GetRmax());
05510 return(1 || funcname || hash || result7 || libp) ;
05511 }
05512
05513 static int G__G__G3D_132_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05514 {
05515 G__letdouble(result7, 102, (double) ((const TTUBE*) G__getstructoffset())->GetDz());
05516 return(1 || funcname || hash || result7 || libp) ;
05517 }
05518
05519 static int G__G__G3D_132_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05520 {
05521 G__letint(result7, 105, (long) ((const TTUBE*) G__getstructoffset())->GetNdiv());
05522 return(1 || funcname || hash || result7 || libp) ;
05523 }
05524
05525 static int G__G__G3D_132_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05526 {
05527 G__letdouble(result7, 102, (double) ((const TTUBE*) G__getstructoffset())->GetAspectRatio());
05528 return(1 || funcname || hash || result7 || libp) ;
05529 }
05530
05531 static int G__G__G3D_132_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05532 {
05533 G__letint(result7, 105, (long) ((const TTUBE*) G__getstructoffset())->GetNumberOfDivisions());
05534 return(1 || funcname || hash || result7 || libp) ;
05535 }
05536
05537 static int G__G__G3D_132_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05538 {
05539 ((TTUBE*) G__getstructoffset())->SetNumberOfDivisions((Int_t) G__int(libp->para[0]));
05540 G__setnull(result7);
05541 return(1 || funcname || hash || result7 || libp) ;
05542 }
05543
05544 static int G__G__G3D_132_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05545 {
05546 switch (libp->paran) {
05547 case 1:
05548 ((TTUBE*) G__getstructoffset())->SetAspectRatio((Float_t) G__double(libp->para[0]));
05549 G__setnull(result7);
05550 break;
05551 case 0:
05552 ((TTUBE*) G__getstructoffset())->SetAspectRatio();
05553 G__setnull(result7);
05554 break;
05555 }
05556 return(1 || funcname || hash || result7 || libp) ;
05557 }
05558
05559 static int G__G__G3D_132_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05560 {
05561 G__letint(result7, 85, (long) TTUBE::Class());
05562 return(1 || funcname || hash || result7 || libp) ;
05563 }
05564
05565 static int G__G__G3D_132_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05566 {
05567 G__letint(result7, 67, (long) TTUBE::Class_Name());
05568 return(1 || funcname || hash || result7 || libp) ;
05569 }
05570
05571 static int G__G__G3D_132_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05572 {
05573 G__letint(result7, 115, (long) TTUBE::Class_Version());
05574 return(1 || funcname || hash || result7 || libp) ;
05575 }
05576
05577 static int G__G__G3D_132_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05578 {
05579 TTUBE::Dictionary();
05580 G__setnull(result7);
05581 return(1 || funcname || hash || result7 || libp) ;
05582 }
05583
05584 static int G__G__G3D_132_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05585 {
05586 ((TTUBE*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05587 G__setnull(result7);
05588 return(1 || funcname || hash || result7 || libp) ;
05589 }
05590
05591 static int G__G__G3D_132_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05592 {
05593 G__letint(result7, 67, (long) TTUBE::DeclFileName());
05594 return(1 || funcname || hash || result7 || libp) ;
05595 }
05596
05597 static int G__G__G3D_132_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05598 {
05599 G__letint(result7, 105, (long) TTUBE::ImplFileLine());
05600 return(1 || funcname || hash || result7 || libp) ;
05601 }
05602
05603 static int G__G__G3D_132_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05604 {
05605 G__letint(result7, 67, (long) TTUBE::ImplFileName());
05606 return(1 || funcname || hash || result7 || libp) ;
05607 }
05608
05609 static int G__G__G3D_132_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05610 {
05611 G__letint(result7, 105, (long) TTUBE::DeclFileLine());
05612 return(1 || funcname || hash || result7 || libp) ;
05613 }
05614
05615
05616 typedef TTUBE G__TTTUBE;
05617 static int G__G__G3D_132_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05618 {
05619 char* gvp = (char*) G__getgvp();
05620 long soff = G__getstructoffset();
05621 int n = G__getaryconstruct();
05622
05623
05624
05625
05626
05627 if (!soff) {
05628 return(1);
05629 }
05630 if (n) {
05631 if (gvp == (char*)G__PVOID) {
05632 delete[] (TTUBE*) soff;
05633 } else {
05634 G__setgvp((long) G__PVOID);
05635 for (int i = n - 1; i >= 0; --i) {
05636 ((TTUBE*) (soff+(sizeof(TTUBE)*i)))->~G__TTTUBE();
05637 }
05638 G__setgvp((long)gvp);
05639 }
05640 } else {
05641 if (gvp == (char*)G__PVOID) {
05642 delete (TTUBE*) soff;
05643 } else {
05644 G__setgvp((long) G__PVOID);
05645 ((TTUBE*) (soff))->~G__TTTUBE();
05646 G__setgvp((long)gvp);
05647 }
05648 }
05649 G__setnull(result7);
05650 return(1 || funcname || hash || result7 || libp) ;
05651 }
05652
05653
05654
05655 static int G__G__G3D_133_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05656 {
05657 TCONE* p = NULL;
05658 char* gvp = (char*) G__getgvp();
05659 int n = G__getaryconstruct();
05660 if (n) {
05661 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05662 p = new TCONE[n];
05663 } else {
05664 p = new((void*) gvp) TCONE[n];
05665 }
05666 } else {
05667 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05668 p = new TCONE;
05669 } else {
05670 p = new((void*) gvp) TCONE;
05671 }
05672 }
05673 result7->obj.i = (long) p;
05674 result7->ref = (long) p;
05675 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONE));
05676 return(1 || funcname || hash || result7 || libp) ;
05677 }
05678
05679 static int G__G__G3D_133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05680 {
05681 TCONE* p = NULL;
05682 char* gvp = (char*) G__getgvp();
05683
05684 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05685 p = new TCONE(
05686 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05687 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05688 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05689 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
05690 } else {
05691 p = new((void*) gvp) TCONE(
05692 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05693 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05694 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05695 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
05696 }
05697 result7->obj.i = (long) p;
05698 result7->ref = (long) p;
05699 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONE));
05700 return(1 || funcname || hash || result7 || libp) ;
05701 }
05702
05703 static int G__G__G3D_133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05704 {
05705 TCONE* p = NULL;
05706 char* gvp = (char*) G__getgvp();
05707 switch (libp->paran) {
05708 case 6:
05709
05710 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05711 p = new TCONE(
05712 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05713 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05714 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
05715 } else {
05716 p = new((void*) gvp) TCONE(
05717 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05718 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05719 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
05720 }
05721 break;
05722 case 5:
05723
05724 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05725 p = new TCONE(
05726 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05727 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05728 , (Float_t) G__double(libp->para[4]));
05729 } else {
05730 p = new((void*) gvp) TCONE(
05731 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05732 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05733 , (Float_t) G__double(libp->para[4]));
05734 }
05735 break;
05736 }
05737 result7->obj.i = (long) p;
05738 result7->ref = (long) p;
05739 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONE));
05740 return(1 || funcname || hash || result7 || libp) ;
05741 }
05742
05743 static int G__G__G3D_133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05744 {
05745 G__letdouble(result7, 102, (double) ((const TCONE*) G__getstructoffset())->GetRmin2());
05746 return(1 || funcname || hash || result7 || libp) ;
05747 }
05748
05749 static int G__G__G3D_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05750 {
05751 G__letdouble(result7, 102, (double) ((const TCONE*) G__getstructoffset())->GetRmax2());
05752 return(1 || funcname || hash || result7 || libp) ;
05753 }
05754
05755 static int G__G__G3D_133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05756 {
05757 G__letint(result7, 85, (long) TCONE::Class());
05758 return(1 || funcname || hash || result7 || libp) ;
05759 }
05760
05761 static int G__G__G3D_133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05762 {
05763 G__letint(result7, 67, (long) TCONE::Class_Name());
05764 return(1 || funcname || hash || result7 || libp) ;
05765 }
05766
05767 static int G__G__G3D_133_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05768 {
05769 G__letint(result7, 115, (long) TCONE::Class_Version());
05770 return(1 || funcname || hash || result7 || libp) ;
05771 }
05772
05773 static int G__G__G3D_133_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05774 {
05775 TCONE::Dictionary();
05776 G__setnull(result7);
05777 return(1 || funcname || hash || result7 || libp) ;
05778 }
05779
05780 static int G__G__G3D_133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05781 {
05782 ((TCONE*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05783 G__setnull(result7);
05784 return(1 || funcname || hash || result7 || libp) ;
05785 }
05786
05787 static int G__G__G3D_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05788 {
05789 G__letint(result7, 67, (long) TCONE::DeclFileName());
05790 return(1 || funcname || hash || result7 || libp) ;
05791 }
05792
05793 static int G__G__G3D_133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05794 {
05795 G__letint(result7, 105, (long) TCONE::ImplFileLine());
05796 return(1 || funcname || hash || result7 || libp) ;
05797 }
05798
05799 static int G__G__G3D_133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05800 {
05801 G__letint(result7, 67, (long) TCONE::ImplFileName());
05802 return(1 || funcname || hash || result7 || libp) ;
05803 }
05804
05805 static int G__G__G3D_133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05806 {
05807 G__letint(result7, 105, (long) TCONE::DeclFileLine());
05808 return(1 || funcname || hash || result7 || libp) ;
05809 }
05810
05811
05812 static int G__G__G3D_133_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05813
05814 {
05815 TCONE* p;
05816 void* tmp = (void*) G__int(libp->para[0]);
05817 p = new TCONE(*(TCONE*) tmp);
05818 result7->obj.i = (long) p;
05819 result7->ref = (long) p;
05820 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONE));
05821 return(1 || funcname || hash || result7 || libp) ;
05822 }
05823
05824
05825 typedef TCONE G__TTCONE;
05826 static int G__G__G3D_133_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05827 {
05828 char* gvp = (char*) G__getgvp();
05829 long soff = G__getstructoffset();
05830 int n = G__getaryconstruct();
05831
05832
05833
05834
05835
05836 if (!soff) {
05837 return(1);
05838 }
05839 if (n) {
05840 if (gvp == (char*)G__PVOID) {
05841 delete[] (TCONE*) soff;
05842 } else {
05843 G__setgvp((long) G__PVOID);
05844 for (int i = n - 1; i >= 0; --i) {
05845 ((TCONE*) (soff+(sizeof(TCONE)*i)))->~G__TTCONE();
05846 }
05847 G__setgvp((long)gvp);
05848 }
05849 } else {
05850 if (gvp == (char*)G__PVOID) {
05851 delete (TCONE*) soff;
05852 } else {
05853 G__setgvp((long) G__PVOID);
05854 ((TCONE*) (soff))->~G__TTCONE();
05855 G__setgvp((long)gvp);
05856 }
05857 }
05858 G__setnull(result7);
05859 return(1 || funcname || hash || result7 || libp) ;
05860 }
05861
05862
05863
05864 static int G__G__G3D_134_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05865 {
05866 TTUBS* p = NULL;
05867 char* gvp = (char*) G__getgvp();
05868 int n = G__getaryconstruct();
05869 if (n) {
05870 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05871 p = new TTUBS[n];
05872 } else {
05873 p = new((void*) gvp) TTUBS[n];
05874 }
05875 } else {
05876 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05877 p = new TTUBS;
05878 } else {
05879 p = new((void*) gvp) TTUBS;
05880 }
05881 }
05882 result7->obj.i = (long) p;
05883 result7->ref = (long) p;
05884 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBS));
05885 return(1 || funcname || hash || result7 || libp) ;
05886 }
05887
05888 static int G__G__G3D_134_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05889 {
05890 TTUBS* p = NULL;
05891 char* gvp = (char*) G__getgvp();
05892
05893 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05894 p = new TTUBS(
05895 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05896 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05897 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05898 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
05899 } else {
05900 p = new((void*) gvp) TTUBS(
05901 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05902 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05903 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05904 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
05905 }
05906 result7->obj.i = (long) p;
05907 result7->ref = (long) p;
05908 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBS));
05909 return(1 || funcname || hash || result7 || libp) ;
05910 }
05911
05912 static int G__G__G3D_134_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05913 {
05914 TTUBS* p = NULL;
05915 char* gvp = (char*) G__getgvp();
05916
05917 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05918 p = new TTUBS(
05919 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05920 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05921 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05922 , (Float_t) G__double(libp->para[6]));
05923 } else {
05924 p = new((void*) gvp) TTUBS(
05925 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05926 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
05927 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
05928 , (Float_t) G__double(libp->para[6]));
05929 }
05930 result7->obj.i = (long) p;
05931 result7->ref = (long) p;
05932 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBS));
05933 return(1 || funcname || hash || result7 || libp) ;
05934 }
05935
05936 static int G__G__G3D_134_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05937 {
05938 G__letdouble(result7, 102, (double) ((const TTUBS*) G__getstructoffset())->GetPhi1());
05939 return(1 || funcname || hash || result7 || libp) ;
05940 }
05941
05942 static int G__G__G3D_134_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05943 {
05944 G__letdouble(result7, 102, (double) ((const TTUBS*) G__getstructoffset())->GetPhi2());
05945 return(1 || funcname || hash || result7 || libp) ;
05946 }
05947
05948 static int G__G__G3D_134_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05949 {
05950 G__letint(result7, 85, (long) TTUBS::Class());
05951 return(1 || funcname || hash || result7 || libp) ;
05952 }
05953
05954 static int G__G__G3D_134_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05955 {
05956 G__letint(result7, 67, (long) TTUBS::Class_Name());
05957 return(1 || funcname || hash || result7 || libp) ;
05958 }
05959
05960 static int G__G__G3D_134_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05961 {
05962 G__letint(result7, 115, (long) TTUBS::Class_Version());
05963 return(1 || funcname || hash || result7 || libp) ;
05964 }
05965
05966 static int G__G__G3D_134_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05967 {
05968 TTUBS::Dictionary();
05969 G__setnull(result7);
05970 return(1 || funcname || hash || result7 || libp) ;
05971 }
05972
05973 static int G__G__G3D_134_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05974 {
05975 ((TTUBS*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05976 G__setnull(result7);
05977 return(1 || funcname || hash || result7 || libp) ;
05978 }
05979
05980 static int G__G__G3D_134_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05981 {
05982 G__letint(result7, 67, (long) TTUBS::DeclFileName());
05983 return(1 || funcname || hash || result7 || libp) ;
05984 }
05985
05986 static int G__G__G3D_134_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05987 {
05988 G__letint(result7, 105, (long) TTUBS::ImplFileLine());
05989 return(1 || funcname || hash || result7 || libp) ;
05990 }
05991
05992 static int G__G__G3D_134_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05993 {
05994 G__letint(result7, 67, (long) TTUBS::ImplFileName());
05995 return(1 || funcname || hash || result7 || libp) ;
05996 }
05997
05998 static int G__G__G3D_134_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05999 {
06000 G__letint(result7, 105, (long) TTUBS::DeclFileLine());
06001 return(1 || funcname || hash || result7 || libp) ;
06002 }
06003
06004
06005 static int G__G__G3D_134_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06006
06007 {
06008 TTUBS* p;
06009 void* tmp = (void*) G__int(libp->para[0]);
06010 p = new TTUBS(*(TTUBS*) tmp);
06011 result7->obj.i = (long) p;
06012 result7->ref = (long) p;
06013 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTUBS));
06014 return(1 || funcname || hash || result7 || libp) ;
06015 }
06016
06017
06018 typedef TTUBS G__TTTUBS;
06019 static int G__G__G3D_134_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06020 {
06021 char* gvp = (char*) G__getgvp();
06022 long soff = G__getstructoffset();
06023 int n = G__getaryconstruct();
06024
06025
06026
06027
06028
06029 if (!soff) {
06030 return(1);
06031 }
06032 if (n) {
06033 if (gvp == (char*)G__PVOID) {
06034 delete[] (TTUBS*) soff;
06035 } else {
06036 G__setgvp((long) G__PVOID);
06037 for (int i = n - 1; i >= 0; --i) {
06038 ((TTUBS*) (soff+(sizeof(TTUBS)*i)))->~G__TTTUBS();
06039 }
06040 G__setgvp((long)gvp);
06041 }
06042 } else {
06043 if (gvp == (char*)G__PVOID) {
06044 delete (TTUBS*) soff;
06045 } else {
06046 G__setgvp((long) G__PVOID);
06047 ((TTUBS*) (soff))->~G__TTTUBS();
06048 G__setgvp((long)gvp);
06049 }
06050 }
06051 G__setnull(result7);
06052 return(1 || funcname || hash || result7 || libp) ;
06053 }
06054
06055
06056
06057 static int G__G__G3D_135_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06058 {
06059 TCONS* p = NULL;
06060 char* gvp = (char*) G__getgvp();
06061 int n = G__getaryconstruct();
06062 if (n) {
06063 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06064 p = new TCONS[n];
06065 } else {
06066 p = new((void*) gvp) TCONS[n];
06067 }
06068 } else {
06069 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06070 p = new TCONS;
06071 } else {
06072 p = new((void*) gvp) TCONS;
06073 }
06074 }
06075 result7->obj.i = (long) p;
06076 result7->ref = (long) p;
06077 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONS));
06078 return(1 || funcname || hash || result7 || libp) ;
06079 }
06080
06081 static int G__G__G3D_135_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06082 {
06083 TCONS* p = NULL;
06084 char* gvp = (char*) G__getgvp();
06085
06086 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06087 p = new TCONS(
06088 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06089 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06090 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06091 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
06092 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9]));
06093 } else {
06094 p = new((void*) gvp) TCONS(
06095 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06096 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06097 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06098 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
06099 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9]));
06100 }
06101 result7->obj.i = (long) p;
06102 result7->ref = (long) p;
06103 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONS));
06104 return(1 || funcname || hash || result7 || libp) ;
06105 }
06106
06107 static int G__G__G3D_135_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06108 {
06109 TCONS* p = NULL;
06110 char* gvp = (char*) G__getgvp();
06111 switch (libp->paran) {
06112 case 8:
06113
06114 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06115 p = new TCONS(
06116 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06117 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06118 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06119 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
06120 } else {
06121 p = new((void*) gvp) TCONS(
06122 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06123 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06124 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06125 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
06126 }
06127 break;
06128 case 7:
06129
06130 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06131 p = new TCONS(
06132 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06133 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06134 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06135 , (Float_t) G__double(libp->para[6]));
06136 } else {
06137 p = new((void*) gvp) TCONS(
06138 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06139 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06140 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06141 , (Float_t) G__double(libp->para[6]));
06142 }
06143 break;
06144 }
06145 result7->obj.i = (long) p;
06146 result7->ref = (long) p;
06147 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONS));
06148 return(1 || funcname || hash || result7 || libp) ;
06149 }
06150
06151 static int G__G__G3D_135_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06152 {
06153 G__letdouble(result7, 102, (double) ((const TCONS*) G__getstructoffset())->GetRmin2());
06154 return(1 || funcname || hash || result7 || libp) ;
06155 }
06156
06157 static int G__G__G3D_135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06158 {
06159 G__letdouble(result7, 102, (double) ((const TCONS*) G__getstructoffset())->GetRmax2());
06160 return(1 || funcname || hash || result7 || libp) ;
06161 }
06162
06163 static int G__G__G3D_135_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06164 {
06165 G__letint(result7, 85, (long) TCONS::Class());
06166 return(1 || funcname || hash || result7 || libp) ;
06167 }
06168
06169 static int G__G__G3D_135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06170 {
06171 G__letint(result7, 67, (long) TCONS::Class_Name());
06172 return(1 || funcname || hash || result7 || libp) ;
06173 }
06174
06175 static int G__G__G3D_135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06176 {
06177 G__letint(result7, 115, (long) TCONS::Class_Version());
06178 return(1 || funcname || hash || result7 || libp) ;
06179 }
06180
06181 static int G__G__G3D_135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06182 {
06183 TCONS::Dictionary();
06184 G__setnull(result7);
06185 return(1 || funcname || hash || result7 || libp) ;
06186 }
06187
06188 static int G__G__G3D_135_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06189 {
06190 ((TCONS*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06191 G__setnull(result7);
06192 return(1 || funcname || hash || result7 || libp) ;
06193 }
06194
06195 static int G__G__G3D_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06196 {
06197 G__letint(result7, 67, (long) TCONS::DeclFileName());
06198 return(1 || funcname || hash || result7 || libp) ;
06199 }
06200
06201 static int G__G__G3D_135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06202 {
06203 G__letint(result7, 105, (long) TCONS::ImplFileLine());
06204 return(1 || funcname || hash || result7 || libp) ;
06205 }
06206
06207 static int G__G__G3D_135_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06208 {
06209 G__letint(result7, 67, (long) TCONS::ImplFileName());
06210 return(1 || funcname || hash || result7 || libp) ;
06211 }
06212
06213 static int G__G__G3D_135_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06214 {
06215 G__letint(result7, 105, (long) TCONS::DeclFileLine());
06216 return(1 || funcname || hash || result7 || libp) ;
06217 }
06218
06219
06220 static int G__G__G3D_135_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06221
06222 {
06223 TCONS* p;
06224 void* tmp = (void*) G__int(libp->para[0]);
06225 p = new TCONS(*(TCONS*) tmp);
06226 result7->obj.i = (long) p;
06227 result7->ref = (long) p;
06228 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCONS));
06229 return(1 || funcname || hash || result7 || libp) ;
06230 }
06231
06232
06233 typedef TCONS G__TTCONS;
06234 static int G__G__G3D_135_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06235 {
06236 char* gvp = (char*) G__getgvp();
06237 long soff = G__getstructoffset();
06238 int n = G__getaryconstruct();
06239
06240
06241
06242
06243
06244 if (!soff) {
06245 return(1);
06246 }
06247 if (n) {
06248 if (gvp == (char*)G__PVOID) {
06249 delete[] (TCONS*) soff;
06250 } else {
06251 G__setgvp((long) G__PVOID);
06252 for (int i = n - 1; i >= 0; --i) {
06253 ((TCONS*) (soff+(sizeof(TCONS)*i)))->~G__TTCONS();
06254 }
06255 G__setgvp((long)gvp);
06256 }
06257 } else {
06258 if (gvp == (char*)G__PVOID) {
06259 delete (TCONS*) soff;
06260 } else {
06261 G__setgvp((long) G__PVOID);
06262 ((TCONS*) (soff))->~G__TTCONS();
06263 G__setgvp((long)gvp);
06264 }
06265 }
06266 G__setnull(result7);
06267 return(1 || funcname || hash || result7 || libp) ;
06268 }
06269
06270
06271
06272 static int G__G__G3D_136_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06273 {
06274 TCTUB* p = NULL;
06275 char* gvp = (char*) G__getgvp();
06276 int n = G__getaryconstruct();
06277 if (n) {
06278 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06279 p = new TCTUB[n];
06280 } else {
06281 p = new((void*) gvp) TCTUB[n];
06282 }
06283 } else {
06284 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06285 p = new TCTUB;
06286 } else {
06287 p = new((void*) gvp) TCTUB;
06288 }
06289 }
06290 result7->obj.i = (long) p;
06291 result7->ref = (long) p;
06292 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCTUB));
06293 return(1 || funcname || hash || result7 || libp) ;
06294 }
06295
06296 static int G__G__G3D_136_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06297 {
06298 TCTUB* p = NULL;
06299 char* gvp = (char*) G__getgvp();
06300
06301 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06302 p = new TCTUB(
06303 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06304 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06305 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06306 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
06307 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
06308 , (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
06309 , (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13]));
06310 } else {
06311 p = new((void*) gvp) TCTUB(
06312 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06313 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06314 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06315 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
06316 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
06317 , (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
06318 , (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13]));
06319 }
06320 result7->obj.i = (long) p;
06321 result7->ref = (long) p;
06322 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCTUB));
06323 return(1 || funcname || hash || result7 || libp) ;
06324 }
06325
06326 static int G__G__G3D_136_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06327 {
06328 TCTUB* p = NULL;
06329 char* gvp = (char*) G__getgvp();
06330
06331 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06332 p = new TCTUB(
06333 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06334 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06335 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06336 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
06337 , (Float_t*) G__int(libp->para[8]), (Float_t*) G__int(libp->para[9]));
06338 } else {
06339 p = new((void*) gvp) TCTUB(
06340 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06341 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06342 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
06343 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
06344 , (Float_t*) G__int(libp->para[8]), (Float_t*) G__int(libp->para[9]));
06345 }
06346 result7->obj.i = (long) p;
06347 result7->ref = (long) p;
06348 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCTUB));
06349 return(1 || funcname || hash || result7 || libp) ;
06350 }
06351
06352 static int G__G__G3D_136_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06353 {
06354 G__letint(result7, 85, (long) TCTUB::Class());
06355 return(1 || funcname || hash || result7 || libp) ;
06356 }
06357
06358 static int G__G__G3D_136_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06359 {
06360 G__letint(result7, 67, (long) TCTUB::Class_Name());
06361 return(1 || funcname || hash || result7 || libp) ;
06362 }
06363
06364 static int G__G__G3D_136_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06365 {
06366 G__letint(result7, 115, (long) TCTUB::Class_Version());
06367 return(1 || funcname || hash || result7 || libp) ;
06368 }
06369
06370 static int G__G__G3D_136_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06371 {
06372 TCTUB::Dictionary();
06373 G__setnull(result7);
06374 return(1 || funcname || hash || result7 || libp) ;
06375 }
06376
06377 static int G__G__G3D_136_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06378 {
06379 ((TCTUB*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06380 G__setnull(result7);
06381 return(1 || funcname || hash || result7 || libp) ;
06382 }
06383
06384 static int G__G__G3D_136_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06385 {
06386 G__letint(result7, 67, (long) TCTUB::DeclFileName());
06387 return(1 || funcname || hash || result7 || libp) ;
06388 }
06389
06390 static int G__G__G3D_136_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06391 {
06392 G__letint(result7, 105, (long) TCTUB::ImplFileLine());
06393 return(1 || funcname || hash || result7 || libp) ;
06394 }
06395
06396 static int G__G__G3D_136_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06397 {
06398 G__letint(result7, 67, (long) TCTUB::ImplFileName());
06399 return(1 || funcname || hash || result7 || libp) ;
06400 }
06401
06402 static int G__G__G3D_136_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06403 {
06404 G__letint(result7, 105, (long) TCTUB::DeclFileLine());
06405 return(1 || funcname || hash || result7 || libp) ;
06406 }
06407
06408
06409 static int G__G__G3D_136_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06410
06411 {
06412 TCTUB* p;
06413 void* tmp = (void*) G__int(libp->para[0]);
06414 p = new TCTUB(*(TCTUB*) tmp);
06415 result7->obj.i = (long) p;
06416 result7->ref = (long) p;
06417 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TCTUB));
06418 return(1 || funcname || hash || result7 || libp) ;
06419 }
06420
06421
06422 typedef TCTUB G__TTCTUB;
06423 static int G__G__G3D_136_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06424 {
06425 char* gvp = (char*) G__getgvp();
06426 long soff = G__getstructoffset();
06427 int n = G__getaryconstruct();
06428
06429
06430
06431
06432
06433 if (!soff) {
06434 return(1);
06435 }
06436 if (n) {
06437 if (gvp == (char*)G__PVOID) {
06438 delete[] (TCTUB*) soff;
06439 } else {
06440 G__setgvp((long) G__PVOID);
06441 for (int i = n - 1; i >= 0; --i) {
06442 ((TCTUB*) (soff+(sizeof(TCTUB)*i)))->~G__TTCTUB();
06443 }
06444 G__setgvp((long)gvp);
06445 }
06446 } else {
06447 if (gvp == (char*)G__PVOID) {
06448 delete (TCTUB*) soff;
06449 } else {
06450 G__setgvp((long) G__PVOID);
06451 ((TCTUB*) (soff))->~G__TTCTUB();
06452 G__setgvp((long)gvp);
06453 }
06454 }
06455 G__setnull(result7);
06456 return(1 || funcname || hash || result7 || libp) ;
06457 }
06458
06459
06460
06461 static int G__G__G3D_137_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06462 {
06463 TELTU* p = NULL;
06464 char* gvp = (char*) G__getgvp();
06465 int n = G__getaryconstruct();
06466 if (n) {
06467 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06468 p = new TELTU[n];
06469 } else {
06470 p = new((void*) gvp) TELTU[n];
06471 }
06472 } else {
06473 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06474 p = new TELTU;
06475 } else {
06476 p = new((void*) gvp) TELTU;
06477 }
06478 }
06479 result7->obj.i = (long) p;
06480 result7->ref = (long) p;
06481 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TELTU));
06482 return(1 || funcname || hash || result7 || libp) ;
06483 }
06484
06485 static int G__G__G3D_137_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06486 {
06487 TELTU* p = NULL;
06488 char* gvp = (char*) G__getgvp();
06489
06490 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06491 p = new TELTU(
06492 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06493 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06494 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
06495 } else {
06496 p = new((void*) gvp) TELTU(
06497 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06498 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
06499 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
06500 }
06501 result7->obj.i = (long) p;
06502 result7->ref = (long) p;
06503 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TELTU));
06504 return(1 || funcname || hash || result7 || libp) ;
06505 }
06506
06507 static int G__G__G3D_137_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06508 {
06509 G__letint(result7, 85, (long) TELTU::Class());
06510 return(1 || funcname || hash || result7 || libp) ;
06511 }
06512
06513 static int G__G__G3D_137_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06514 {
06515 G__letint(result7, 67, (long) TELTU::Class_Name());
06516 return(1 || funcname || hash || result7 || libp) ;
06517 }
06518
06519 static int G__G__G3D_137_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06520 {
06521 G__letint(result7, 115, (long) TELTU::Class_Version());
06522 return(1 || funcname || hash || result7 || libp) ;
06523 }
06524
06525 static int G__G__G3D_137_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06526 {
06527 TELTU::Dictionary();
06528 G__setnull(result7);
06529 return(1 || funcname || hash || result7 || libp) ;
06530 }
06531
06532 static int G__G__G3D_137_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06533 {
06534 ((TELTU*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06535 G__setnull(result7);
06536 return(1 || funcname || hash || result7 || libp) ;
06537 }
06538
06539 static int G__G__G3D_137_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06540 {
06541 G__letint(result7, 67, (long) TELTU::DeclFileName());
06542 return(1 || funcname || hash || result7 || libp) ;
06543 }
06544
06545 static int G__G__G3D_137_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06546 {
06547 G__letint(result7, 105, (long) TELTU::ImplFileLine());
06548 return(1 || funcname || hash || result7 || libp) ;
06549 }
06550
06551 static int G__G__G3D_137_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06552 {
06553 G__letint(result7, 67, (long) TELTU::ImplFileName());
06554 return(1 || funcname || hash || result7 || libp) ;
06555 }
06556
06557 static int G__G__G3D_137_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06558 {
06559 G__letint(result7, 105, (long) TELTU::DeclFileLine());
06560 return(1 || funcname || hash || result7 || libp) ;
06561 }
06562
06563
06564 static int G__G__G3D_137_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06565
06566 {
06567 TELTU* p;
06568 void* tmp = (void*) G__int(libp->para[0]);
06569 p = new TELTU(*(TELTU*) tmp);
06570 result7->obj.i = (long) p;
06571 result7->ref = (long) p;
06572 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TELTU));
06573 return(1 || funcname || hash || result7 || libp) ;
06574 }
06575
06576
06577 typedef TELTU G__TTELTU;
06578 static int G__G__G3D_137_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06579 {
06580 char* gvp = (char*) G__getgvp();
06581 long soff = G__getstructoffset();
06582 int n = G__getaryconstruct();
06583
06584
06585
06586
06587
06588 if (!soff) {
06589 return(1);
06590 }
06591 if (n) {
06592 if (gvp == (char*)G__PVOID) {
06593 delete[] (TELTU*) soff;
06594 } else {
06595 G__setgvp((long) G__PVOID);
06596 for (int i = n - 1; i >= 0; --i) {
06597 ((TELTU*) (soff+(sizeof(TELTU)*i)))->~G__TTELTU();
06598 }
06599 G__setgvp((long)gvp);
06600 }
06601 } else {
06602 if (gvp == (char*)G__PVOID) {
06603 delete (TELTU*) soff;
06604 } else {
06605 G__setgvp((long) G__PVOID);
06606 ((TELTU*) (soff))->~G__TTELTU();
06607 G__setgvp((long)gvp);
06608 }
06609 }
06610 G__setnull(result7);
06611 return(1 || funcname || hash || result7 || libp) ;
06612 }
06613
06614
06615
06616 static int G__G__G3D_149_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06617 {
06618 TRotMatrix* p = NULL;
06619 char* gvp = (char*) G__getgvp();
06620 int n = G__getaryconstruct();
06621 if (n) {
06622 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06623 p = new TRotMatrix[n];
06624 } else {
06625 p = new((void*) gvp) TRotMatrix[n];
06626 }
06627 } else {
06628 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06629 p = new TRotMatrix;
06630 } else {
06631 p = new((void*) gvp) TRotMatrix;
06632 }
06633 }
06634 result7->obj.i = (long) p;
06635 result7->ref = (long) p;
06636 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
06637 return(1 || funcname || hash || result7 || libp) ;
06638 }
06639
06640 static int G__G__G3D_149_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06641 {
06642 TRotMatrix* p = NULL;
06643 char* gvp = (char*) G__getgvp();
06644
06645 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06646 p = new TRotMatrix(
06647 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06648 , (Double_t*) G__int(libp->para[2]));
06649 } else {
06650 p = new((void*) gvp) TRotMatrix(
06651 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06652 , (Double_t*) G__int(libp->para[2]));
06653 }
06654 result7->obj.i = (long) p;
06655 result7->ref = (long) p;
06656 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
06657 return(1 || funcname || hash || result7 || libp) ;
06658 }
06659
06660 static int G__G__G3D_149_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06661 {
06662 TRotMatrix* p = NULL;
06663 char* gvp = (char*) G__getgvp();
06664
06665 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06666 p = new TRotMatrix(
06667 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06668 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06669 , (Double_t) G__double(libp->para[4]));
06670 } else {
06671 p = new((void*) gvp) TRotMatrix(
06672 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06673 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06674 , (Double_t) G__double(libp->para[4]));
06675 }
06676 result7->obj.i = (long) p;
06677 result7->ref = (long) p;
06678 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
06679 return(1 || funcname || hash || result7 || libp) ;
06680 }
06681
06682 static int G__G__G3D_149_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06683 {
06684 TRotMatrix* p = NULL;
06685 char* gvp = (char*) G__getgvp();
06686
06687 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06688 p = new TRotMatrix(
06689 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06690 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06691 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
06692 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
06693 } else {
06694 p = new((void*) gvp) TRotMatrix(
06695 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06696 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06697 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
06698 , (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
06699 }
06700 result7->obj.i = (long) p;
06701 result7->ref = (long) p;
06702 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
06703 return(1 || funcname || hash || result7 || libp) ;
06704 }
06705
06706 static int G__G__G3D_149_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06707 {
06708 G__letdouble(result7, 100, (double) ((const TRotMatrix*) G__getstructoffset())->Determinant());
06709 return(1 || funcname || hash || result7 || libp) ;
06710 }
06711
06712 static int G__G__G3D_149_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06713 {
06714 G__letint(result7, 68, (long) ((TRotMatrix*) G__getstructoffset())->GetMatrix());
06715 return(1 || funcname || hash || result7 || libp) ;
06716 }
06717
06718 static int G__G__G3D_149_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06719 {
06720 G__letint(result7, 105, (long) ((const TRotMatrix*) G__getstructoffset())->GetNumber());
06721 return(1 || funcname || hash || result7 || libp) ;
06722 }
06723
06724 static int G__G__G3D_149_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06725 {
06726 G__letint(result7, 105, (long) ((const TRotMatrix*) G__getstructoffset())->GetType());
06727 return(1 || funcname || hash || result7 || libp) ;
06728 }
06729
06730 static int G__G__G3D_149_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06731 {
06732 G__letdouble(result7, 100, (double) ((const TRotMatrix*) G__getstructoffset())->GetTheta());
06733 return(1 || funcname || hash || result7 || libp) ;
06734 }
06735
06736 static int G__G__G3D_149_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06737 {
06738 G__letdouble(result7, 100, (double) ((const TRotMatrix*) G__getstructoffset())->GetPhi());
06739 return(1 || funcname || hash || result7 || libp) ;
06740 }
06741
06742 static int G__G__G3D_149_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06743 {
06744 G__letdouble(result7, 100, (double) ((const TRotMatrix*) G__getstructoffset())->GetPsi());
06745 return(1 || funcname || hash || result7 || libp) ;
06746 }
06747
06748 static int G__G__G3D_149_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06749 {
06750 G__letint(result7, 68, (long) ((const TRotMatrix*) G__getstructoffset())->GetGLMatrix((Double_t*) G__int(libp->para[0])));
06751 return(1 || funcname || hash || result7 || libp) ;
06752 }
06753
06754 static int G__G__G3D_149_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06755 {
06756 G__letint(result7, 103, (long) ((const TRotMatrix*) G__getstructoffset())->IsReflection());
06757 return(1 || funcname || hash || result7 || libp) ;
06758 }
06759
06760 static int G__G__G3D_149_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06761 {
06762 G__letint(result7, 68, (long) ((TRotMatrix*) G__getstructoffset())->SetAngles((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
06763 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
06764 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
06765 return(1 || funcname || hash || result7 || libp) ;
06766 }
06767
06768 static int G__G__G3D_149_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06769 {
06770 ((TRotMatrix*) G__getstructoffset())->SetMatrix((Double_t*) G__int(libp->para[0]));
06771 G__setnull(result7);
06772 return(1 || funcname || hash || result7 || libp) ;
06773 }
06774
06775 static int G__G__G3D_149_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06776 {
06777 G__letint(result7, 85, (long) TRotMatrix::Class());
06778 return(1 || funcname || hash || result7 || libp) ;
06779 }
06780
06781 static int G__G__G3D_149_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06782 {
06783 G__letint(result7, 67, (long) TRotMatrix::Class_Name());
06784 return(1 || funcname || hash || result7 || libp) ;
06785 }
06786
06787 static int G__G__G3D_149_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06788 {
06789 G__letint(result7, 115, (long) TRotMatrix::Class_Version());
06790 return(1 || funcname || hash || result7 || libp) ;
06791 }
06792
06793 static int G__G__G3D_149_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06794 {
06795 TRotMatrix::Dictionary();
06796 G__setnull(result7);
06797 return(1 || funcname || hash || result7 || libp) ;
06798 }
06799
06800 static int G__G__G3D_149_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06801 {
06802 ((TRotMatrix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06803 G__setnull(result7);
06804 return(1 || funcname || hash || result7 || libp) ;
06805 }
06806
06807 static int G__G__G3D_149_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06808 {
06809 G__letint(result7, 67, (long) TRotMatrix::DeclFileName());
06810 return(1 || funcname || hash || result7 || libp) ;
06811 }
06812
06813 static int G__G__G3D_149_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06814 {
06815 G__letint(result7, 105, (long) TRotMatrix::ImplFileLine());
06816 return(1 || funcname || hash || result7 || libp) ;
06817 }
06818
06819 static int G__G__G3D_149_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06820 {
06821 G__letint(result7, 67, (long) TRotMatrix::ImplFileName());
06822 return(1 || funcname || hash || result7 || libp) ;
06823 }
06824
06825 static int G__G__G3D_149_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06826 {
06827 G__letint(result7, 105, (long) TRotMatrix::DeclFileLine());
06828 return(1 || funcname || hash || result7 || libp) ;
06829 }
06830
06831
06832 static int G__G__G3D_149_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06833
06834 {
06835 TRotMatrix* p;
06836 void* tmp = (void*) G__int(libp->para[0]);
06837 p = new TRotMatrix(*(TRotMatrix*) tmp);
06838 result7->obj.i = (long) p;
06839 result7->ref = (long) p;
06840 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
06841 return(1 || funcname || hash || result7 || libp) ;
06842 }
06843
06844
06845 typedef TRotMatrix G__TTRotMatrix;
06846 static int G__G__G3D_149_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06847 {
06848 char* gvp = (char*) G__getgvp();
06849 long soff = G__getstructoffset();
06850 int n = G__getaryconstruct();
06851
06852
06853
06854
06855
06856 if (!soff) {
06857 return(1);
06858 }
06859 if (n) {
06860 if (gvp == (char*)G__PVOID) {
06861 delete[] (TRotMatrix*) soff;
06862 } else {
06863 G__setgvp((long) G__PVOID);
06864 for (int i = n - 1; i >= 0; --i) {
06865 ((TRotMatrix*) (soff+(sizeof(TRotMatrix)*i)))->~G__TTRotMatrix();
06866 }
06867 G__setgvp((long)gvp);
06868 }
06869 } else {
06870 if (gvp == (char*)G__PVOID) {
06871 delete (TRotMatrix*) soff;
06872 } else {
06873 G__setgvp((long) G__PVOID);
06874 ((TRotMatrix*) (soff))->~G__TTRotMatrix();
06875 G__setgvp((long)gvp);
06876 }
06877 }
06878 G__setnull(result7);
06879 return(1 || funcname || hash || result7 || libp) ;
06880 }
06881
06882
06883 static int G__G__G3D_149_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06884 {
06885 TRotMatrix* dest = (TRotMatrix*) G__getstructoffset();
06886 *dest = *(TRotMatrix*) libp->para[0].ref;
06887 const TRotMatrix& obj = *dest;
06888 result7->ref = (long) (&obj);
06889 result7->obj.i = (long) (&obj);
06890 return(1 || funcname || hash || result7 || libp) ;
06891 }
06892
06893
06894
06895 static int G__G__G3D_150_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06896 {
06897 TGeometry* p = NULL;
06898 char* gvp = (char*) G__getgvp();
06899 int n = G__getaryconstruct();
06900 if (n) {
06901 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06902 p = new TGeometry[n];
06903 } else {
06904 p = new((void*) gvp) TGeometry[n];
06905 }
06906 } else {
06907 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06908 p = new TGeometry;
06909 } else {
06910 p = new((void*) gvp) TGeometry;
06911 }
06912 }
06913 result7->obj.i = (long) p;
06914 result7->ref = (long) p;
06915 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TGeometry));
06916 return(1 || funcname || hash || result7 || libp) ;
06917 }
06918
06919 static int G__G__G3D_150_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06920 {
06921 TGeometry* p = NULL;
06922 char* gvp = (char*) G__getgvp();
06923
06924 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06925 p = new TGeometry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06926 } else {
06927 p = new((void*) gvp) TGeometry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06928 }
06929 result7->obj.i = (long) p;
06930 result7->ref = (long) p;
06931 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TGeometry));
06932 return(1 || funcname || hash || result7 || libp) ;
06933 }
06934
06935 static int G__G__G3D_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06936 {
06937 switch (libp->paran) {
06938 case 1:
06939 ((TGeometry*) G__getstructoffset())->cd((const char*) G__int(libp->para[0]));
06940 G__setnull(result7);
06941 break;
06942 case 0:
06943 ((TGeometry*) G__getstructoffset())->cd();
06944 G__setnull(result7);
06945 break;
06946 }
06947 return(1 || funcname || hash || result7 || libp) ;
06948 }
06949
06950 static int G__G__G3D_150_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06951 {
06952 G__letdouble(result7, 102, (double) ((const TGeometry*) G__getstructoffset())->GetBomb());
06953 return(1 || funcname || hash || result7 || libp) ;
06954 }
06955
06956 static int G__G__G3D_150_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06957 {
06958 G__letint(result7, 105, (long) ((const TGeometry*) G__getstructoffset())->GeomLevel());
06959 return(1 || funcname || hash || result7 || libp) ;
06960 }
06961
06962 static int G__G__G3D_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06963 {
06964 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetListOfShapes());
06965 return(1 || funcname || hash || result7 || libp) ;
06966 }
06967
06968 static int G__G__G3D_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06969 {
06970 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetListOfNodes());
06971 return(1 || funcname || hash || result7 || libp) ;
06972 }
06973
06974 static int G__G__G3D_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06975 {
06976 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetListOfMaterials());
06977 return(1 || funcname || hash || result7 || libp) ;
06978 }
06979
06980 static int G__G__G3D_150_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06981 {
06982 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetListOfMatrices());
06983 return(1 || funcname || hash || result7 || libp) ;
06984 }
06985
06986 static int G__G__G3D_150_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06987 {
06988 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetCurrentNode());
06989 return(1 || funcname || hash || result7 || libp) ;
06990 }
06991
06992 static int G__G__G3D_150_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06993 {
06994 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetMaterial((const char*) G__int(libp->para[0])));
06995 return(1 || funcname || hash || result7 || libp) ;
06996 }
06997
06998 static int G__G__G3D_150_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06999 {
07000 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetMaterialByNumber((Int_t) G__int(libp->para[0])));
07001 return(1 || funcname || hash || result7 || libp) ;
07002 }
07003
07004 static int G__G__G3D_150_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07005 {
07006 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetNode((const char*) G__int(libp->para[0])));
07007 return(1 || funcname || hash || result7 || libp) ;
07008 }
07009
07010 static int G__G__G3D_150_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07011 {
07012 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetShape((const char*) G__int(libp->para[0])));
07013 return(1 || funcname || hash || result7 || libp) ;
07014 }
07015
07016 static int G__G__G3D_150_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07017 {
07018 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetShapeByNumber((Int_t) G__int(libp->para[0])));
07019 return(1 || funcname || hash || result7 || libp) ;
07020 }
07021
07022 static int G__G__G3D_150_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07023 {
07024 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetRotMatrix((const char*) G__int(libp->para[0])));
07025 return(1 || funcname || hash || result7 || libp) ;
07026 }
07027
07028 static int G__G__G3D_150_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07029 {
07030 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetRotMatrixByNumber((Int_t) G__int(libp->para[0])));
07031 return(1 || funcname || hash || result7 || libp) ;
07032 }
07033
07034 static int G__G__G3D_150_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07035 {
07036 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetCurrentMatrix());
07037 return(1 || funcname || hash || result7 || libp) ;
07038 }
07039
07040 static int G__G__G3D_150_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07041 {
07042 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetCurrentPosition((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07043 , (Double_t*) G__int(libp->para[2])));
07044 return(1 || funcname || hash || result7 || libp) ;
07045 }
07046
07047 static int G__G__G3D_150_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07048 {
07049 G__letint(result7, 85, (long) ((const TGeometry*) G__getstructoffset())->GetCurrentPosition((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07050 , (Float_t*) G__int(libp->para[2])));
07051 return(1 || funcname || hash || result7 || libp) ;
07052 }
07053
07054 static int G__G__G3D_150_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07055 {
07056 G__letint(result7, 103, (long) ((const TGeometry*) G__getstructoffset())->GetCurrentReflection());
07057 return(1 || funcname || hash || result7 || libp) ;
07058 }
07059
07060 static int G__G__G3D_150_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07061 {
07062 ((TGeometry*) G__getstructoffset())->Local2Master((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
07063 G__setnull(result7);
07064 return(1 || funcname || hash || result7 || libp) ;
07065 }
07066
07067 static int G__G__G3D_150_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07068 {
07069 ((TGeometry*) G__getstructoffset())->Local2Master((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
07070 G__setnull(result7);
07071 return(1 || funcname || hash || result7 || libp) ;
07072 }
07073
07074 static int G__G__G3D_150_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07075 {
07076 ((TGeometry*) G__getstructoffset())->Master2Local((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
07077 G__setnull(result7);
07078 return(1 || funcname || hash || result7 || libp) ;
07079 }
07080
07081 static int G__G__G3D_150_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07082 {
07083 ((TGeometry*) G__getstructoffset())->Master2Local((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
07084 G__setnull(result7);
07085 return(1 || funcname || hash || result7 || libp) ;
07086 }
07087
07088 static int G__G__G3D_150_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07089 {
07090 switch (libp->paran) {
07091 case 8:
07092 ((TGeometry*) G__getstructoffset())->Node(
07093 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07094 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
07095 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
07096 , (const char*) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7]));
07097 G__setnull(result7);
07098 break;
07099 case 7:
07100 ((TGeometry*) G__getstructoffset())->Node(
07101 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07102 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
07103 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
07104 , (const char*) G__int(libp->para[6]));
07105 G__setnull(result7);
07106 break;
07107 case 6:
07108 ((TGeometry*) G__getstructoffset())->Node((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07109 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
07110 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
07111 G__setnull(result7);
07112 break;
07113 case 5:
07114 ((TGeometry*) G__getstructoffset())->Node((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07115 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
07116 , (Double_t) G__double(libp->para[4]));
07117 G__setnull(result7);
07118 break;
07119 case 4:
07120 ((TGeometry*) G__getstructoffset())->Node((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07121 , (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
07122 G__setnull(result7);
07123 break;
07124 case 3:
07125 ((TGeometry*) G__getstructoffset())->Node((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07126 , (const char*) G__int(libp->para[2]));
07127 G__setnull(result7);
07128 break;
07129 }
07130 return(1 || funcname || hash || result7 || libp) ;
07131 }
07132
07133 static int G__G__G3D_150_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07134 {
07135 G__letint(result7, 105, (long) ((TGeometry*) G__getstructoffset())->PushLevel());
07136 return(1 || funcname || hash || result7 || libp) ;
07137 }
07138
07139 static int G__G__G3D_150_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07140 {
07141 G__letint(result7, 105, (long) ((TGeometry*) G__getstructoffset())->PopLevel());
07142 return(1 || funcname || hash || result7 || libp) ;
07143 }
07144
07145 static int G__G__G3D_150_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07146 {
07147 switch (libp->paran) {
07148 case 1:
07149 ((TGeometry*) G__getstructoffset())->SetBomb((Float_t) G__double(libp->para[0]));
07150 G__setnull(result7);
07151 break;
07152 case 0:
07153 ((TGeometry*) G__getstructoffset())->SetBomb();
07154 G__setnull(result7);
07155 break;
07156 }
07157 return(1 || funcname || hash || result7 || libp) ;
07158 }
07159
07160 static int G__G__G3D_150_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07161 {
07162 ((TGeometry*) G__getstructoffset())->SetCurrentNode((TNode*) G__int(libp->para[0]));
07163 G__setnull(result7);
07164 return(1 || funcname || hash || result7 || libp) ;
07165 }
07166
07167 static int G__G__G3D_150_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07168 {
07169 switch (libp->paran) {
07170 case 1:
07171 ((TGeometry*) G__getstructoffset())->SetGeomLevel((Int_t) G__int(libp->para[0]));
07172 G__setnull(result7);
07173 break;
07174 case 0:
07175 ((TGeometry*) G__getstructoffset())->SetGeomLevel();
07176 G__setnull(result7);
07177 break;
07178 }
07179 return(1 || funcname || hash || result7 || libp) ;
07180 }
07181
07182 static int G__G__G3D_150_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07183 {
07184 switch (libp->paran) {
07185 case 1:
07186 ((TGeometry*) G__getstructoffset())->SetMatrix((TRotMatrix*) G__int(libp->para[0]));
07187 G__setnull(result7);
07188 break;
07189 case 0:
07190 ((TGeometry*) G__getstructoffset())->SetMatrix();
07191 G__setnull(result7);
07192 break;
07193 }
07194 return(1 || funcname || hash || result7 || libp) ;
07195 }
07196
07197 static int G__G__G3D_150_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07198 {
07199 switch (libp->paran) {
07200 case 4:
07201 ((TGeometry*) G__getstructoffset())->SetPosition((TRotMatrix*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
07202 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
07203 G__setnull(result7);
07204 break;
07205 case 3:
07206 ((TGeometry*) G__getstructoffset())->SetPosition((TRotMatrix*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
07207 , (Double_t) G__double(libp->para[2]));
07208 G__setnull(result7);
07209 break;
07210 case 2:
07211 ((TGeometry*) G__getstructoffset())->SetPosition((TRotMatrix*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
07212 G__setnull(result7);
07213 break;
07214 case 1:
07215 ((TGeometry*) G__getstructoffset())->SetPosition((TRotMatrix*) G__int(libp->para[0]));
07216 G__setnull(result7);
07217 break;
07218 }
07219 return(1 || funcname || hash || result7 || libp) ;
07220 }
07221
07222 static int G__G__G3D_150_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07223 {
07224 ((TGeometry*) G__getstructoffset())->SetPosition((TRotMatrix*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
07225 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
07226 G__setnull(result7);
07227 return(1 || funcname || hash || result7 || libp) ;
07228 }
07229
07230 static int G__G__G3D_150_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07231 {
07232 ((TGeometry*) G__getstructoffset())->SetPosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
07233 , (Double_t) G__double(libp->para[2]));
07234 G__setnull(result7);
07235 return(1 || funcname || hash || result7 || libp) ;
07236 }
07237
07238 static int G__G__G3D_150_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07239 {
07240 ((TGeometry*) G__getstructoffset())->SetPosition((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
07241 , (Float_t) G__double(libp->para[2]));
07242 G__setnull(result7);
07243 return(1 || funcname || hash || result7 || libp) ;
07244 }
07245
07246 static int G__G__G3D_150_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07247 {
07248 ((TGeometry*) G__getstructoffset())->UpdateMatrix((TNode*) G__int(libp->para[0]));
07249 G__setnull(result7);
07250 return(1 || funcname || hash || result7 || libp) ;
07251 }
07252
07253 static int G__G__G3D_150_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07254 {
07255 switch (libp->paran) {
07256 case 4:
07257 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
07258 , (Double_t) G__double(libp->para[2]), (TRotMatrix*) G__int(libp->para[3]));
07259 G__setnull(result7);
07260 break;
07261 case 3:
07262 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
07263 , (Double_t) G__double(libp->para[2]));
07264 G__setnull(result7);
07265 break;
07266 case 2:
07267 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
07268 G__setnull(result7);
07269 break;
07270 case 1:
07271 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix((Double_t) G__double(libp->para[0]));
07272 G__setnull(result7);
07273 break;
07274 case 0:
07275 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix();
07276 G__setnull(result7);
07277 break;
07278 }
07279 return(1 || funcname || hash || result7 || libp) ;
07280 }
07281
07282 static int G__G__G3D_150_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07283 {
07284 switch (libp->paran) {
07285 case 5:
07286 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
07287 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
07288 , (Bool_t) G__int(libp->para[4]));
07289 G__setnull(result7);
07290 break;
07291 case 4:
07292 ((TGeometry*) G__getstructoffset())->UpdateTempMatrix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
07293 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
07294 G__setnull(result7);
07295 break;
07296 }
07297 return(1 || funcname || hash || result7 || libp) ;
07298 }
07299
07300 static int G__G__G3D_150_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07301 {
07302 G__letint(result7, 85, (long) TGeometry::Get((const char*) G__int(libp->para[0])));
07303 return(1 || funcname || hash || result7 || libp) ;
07304 }
07305
07306 static int G__G__G3D_150_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07307 {
07308 TGeometry::UpdateTempMatrix(
07309 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07310 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
07311 , (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])
07312 , (Double_t*) G__int(libp->para[6]), (Double_t*) G__int(libp->para[7]));
07313 G__setnull(result7);
07314 return(1 || funcname || hash || result7 || libp) ;
07315 }
07316
07317 static int G__G__G3D_150_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07318 {
07319 G__letint(result7, 85, (long) TGeometry::Class());
07320 return(1 || funcname || hash || result7 || libp) ;
07321 }
07322
07323 static int G__G__G3D_150_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07324 {
07325 G__letint(result7, 67, (long) TGeometry::Class_Name());
07326 return(1 || funcname || hash || result7 || libp) ;
07327 }
07328
07329 static int G__G__G3D_150_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07330 {
07331 G__letint(result7, 115, (long) TGeometry::Class_Version());
07332 return(1 || funcname || hash || result7 || libp) ;
07333 }
07334
07335 static int G__G__G3D_150_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07336 {
07337 TGeometry::Dictionary();
07338 G__setnull(result7);
07339 return(1 || funcname || hash || result7 || libp) ;
07340 }
07341
07342 static int G__G__G3D_150_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07343 {
07344 ((TGeometry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07345 G__setnull(result7);
07346 return(1 || funcname || hash || result7 || libp) ;
07347 }
07348
07349 static int G__G__G3D_150_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07350 {
07351 G__letint(result7, 67, (long) TGeometry::DeclFileName());
07352 return(1 || funcname || hash || result7 || libp) ;
07353 }
07354
07355 static int G__G__G3D_150_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07356 {
07357 G__letint(result7, 105, (long) TGeometry::ImplFileLine());
07358 return(1 || funcname || hash || result7 || libp) ;
07359 }
07360
07361 static int G__G__G3D_150_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07362 {
07363 G__letint(result7, 67, (long) TGeometry::ImplFileName());
07364 return(1 || funcname || hash || result7 || libp) ;
07365 }
07366
07367 static int G__G__G3D_150_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07368 {
07369 G__letint(result7, 105, (long) TGeometry::DeclFileLine());
07370 return(1 || funcname || hash || result7 || libp) ;
07371 }
07372
07373
07374 typedef TGeometry G__TTGeometry;
07375 static int G__G__G3D_150_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07376 {
07377 char* gvp = (char*) G__getgvp();
07378 long soff = G__getstructoffset();
07379 int n = G__getaryconstruct();
07380
07381
07382
07383
07384
07385 if (!soff) {
07386 return(1);
07387 }
07388 if (n) {
07389 if (gvp == (char*)G__PVOID) {
07390 delete[] (TGeometry*) soff;
07391 } else {
07392 G__setgvp((long) G__PVOID);
07393 for (int i = n - 1; i >= 0; --i) {
07394 ((TGeometry*) (soff+(sizeof(TGeometry)*i)))->~G__TTGeometry();
07395 }
07396 G__setgvp((long)gvp);
07397 }
07398 } else {
07399 if (gvp == (char*)G__PVOID) {
07400 delete (TGeometry*) soff;
07401 } else {
07402 G__setgvp((long) G__PVOID);
07403 ((TGeometry*) (soff))->~G__TTGeometry();
07404 G__setgvp((long)gvp);
07405 }
07406 }
07407 G__setnull(result7);
07408 return(1 || funcname || hash || result7 || libp) ;
07409 }
07410
07411
07412
07413 static int G__G__G3D_151_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07414 {
07415 TGTRA* p = NULL;
07416 char* gvp = (char*) G__getgvp();
07417 int n = G__getaryconstruct();
07418 if (n) {
07419 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07420 p = new TGTRA[n];
07421 } else {
07422 p = new((void*) gvp) TGTRA[n];
07423 }
07424 } else {
07425 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07426 p = new TGTRA;
07427 } else {
07428 p = new((void*) gvp) TGTRA;
07429 }
07430 }
07431 result7->obj.i = (long) p;
07432 result7->ref = (long) p;
07433 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TGTRA));
07434 return(1 || funcname || hash || result7 || libp) ;
07435 }
07436
07437 static int G__G__G3D_151_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07438 {
07439 TGTRA* p = NULL;
07440 char* gvp = (char*) G__getgvp();
07441
07442 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07443 p = new TGTRA(
07444 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07445 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
07446 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
07447 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
07448 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
07449 , (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
07450 , (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13])
07451 , (Float_t) G__double(libp->para[14]));
07452 } else {
07453 p = new((void*) gvp) TGTRA(
07454 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07455 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
07456 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
07457 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
07458 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
07459 , (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
07460 , (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13])
07461 , (Float_t) G__double(libp->para[14]));
07462 }
07463 result7->obj.i = (long) p;
07464 result7->ref = (long) p;
07465 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TGTRA));
07466 return(1 || funcname || hash || result7 || libp) ;
07467 }
07468
07469 static int G__G__G3D_151_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07470 {
07471 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetTwist());
07472 return(1 || funcname || hash || result7 || libp) ;
07473 }
07474
07475 static int G__G__G3D_151_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07476 {
07477 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetH1());
07478 return(1 || funcname || hash || result7 || libp) ;
07479 }
07480
07481 static int G__G__G3D_151_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07482 {
07483 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetBl1());
07484 return(1 || funcname || hash || result7 || libp) ;
07485 }
07486
07487 static int G__G__G3D_151_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07488 {
07489 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetTl1());
07490 return(1 || funcname || hash || result7 || libp) ;
07491 }
07492
07493 static int G__G__G3D_151_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07494 {
07495 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetAlpha1());
07496 return(1 || funcname || hash || result7 || libp) ;
07497 }
07498
07499 static int G__G__G3D_151_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07500 {
07501 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetH2());
07502 return(1 || funcname || hash || result7 || libp) ;
07503 }
07504
07505 static int G__G__G3D_151_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07506 {
07507 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetBl2());
07508 return(1 || funcname || hash || result7 || libp) ;
07509 }
07510
07511 static int G__G__G3D_151_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07512 {
07513 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetTl2());
07514 return(1 || funcname || hash || result7 || libp) ;
07515 }
07516
07517 static int G__G__G3D_151_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07518 {
07519 G__letdouble(result7, 102, (double) ((const TGTRA*) G__getstructoffset())->GetAlpha2());
07520 return(1 || funcname || hash || result7 || libp) ;
07521 }
07522
07523 static int G__G__G3D_151_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07524 {
07525 G__letint(result7, 85, (long) TGTRA::Class());
07526 return(1 || funcname || hash || result7 || libp) ;
07527 }
07528
07529 static int G__G__G3D_151_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07530 {
07531 G__letint(result7, 67, (long) TGTRA::Class_Name());
07532 return(1 || funcname || hash || result7 || libp) ;
07533 }
07534
07535 static int G__G__G3D_151_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07536 {
07537 G__letint(result7, 115, (long) TGTRA::Class_Version());
07538 return(1 || funcname || hash || result7 || libp) ;
07539 }
07540
07541 static int G__G__G3D_151_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07542 {
07543 TGTRA::Dictionary();
07544 G__setnull(result7);
07545 return(1 || funcname || hash || result7 || libp) ;
07546 }
07547
07548 static int G__G__G3D_151_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07549 {
07550 ((TGTRA*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07551 G__setnull(result7);
07552 return(1 || funcname || hash || result7 || libp) ;
07553 }
07554
07555 static int G__G__G3D_151_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07556 {
07557 G__letint(result7, 67, (long) TGTRA::DeclFileName());
07558 return(1 || funcname || hash || result7 || libp) ;
07559 }
07560
07561 static int G__G__G3D_151_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07562 {
07563 G__letint(result7, 105, (long) TGTRA::ImplFileLine());
07564 return(1 || funcname || hash || result7 || libp) ;
07565 }
07566
07567 static int G__G__G3D_151_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07568 {
07569 G__letint(result7, 67, (long) TGTRA::ImplFileName());
07570 return(1 || funcname || hash || result7 || libp) ;
07571 }
07572
07573 static int G__G__G3D_151_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07574 {
07575 G__letint(result7, 105, (long) TGTRA::DeclFileLine());
07576 return(1 || funcname || hash || result7 || libp) ;
07577 }
07578
07579
07580 static int G__G__G3D_151_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07581
07582 {
07583 TGTRA* p;
07584 void* tmp = (void*) G__int(libp->para[0]);
07585 p = new TGTRA(*(TGTRA*) tmp);
07586 result7->obj.i = (long) p;
07587 result7->ref = (long) p;
07588 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TGTRA));
07589 return(1 || funcname || hash || result7 || libp) ;
07590 }
07591
07592
07593 typedef TGTRA G__TTGTRA;
07594 static int G__G__G3D_151_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07595 {
07596 char* gvp = (char*) G__getgvp();
07597 long soff = G__getstructoffset();
07598 int n = G__getaryconstruct();
07599
07600
07601
07602
07603
07604 if (!soff) {
07605 return(1);
07606 }
07607 if (n) {
07608 if (gvp == (char*)G__PVOID) {
07609 delete[] (TGTRA*) soff;
07610 } else {
07611 G__setgvp((long) G__PVOID);
07612 for (int i = n - 1; i >= 0; --i) {
07613 ((TGTRA*) (soff+(sizeof(TGTRA)*i)))->~G__TTGTRA();
07614 }
07615 G__setgvp((long)gvp);
07616 }
07617 } else {
07618 if (gvp == (char*)G__PVOID) {
07619 delete (TGTRA*) soff;
07620 } else {
07621 G__setgvp((long) G__PVOID);
07622 ((TGTRA*) (soff))->~G__TTGTRA();
07623 G__setgvp((long)gvp);
07624 }
07625 }
07626 G__setnull(result7);
07627 return(1 || funcname || hash || result7 || libp) ;
07628 }
07629
07630
07631 static int G__G__G3D_151_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07632 {
07633 TGTRA* dest = (TGTRA*) G__getstructoffset();
07634 *dest = *(TGTRA*) libp->para[0].ref;
07635 const TGTRA& obj = *dest;
07636 result7->ref = (long) (&obj);
07637 result7->obj.i = (long) (&obj);
07638 return(1 || funcname || hash || result7 || libp) ;
07639 }
07640
07641
07642
07643 static int G__G__G3D_152_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07644 {
07645 TPolyLine3D* p = NULL;
07646 char* gvp = (char*) G__getgvp();
07647 int n = G__getaryconstruct();
07648 if (n) {
07649 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07650 p = new TPolyLine3D[n];
07651 } else {
07652 p = new((void*) gvp) TPolyLine3D[n];
07653 }
07654 } else {
07655 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07656 p = new TPolyLine3D;
07657 } else {
07658 p = new((void*) gvp) TPolyLine3D;
07659 }
07660 }
07661 result7->obj.i = (long) p;
07662 result7->ref = (long) p;
07663 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07664 return(1 || funcname || hash || result7 || libp) ;
07665 }
07666
07667 static int G__G__G3D_152_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07668 {
07669 TPolyLine3D* p = NULL;
07670 char* gvp = (char*) G__getgvp();
07671 switch (libp->paran) {
07672 case 2:
07673
07674 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07675 p = new TPolyLine3D((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
07676 } else {
07677 p = new((void*) gvp) TPolyLine3D((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
07678 }
07679 break;
07680 case 1:
07681
07682 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07683 p = new TPolyLine3D((Int_t) G__int(libp->para[0]));
07684 } else {
07685 p = new((void*) gvp) TPolyLine3D((Int_t) G__int(libp->para[0]));
07686 }
07687 break;
07688 }
07689 result7->obj.i = (long) p;
07690 result7->ref = (long) p;
07691 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07692 return(1 || funcname || hash || result7 || libp) ;
07693 }
07694
07695 static int G__G__G3D_152_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07696 {
07697 TPolyLine3D* p = NULL;
07698 char* gvp = (char*) G__getgvp();
07699 switch (libp->paran) {
07700 case 3:
07701
07702 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07703 p = new TPolyLine3D(
07704 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07705 , (Option_t*) G__int(libp->para[2]));
07706 } else {
07707 p = new((void*) gvp) TPolyLine3D(
07708 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07709 , (Option_t*) G__int(libp->para[2]));
07710 }
07711 break;
07712 case 2:
07713
07714 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07715 p = new TPolyLine3D((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
07716 } else {
07717 p = new((void*) gvp) TPolyLine3D((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
07718 }
07719 break;
07720 }
07721 result7->obj.i = (long) p;
07722 result7->ref = (long) p;
07723 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07724 return(1 || funcname || hash || result7 || libp) ;
07725 }
07726
07727 static int G__G__G3D_152_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07728 {
07729 TPolyLine3D* p = NULL;
07730 char* gvp = (char*) G__getgvp();
07731 switch (libp->paran) {
07732 case 3:
07733
07734 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07735 p = new TPolyLine3D(
07736 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07737 , (Option_t*) G__int(libp->para[2]));
07738 } else {
07739 p = new((void*) gvp) TPolyLine3D(
07740 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07741 , (Option_t*) G__int(libp->para[2]));
07742 }
07743 break;
07744 case 2:
07745
07746 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07747 p = new TPolyLine3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
07748 } else {
07749 p = new((void*) gvp) TPolyLine3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
07750 }
07751 break;
07752 }
07753 result7->obj.i = (long) p;
07754 result7->ref = (long) p;
07755 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07756 return(1 || funcname || hash || result7 || libp) ;
07757 }
07758
07759 static int G__G__G3D_152_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07760 {
07761 TPolyLine3D* p = NULL;
07762 char* gvp = (char*) G__getgvp();
07763 switch (libp->paran) {
07764 case 5:
07765
07766 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07767 p = new TPolyLine3D(
07768 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07769 , (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
07770 , (Option_t*) G__int(libp->para[4]));
07771 } else {
07772 p = new((void*) gvp) TPolyLine3D(
07773 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07774 , (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
07775 , (Option_t*) G__int(libp->para[4]));
07776 }
07777 break;
07778 case 4:
07779
07780 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07781 p = new TPolyLine3D(
07782 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07783 , (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
07784 } else {
07785 p = new((void*) gvp) TPolyLine3D(
07786 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07787 , (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
07788 }
07789 break;
07790 }
07791 result7->obj.i = (long) p;
07792 result7->ref = (long) p;
07793 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07794 return(1 || funcname || hash || result7 || libp) ;
07795 }
07796
07797 static int G__G__G3D_152_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07798 {
07799 TPolyLine3D* p = NULL;
07800 char* gvp = (char*) G__getgvp();
07801 switch (libp->paran) {
07802 case 5:
07803
07804 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07805 p = new TPolyLine3D(
07806 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07807 , (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
07808 , (Option_t*) G__int(libp->para[4]));
07809 } else {
07810 p = new((void*) gvp) TPolyLine3D(
07811 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07812 , (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
07813 , (Option_t*) G__int(libp->para[4]));
07814 }
07815 break;
07816 case 4:
07817
07818 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07819 p = new TPolyLine3D(
07820 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07821 , (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
07822 } else {
07823 p = new((void*) gvp) TPolyLine3D(
07824 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07825 , (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
07826 }
07827 break;
07828 }
07829 result7->obj.i = (long) p;
07830 result7->ref = (long) p;
07831 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07832 return(1 || funcname || hash || result7 || libp) ;
07833 }
07834
07835 static int G__G__G3D_152_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07836 {
07837 TPolyLine3D* p = NULL;
07838 char* gvp = (char*) G__getgvp();
07839
07840 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07841 p = new TPolyLine3D(*(TPolyLine3D*) libp->para[0].ref);
07842 } else {
07843 p = new((void*) gvp) TPolyLine3D(*(TPolyLine3D*) libp->para[0].ref);
07844 }
07845 result7->obj.i = (long) p;
07846 result7->ref = (long) p;
07847 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
07848 return(1 || funcname || hash || result7 || libp) ;
07849 }
07850
07851 static int G__G__G3D_152_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07852 {
07853 {
07854 const TPolyLine3D& obj = ((TPolyLine3D*) G__getstructoffset())->operator=(*(TPolyLine3D*) libp->para[0].ref);
07855 result7->ref = (long) (&obj);
07856 result7->obj.i = (long) (&obj);
07857 }
07858 return(1 || funcname || hash || result7 || libp) ;
07859 }
07860
07861 static int G__G__G3D_152_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07862 {
07863 switch (libp->paran) {
07864 case 3:
07865 ((TPolyLine3D*) G__getstructoffset())->DrawPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07866 , (Option_t*) G__int(libp->para[2]));
07867 G__setnull(result7);
07868 break;
07869 case 2:
07870 ((TPolyLine3D*) G__getstructoffset())->DrawPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
07871 G__setnull(result7);
07872 break;
07873 }
07874 return(1 || funcname || hash || result7 || libp) ;
07875 }
07876
07877 static int G__G__G3D_152_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07878 {
07879 G__letint(result7, 105, (long) ((const TPolyLine3D*) G__getstructoffset())->GetLastPoint());
07880 return(1 || funcname || hash || result7 || libp) ;
07881 }
07882
07883 static int G__G__G3D_152_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07884 {
07885 G__letint(result7, 105, (long) ((const TPolyLine3D*) G__getstructoffset())->GetN());
07886 return(1 || funcname || hash || result7 || libp) ;
07887 }
07888
07889 static int G__G__G3D_152_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07890 {
07891 G__letint(result7, 70, (long) ((const TPolyLine3D*) G__getstructoffset())->GetP());
07892 return(1 || funcname || hash || result7 || libp) ;
07893 }
07894
07895 static int G__G__G3D_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07896 {
07897 G__letint(result7, 105, (long) ((TPolyLine3D*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
07898 return(1 || funcname || hash || result7 || libp) ;
07899 }
07900
07901 static int G__G__G3D_152_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07902 {
07903 G__letint(result7, 105, (long) ((TPolyLine3D*) G__getstructoffset())->SetNextPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
07904 , (Double_t) G__double(libp->para[2])));
07905 return(1 || funcname || hash || result7 || libp) ;
07906 }
07907
07908 static int G__G__G3D_152_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07909 {
07910 switch (libp->paran) {
07911 case 1:
07912 ((TPolyLine3D*) G__getstructoffset())->SetOption((Option_t*) G__int(libp->para[0]));
07913 G__setnull(result7);
07914 break;
07915 case 0:
07916 ((TPolyLine3D*) G__getstructoffset())->SetOption();
07917 G__setnull(result7);
07918 break;
07919 }
07920 return(1 || funcname || hash || result7 || libp) ;
07921 }
07922
07923 static int G__G__G3D_152_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07924 {
07925 ((TPolyLine3D*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
07926 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
07927 G__setnull(result7);
07928 return(1 || funcname || hash || result7 || libp) ;
07929 }
07930
07931 static int G__G__G3D_152_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07932 {
07933 switch (libp->paran) {
07934 case 2:
07935 ((TPolyLine3D*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
07936 G__setnull(result7);
07937 break;
07938 case 1:
07939 ((TPolyLine3D*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]));
07940 G__setnull(result7);
07941 break;
07942 }
07943 return(1 || funcname || hash || result7 || libp) ;
07944 }
07945
07946 static int G__G__G3D_152_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07947 {
07948 switch (libp->paran) {
07949 case 3:
07950 ((TPolyLine3D*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
07951 , (Option_t*) G__int(libp->para[2]));
07952 G__setnull(result7);
07953 break;
07954 case 2:
07955 ((TPolyLine3D*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
07956 G__setnull(result7);
07957 break;
07958 }
07959 return(1 || funcname || hash || result7 || libp) ;
07960 }
07961
07962 static int G__G__G3D_152_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07963 {
07964 switch (libp->paran) {
07965 case 3:
07966 ((TPolyLine3D*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07967 , (Option_t*) G__int(libp->para[2]));
07968 G__setnull(result7);
07969 break;
07970 case 2:
07971 ((TPolyLine3D*) G__getstructoffset())->SetPolyLine((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
07972 G__setnull(result7);
07973 break;
07974 }
07975 return(1 || funcname || hash || result7 || libp) ;
07976 }
07977
07978 static int G__G__G3D_152_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07979 {
07980 G__letint(result7, 105, (long) ((const TPolyLine3D*) G__getstructoffset())->Size());
07981 return(1 || funcname || hash || result7 || libp) ;
07982 }
07983
07984 static int G__G__G3D_152_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07985 {
07986 TPolyLine3D::DrawOutlineCube((TList*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
07987 , (Double_t*) G__int(libp->para[2]));
07988 G__setnull(result7);
07989 return(1 || funcname || hash || result7 || libp) ;
07990 }
07991
07992 static int G__G__G3D_152_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07993 {
07994 G__letint(result7, 85, (long) TPolyLine3D::Class());
07995 return(1 || funcname || hash || result7 || libp) ;
07996 }
07997
07998 static int G__G__G3D_152_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07999 {
08000 G__letint(result7, 67, (long) TPolyLine3D::Class_Name());
08001 return(1 || funcname || hash || result7 || libp) ;
08002 }
08003
08004 static int G__G__G3D_152_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08005 {
08006 G__letint(result7, 115, (long) TPolyLine3D::Class_Version());
08007 return(1 || funcname || hash || result7 || libp) ;
08008 }
08009
08010 static int G__G__G3D_152_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08011 {
08012 TPolyLine3D::Dictionary();
08013 G__setnull(result7);
08014 return(1 || funcname || hash || result7 || libp) ;
08015 }
08016
08017 static int G__G__G3D_152_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08018 {
08019 ((TPolyLine3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08020 G__setnull(result7);
08021 return(1 || funcname || hash || result7 || libp) ;
08022 }
08023
08024 static int G__G__G3D_152_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08025 {
08026 G__letint(result7, 67, (long) TPolyLine3D::DeclFileName());
08027 return(1 || funcname || hash || result7 || libp) ;
08028 }
08029
08030 static int G__G__G3D_152_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08031 {
08032 G__letint(result7, 105, (long) TPolyLine3D::ImplFileLine());
08033 return(1 || funcname || hash || result7 || libp) ;
08034 }
08035
08036 static int G__G__G3D_152_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08037 {
08038 G__letint(result7, 67, (long) TPolyLine3D::ImplFileName());
08039 return(1 || funcname || hash || result7 || libp) ;
08040 }
08041
08042 static int G__G__G3D_152_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08043 {
08044 G__letint(result7, 105, (long) TPolyLine3D::DeclFileLine());
08045 return(1 || funcname || hash || result7 || libp) ;
08046 }
08047
08048
08049 typedef TPolyLine3D G__TTPolyLine3D;
08050 static int G__G__G3D_152_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08051 {
08052 char* gvp = (char*) G__getgvp();
08053 long soff = G__getstructoffset();
08054 int n = G__getaryconstruct();
08055
08056
08057
08058
08059
08060 if (!soff) {
08061 return(1);
08062 }
08063 if (n) {
08064 if (gvp == (char*)G__PVOID) {
08065 delete[] (TPolyLine3D*) soff;
08066 } else {
08067 G__setgvp((long) G__PVOID);
08068 for (int i = n - 1; i >= 0; --i) {
08069 ((TPolyLine3D*) (soff+(sizeof(TPolyLine3D)*i)))->~G__TTPolyLine3D();
08070 }
08071 G__setgvp((long)gvp);
08072 }
08073 } else {
08074 if (gvp == (char*)G__PVOID) {
08075 delete (TPolyLine3D*) soff;
08076 } else {
08077 G__setgvp((long) G__PVOID);
08078 ((TPolyLine3D*) (soff))->~G__TTPolyLine3D();
08079 G__setgvp((long)gvp);
08080 }
08081 }
08082 G__setnull(result7);
08083 return(1 || funcname || hash || result7 || libp) ;
08084 }
08085
08086
08087
08088 static int G__G__G3D_155_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08089 {
08090 THelix* p = NULL;
08091 char* gvp = (char*) G__getgvp();
08092 int n = G__getaryconstruct();
08093 if (n) {
08094 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08095 p = new THelix[n];
08096 } else {
08097 p = new((void*) gvp) THelix[n];
08098 }
08099 } else {
08100 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08101 p = new THelix;
08102 } else {
08103 p = new((void*) gvp) THelix;
08104 }
08105 }
08106 result7->obj.i = (long) p;
08107 result7->ref = (long) p;
08108 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THelix));
08109 return(1 || funcname || hash || result7 || libp) ;
08110 }
08111
08112 static int G__G__G3D_155_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08113 {
08114 THelix* p = NULL;
08115 char* gvp = (char*) G__getgvp();
08116
08117 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08118 p = new THelix(
08119 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
08120 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
08121 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
08122 , (Double_t) G__double(libp->para[6]));
08123 } else {
08124 p = new((void*) gvp) THelix(
08125 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
08126 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
08127 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
08128 , (Double_t) G__double(libp->para[6]));
08129 }
08130 result7->obj.i = (long) p;
08131 result7->ref = (long) p;
08132 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THelix));
08133 return(1 || funcname || hash || result7 || libp) ;
08134 }
08135
08136 static int G__G__G3D_155_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08137 {
08138 THelix* p = NULL;
08139 char* gvp = (char*) G__getgvp();
08140 switch (libp->paran) {
08141 case 6:
08142
08143 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08144 p = new THelix(
08145 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08146 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
08147 , (EHelixRangeType) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
08148 } else {
08149 p = new((void*) gvp) THelix(
08150 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08151 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
08152 , (EHelixRangeType) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
08153 }
08154 break;
08155 case 5:
08156
08157 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08158 p = new THelix(
08159 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08160 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
08161 , (EHelixRangeType) G__int(libp->para[4]));
08162 } else {
08163 p = new((void*) gvp) THelix(
08164 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08165 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
08166 , (EHelixRangeType) G__int(libp->para[4]));
08167 }
08168 break;
08169 case 4:
08170
08171 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08172 p = new THelix(
08173 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08174 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
08175 } else {
08176 p = new((void*) gvp) THelix(
08177 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08178 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
08179 }
08180 break;
08181 case 3:
08182
08183 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08184 p = new THelix(
08185 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08186 , (Double_t) G__double(libp->para[2]));
08187 } else {
08188 p = new((void*) gvp) THelix(
08189 (Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08190 , (Double_t) G__double(libp->para[2]));
08191 }
08192 break;
08193 }
08194 result7->obj.i = (long) p;
08195 result7->ref = (long) p;
08196 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THelix));
08197 return(1 || funcname || hash || result7 || libp) ;
08198 }
08199
08200 static int G__G__G3D_155_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08201 {
08202 THelix* p = NULL;
08203 char* gvp = (char*) G__getgvp();
08204
08205 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08206 p = new THelix(*(THelix*) libp->para[0].ref);
08207 } else {
08208 p = new((void*) gvp) THelix(*(THelix*) libp->para[0].ref);
08209 }
08210 result7->obj.i = (long) p;
08211 result7->ref = (long) p;
08212 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THelix));
08213 return(1 || funcname || hash || result7 || libp) ;
08214 }
08215
08216 static int G__G__G3D_155_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08217 {
08218 ((THelix*) G__getstructoffset())->SetAxis((Double_t*) G__int(libp->para[0]));
08219 G__setnull(result7);
08220 return(1 || funcname || hash || result7 || libp) ;
08221 }
08222
08223 static int G__G__G3D_155_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08224 {
08225 ((THelix*) G__getstructoffset())->SetAxis((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
08226 , (Double_t) G__double(libp->para[2]));
08227 G__setnull(result7);
08228 return(1 || funcname || hash || result7 || libp) ;
08229 }
08230
08231 static int G__G__G3D_155_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08232 {
08233 switch (libp->paran) {
08234 case 2:
08235 ((THelix*) G__getstructoffset())->SetRange((Double_t*) G__int(libp->para[0]), (EHelixRangeType) G__int(libp->para[1]));
08236 G__setnull(result7);
08237 break;
08238 case 1:
08239 ((THelix*) G__getstructoffset())->SetRange((Double_t*) G__int(libp->para[0]));
08240 G__setnull(result7);
08241 break;
08242 }
08243 return(1 || funcname || hash || result7 || libp) ;
08244 }
08245
08246 static int G__G__G3D_155_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08247 {
08248 switch (libp->paran) {
08249 case 3:
08250 ((THelix*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
08251 , (EHelixRangeType) G__int(libp->para[2]));
08252 G__setnull(result7);
08253 break;
08254 case 2:
08255 ((THelix*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
08256 G__setnull(result7);
08257 break;
08258 }
08259 return(1 || funcname || hash || result7 || libp) ;
08260 }
08261
08262 static int G__G__G3D_155_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08263 {
08264 switch (libp->paran) {
08265 case 6:
08266 ((THelix*) G__getstructoffset())->SetHelix((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08267 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
08268 , (EHelixRangeType) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5]));
08269 G__setnull(result7);
08270 break;
08271 case 5:
08272 ((THelix*) G__getstructoffset())->SetHelix((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08273 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])
08274 , (EHelixRangeType) G__int(libp->para[4]));
08275 G__setnull(result7);
08276 break;
08277 case 4:
08278 ((THelix*) G__getstructoffset())->SetHelix((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08279 , (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
08280 G__setnull(result7);
08281 break;
08282 case 3:
08283 ((THelix*) G__getstructoffset())->SetHelix((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
08284 , (Double_t) G__double(libp->para[2]));
08285 G__setnull(result7);
08286 break;
08287 }
08288 return(1 || funcname || hash || result7 || libp) ;
08289 }
08290
08291 static int G__G__G3D_155_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08292 {
08293 G__letint(result7, 85, (long) THelix::Class());
08294 return(1 || funcname || hash || result7 || libp) ;
08295 }
08296
08297 static int G__G__G3D_155_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08298 {
08299 G__letint(result7, 67, (long) THelix::Class_Name());
08300 return(1 || funcname || hash || result7 || libp) ;
08301 }
08302
08303 static int G__G__G3D_155_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08304 {
08305 G__letint(result7, 115, (long) THelix::Class_Version());
08306 return(1 || funcname || hash || result7 || libp) ;
08307 }
08308
08309 static int G__G__G3D_155_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08310 {
08311 THelix::Dictionary();
08312 G__setnull(result7);
08313 return(1 || funcname || hash || result7 || libp) ;
08314 }
08315
08316 static int G__G__G3D_155_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08317 {
08318 ((THelix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08319 G__setnull(result7);
08320 return(1 || funcname || hash || result7 || libp) ;
08321 }
08322
08323 static int G__G__G3D_155_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08324 {
08325 G__letint(result7, 67, (long) THelix::DeclFileName());
08326 return(1 || funcname || hash || result7 || libp) ;
08327 }
08328
08329 static int G__G__G3D_155_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08330 {
08331 G__letint(result7, 105, (long) THelix::ImplFileLine());
08332 return(1 || funcname || hash || result7 || libp) ;
08333 }
08334
08335 static int G__G__G3D_155_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08336 {
08337 G__letint(result7, 67, (long) THelix::ImplFileName());
08338 return(1 || funcname || hash || result7 || libp) ;
08339 }
08340
08341 static int G__G__G3D_155_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08342 {
08343 G__letint(result7, 105, (long) THelix::DeclFileLine());
08344 return(1 || funcname || hash || result7 || libp) ;
08345 }
08346
08347
08348 typedef THelix G__TTHelix;
08349 static int G__G__G3D_155_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08350 {
08351 char* gvp = (char*) G__getgvp();
08352 long soff = G__getstructoffset();
08353 int n = G__getaryconstruct();
08354
08355
08356
08357
08358
08359 if (!soff) {
08360 return(1);
08361 }
08362 if (n) {
08363 if (gvp == (char*)G__PVOID) {
08364 delete[] (THelix*) soff;
08365 } else {
08366 G__setgvp((long) G__PVOID);
08367 for (int i = n - 1; i >= 0; --i) {
08368 ((THelix*) (soff+(sizeof(THelix)*i)))->~G__TTHelix();
08369 }
08370 G__setgvp((long)gvp);
08371 }
08372 } else {
08373 if (gvp == (char*)G__PVOID) {
08374 delete (THelix*) soff;
08375 } else {
08376 G__setgvp((long) G__PVOID);
08377 ((THelix*) (soff))->~G__TTHelix();
08378 G__setgvp((long)gvp);
08379 }
08380 }
08381 G__setnull(result7);
08382 return(1 || funcname || hash || result7 || libp) ;
08383 }
08384
08385
08386
08387 static int G__G__G3D_156_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08388 {
08389 THYPE* p = NULL;
08390 char* gvp = (char*) G__getgvp();
08391 int n = G__getaryconstruct();
08392 if (n) {
08393 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08394 p = new THYPE[n];
08395 } else {
08396 p = new((void*) gvp) THYPE[n];
08397 }
08398 } else {
08399 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08400 p = new THYPE;
08401 } else {
08402 p = new((void*) gvp) THYPE;
08403 }
08404 }
08405 result7->obj.i = (long) p;
08406 result7->ref = (long) p;
08407 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THYPE));
08408 return(1 || funcname || hash || result7 || libp) ;
08409 }
08410
08411 static int G__G__G3D_156_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08412 {
08413 THYPE* p = NULL;
08414 char* gvp = (char*) G__getgvp();
08415
08416 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08417 p = new THYPE(
08418 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08419 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
08420 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
08421 , (Float_t) G__double(libp->para[6]));
08422 } else {
08423 p = new((void*) gvp) THYPE(
08424 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08425 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
08426 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
08427 , (Float_t) G__double(libp->para[6]));
08428 }
08429 result7->obj.i = (long) p;
08430 result7->ref = (long) p;
08431 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THYPE));
08432 return(1 || funcname || hash || result7 || libp) ;
08433 }
08434
08435 static int G__G__G3D_156_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08436 {
08437 G__letdouble(result7, 102, (double) ((const THYPE*) G__getstructoffset())->GetPhi());
08438 return(1 || funcname || hash || result7 || libp) ;
08439 }
08440
08441 static int G__G__G3D_156_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08442 {
08443 G__letint(result7, 85, (long) THYPE::Class());
08444 return(1 || funcname || hash || result7 || libp) ;
08445 }
08446
08447 static int G__G__G3D_156_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08448 {
08449 G__letint(result7, 67, (long) THYPE::Class_Name());
08450 return(1 || funcname || hash || result7 || libp) ;
08451 }
08452
08453 static int G__G__G3D_156_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08454 {
08455 G__letint(result7, 115, (long) THYPE::Class_Version());
08456 return(1 || funcname || hash || result7 || libp) ;
08457 }
08458
08459 static int G__G__G3D_156_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08460 {
08461 THYPE::Dictionary();
08462 G__setnull(result7);
08463 return(1 || funcname || hash || result7 || libp) ;
08464 }
08465
08466 static int G__G__G3D_156_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08467 {
08468 ((THYPE*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08469 G__setnull(result7);
08470 return(1 || funcname || hash || result7 || libp) ;
08471 }
08472
08473 static int G__G__G3D_156_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08474 {
08475 G__letint(result7, 67, (long) THYPE::DeclFileName());
08476 return(1 || funcname || hash || result7 || libp) ;
08477 }
08478
08479 static int G__G__G3D_156_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08480 {
08481 G__letint(result7, 105, (long) THYPE::ImplFileLine());
08482 return(1 || funcname || hash || result7 || libp) ;
08483 }
08484
08485 static int G__G__G3D_156_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08486 {
08487 G__letint(result7, 67, (long) THYPE::ImplFileName());
08488 return(1 || funcname || hash || result7 || libp) ;
08489 }
08490
08491 static int G__G__G3D_156_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08492 {
08493 G__letint(result7, 105, (long) THYPE::DeclFileLine());
08494 return(1 || funcname || hash || result7 || libp) ;
08495 }
08496
08497
08498 static int G__G__G3D_156_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08499
08500 {
08501 THYPE* p;
08502 void* tmp = (void*) G__int(libp->para[0]);
08503 p = new THYPE(*(THYPE*) tmp);
08504 result7->obj.i = (long) p;
08505 result7->ref = (long) p;
08506 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_THYPE));
08507 return(1 || funcname || hash || result7 || libp) ;
08508 }
08509
08510
08511 typedef THYPE G__TTHYPE;
08512 static int G__G__G3D_156_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08513 {
08514 char* gvp = (char*) G__getgvp();
08515 long soff = G__getstructoffset();
08516 int n = G__getaryconstruct();
08517
08518
08519
08520
08521
08522 if (!soff) {
08523 return(1);
08524 }
08525 if (n) {
08526 if (gvp == (char*)G__PVOID) {
08527 delete[] (THYPE*) soff;
08528 } else {
08529 G__setgvp((long) G__PVOID);
08530 for (int i = n - 1; i >= 0; --i) {
08531 ((THYPE*) (soff+(sizeof(THYPE)*i)))->~G__TTHYPE();
08532 }
08533 G__setgvp((long)gvp);
08534 }
08535 } else {
08536 if (gvp == (char*)G__PVOID) {
08537 delete (THYPE*) soff;
08538 } else {
08539 G__setgvp((long) G__PVOID);
08540 ((THYPE*) (soff))->~G__TTHYPE();
08541 G__setgvp((long)gvp);
08542 }
08543 }
08544 G__setnull(result7);
08545 return(1 || funcname || hash || result7 || libp) ;
08546 }
08547
08548
08549
08550 static int G__G__G3D_158_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08551 {
08552 TMarker3DBox* p = NULL;
08553 char* gvp = (char*) G__getgvp();
08554 int n = G__getaryconstruct();
08555 if (n) {
08556 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08557 p = new TMarker3DBox[n];
08558 } else {
08559 p = new((void*) gvp) TMarker3DBox[n];
08560 }
08561 } else {
08562 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08563 p = new TMarker3DBox;
08564 } else {
08565 p = new((void*) gvp) TMarker3DBox;
08566 }
08567 }
08568 result7->obj.i = (long) p;
08569 result7->ref = (long) p;
08570 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox));
08571 return(1 || funcname || hash || result7 || libp) ;
08572 }
08573
08574 static int G__G__G3D_158_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08575 {
08576 TMarker3DBox* p = NULL;
08577 char* gvp = (char*) G__getgvp();
08578
08579 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08580 p = new TMarker3DBox(
08581 (Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
08582 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
08583 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
08584 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
08585 } else {
08586 p = new((void*) gvp) TMarker3DBox(
08587 (Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
08588 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
08589 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
08590 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
08591 }
08592 result7->obj.i = (long) p;
08593 result7->ref = (long) p;
08594 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox));
08595 return(1 || funcname || hash || result7 || libp) ;
08596 }
08597
08598 static int G__G__G3D_158_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08599 {
08600 G__letint(result7, 85, (long) ((const TMarker3DBox*) G__getstructoffset())->GetRefObject());
08601 return(1 || funcname || hash || result7 || libp) ;
08602 }
08603
08604 static int G__G__G3D_158_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08605 {
08606 ((const TMarker3DBox*) G__getstructoffset())->GetDirection(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
08607 G__setnull(result7);
08608 return(1 || funcname || hash || result7 || libp) ;
08609 }
08610
08611 static int G__G__G3D_158_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08612 {
08613 ((const TMarker3DBox*) G__getstructoffset())->GetPosition(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
08614 , *(Float_t*) G__Floatref(&libp->para[2]));
08615 G__setnull(result7);
08616 return(1 || funcname || hash || result7 || libp) ;
08617 }
08618
08619 static int G__G__G3D_158_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08620 {
08621 ((const TMarker3DBox*) G__getstructoffset())->GetSize(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
08622 , *(Float_t*) G__Floatref(&libp->para[2]));
08623 G__setnull(result7);
08624 return(1 || funcname || hash || result7 || libp) ;
08625 }
08626
08627 static int G__G__G3D_158_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08628 {
08629 TMarker3DBox::PaintH3((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
08630 G__setnull(result7);
08631 return(1 || funcname || hash || result7 || libp) ;
08632 }
08633
08634 static int G__G__G3D_158_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08635 {
08636 ((const TMarker3DBox*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
08637 G__setnull(result7);
08638 return(1 || funcname || hash || result7 || libp) ;
08639 }
08640
08641 static int G__G__G3D_158_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08642 {
08643 ((TMarker3DBox*) G__getstructoffset())->SetDirection((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
08644 G__setnull(result7);
08645 return(1 || funcname || hash || result7 || libp) ;
08646 }
08647
08648 static int G__G__G3D_158_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08649 {
08650 ((TMarker3DBox*) G__getstructoffset())->SetPosition((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
08651 , (Float_t) G__double(libp->para[2]));
08652 G__setnull(result7);
08653 return(1 || funcname || hash || result7 || libp) ;
08654 }
08655
08656 static int G__G__G3D_158_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08657 {
08658 ((TMarker3DBox*) G__getstructoffset())->SetSize((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
08659 , (Float_t) G__double(libp->para[2]));
08660 G__setnull(result7);
08661 return(1 || funcname || hash || result7 || libp) ;
08662 }
08663
08664 static int G__G__G3D_158_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08665 {
08666 switch (libp->paran) {
08667 case 1:
08668 ((TMarker3DBox*) G__getstructoffset())->SetRefObject((TObject*) G__int(libp->para[0]));
08669 G__setnull(result7);
08670 break;
08671 case 0:
08672 ((TMarker3DBox*) G__getstructoffset())->SetRefObject();
08673 G__setnull(result7);
08674 break;
08675 }
08676 return(1 || funcname || hash || result7 || libp) ;
08677 }
08678
08679 static int G__G__G3D_158_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08680 {
08681 G__letint(result7, 85, (long) TMarker3DBox::Class());
08682 return(1 || funcname || hash || result7 || libp) ;
08683 }
08684
08685 static int G__G__G3D_158_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08686 {
08687 G__letint(result7, 67, (long) TMarker3DBox::Class_Name());
08688 return(1 || funcname || hash || result7 || libp) ;
08689 }
08690
08691 static int G__G__G3D_158_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08692 {
08693 G__letint(result7, 115, (long) TMarker3DBox::Class_Version());
08694 return(1 || funcname || hash || result7 || libp) ;
08695 }
08696
08697 static int G__G__G3D_158_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08698 {
08699 TMarker3DBox::Dictionary();
08700 G__setnull(result7);
08701 return(1 || funcname || hash || result7 || libp) ;
08702 }
08703
08704 static int G__G__G3D_158_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08705 {
08706 ((TMarker3DBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08707 G__setnull(result7);
08708 return(1 || funcname || hash || result7 || libp) ;
08709 }
08710
08711 static int G__G__G3D_158_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08712 {
08713 G__letint(result7, 67, (long) TMarker3DBox::DeclFileName());
08714 return(1 || funcname || hash || result7 || libp) ;
08715 }
08716
08717 static int G__G__G3D_158_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08718 {
08719 G__letint(result7, 105, (long) TMarker3DBox::ImplFileLine());
08720 return(1 || funcname || hash || result7 || libp) ;
08721 }
08722
08723 static int G__G__G3D_158_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08724 {
08725 G__letint(result7, 67, (long) TMarker3DBox::ImplFileName());
08726 return(1 || funcname || hash || result7 || libp) ;
08727 }
08728
08729 static int G__G__G3D_158_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08730 {
08731 G__letint(result7, 105, (long) TMarker3DBox::DeclFileLine());
08732 return(1 || funcname || hash || result7 || libp) ;
08733 }
08734
08735
08736 typedef TMarker3DBox G__TTMarker3DBox;
08737 static int G__G__G3D_158_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08738 {
08739 char* gvp = (char*) G__getgvp();
08740 long soff = G__getstructoffset();
08741 int n = G__getaryconstruct();
08742
08743
08744
08745
08746
08747 if (!soff) {
08748 return(1);
08749 }
08750 if (n) {
08751 if (gvp == (char*)G__PVOID) {
08752 delete[] (TMarker3DBox*) soff;
08753 } else {
08754 G__setgvp((long) G__PVOID);
08755 for (int i = n - 1; i >= 0; --i) {
08756 ((TMarker3DBox*) (soff+(sizeof(TMarker3DBox)*i)))->~G__TTMarker3DBox();
08757 }
08758 G__setgvp((long)gvp);
08759 }
08760 } else {
08761 if (gvp == (char*)G__PVOID) {
08762 delete (TMarker3DBox*) soff;
08763 } else {
08764 G__setgvp((long) G__PVOID);
08765 ((TMarker3DBox*) (soff))->~G__TTMarker3DBox();
08766 G__setgvp((long)gvp);
08767 }
08768 }
08769 G__setnull(result7);
08770 return(1 || funcname || hash || result7 || libp) ;
08771 }
08772
08773
08774
08775 static int G__G__G3D_160_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08776 {
08777 TMixture* p = NULL;
08778 char* gvp = (char*) G__getgvp();
08779 int n = G__getaryconstruct();
08780 if (n) {
08781 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08782 p = new TMixture[n];
08783 } else {
08784 p = new((void*) gvp) TMixture[n];
08785 }
08786 } else {
08787 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08788 p = new TMixture;
08789 } else {
08790 p = new((void*) gvp) TMixture;
08791 }
08792 }
08793 result7->obj.i = (long) p;
08794 result7->ref = (long) p;
08795 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMixture));
08796 return(1 || funcname || hash || result7 || libp) ;
08797 }
08798
08799 static int G__G__G3D_160_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08800 {
08801 TMixture* p = NULL;
08802 char* gvp = (char*) G__getgvp();
08803
08804 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08805 p = new TMixture(
08806 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08807 , (Int_t) G__int(libp->para[2]));
08808 } else {
08809 p = new((void*) gvp) TMixture(
08810 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08811 , (Int_t) G__int(libp->para[2]));
08812 }
08813 result7->obj.i = (long) p;
08814 result7->ref = (long) p;
08815 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMixture));
08816 return(1 || funcname || hash || result7 || libp) ;
08817 }
08818
08819 static int G__G__G3D_160_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08820 {
08821 ((TMixture*) G__getstructoffset())->DefineElement((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
08822 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
08823 G__setnull(result7);
08824 return(1 || funcname || hash || result7 || libp) ;
08825 }
08826
08827 static int G__G__G3D_160_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08828 {
08829 G__letint(result7, 105, (long) ((const TMixture*) G__getstructoffset())->GetNmixt());
08830 return(1 || funcname || hash || result7 || libp) ;
08831 }
08832
08833 static int G__G__G3D_160_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08834 {
08835 G__letint(result7, 70, (long) ((const TMixture*) G__getstructoffset())->GetAmixt());
08836 return(1 || funcname || hash || result7 || libp) ;
08837 }
08838
08839 static int G__G__G3D_160_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08840 {
08841 G__letint(result7, 70, (long) ((const TMixture*) G__getstructoffset())->GetZmixt());
08842 return(1 || funcname || hash || result7 || libp) ;
08843 }
08844
08845 static int G__G__G3D_160_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08846 {
08847 G__letint(result7, 70, (long) ((const TMixture*) G__getstructoffset())->GetWmixt());
08848 return(1 || funcname || hash || result7 || libp) ;
08849 }
08850
08851 static int G__G__G3D_160_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08852 {
08853 G__letint(result7, 85, (long) TMixture::Class());
08854 return(1 || funcname || hash || result7 || libp) ;
08855 }
08856
08857 static int G__G__G3D_160_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08858 {
08859 G__letint(result7, 67, (long) TMixture::Class_Name());
08860 return(1 || funcname || hash || result7 || libp) ;
08861 }
08862
08863 static int G__G__G3D_160_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08864 {
08865 G__letint(result7, 115, (long) TMixture::Class_Version());
08866 return(1 || funcname || hash || result7 || libp) ;
08867 }
08868
08869 static int G__G__G3D_160_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08870 {
08871 TMixture::Dictionary();
08872 G__setnull(result7);
08873 return(1 || funcname || hash || result7 || libp) ;
08874 }
08875
08876 static int G__G__G3D_160_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08877 {
08878 ((TMixture*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08879 G__setnull(result7);
08880 return(1 || funcname || hash || result7 || libp) ;
08881 }
08882
08883 static int G__G__G3D_160_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08884 {
08885 G__letint(result7, 67, (long) TMixture::DeclFileName());
08886 return(1 || funcname || hash || result7 || libp) ;
08887 }
08888
08889 static int G__G__G3D_160_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08890 {
08891 G__letint(result7, 105, (long) TMixture::ImplFileLine());
08892 return(1 || funcname || hash || result7 || libp) ;
08893 }
08894
08895 static int G__G__G3D_160_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08896 {
08897 G__letint(result7, 67, (long) TMixture::ImplFileName());
08898 return(1 || funcname || hash || result7 || libp) ;
08899 }
08900
08901 static int G__G__G3D_160_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08902 {
08903 G__letint(result7, 105, (long) TMixture::DeclFileLine());
08904 return(1 || funcname || hash || result7 || libp) ;
08905 }
08906
08907
08908 static int G__G__G3D_160_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08909
08910 {
08911 TMixture* p;
08912 void* tmp = (void*) G__int(libp->para[0]);
08913 p = new TMixture(*(TMixture*) tmp);
08914 result7->obj.i = (long) p;
08915 result7->ref = (long) p;
08916 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TMixture));
08917 return(1 || funcname || hash || result7 || libp) ;
08918 }
08919
08920
08921 typedef TMixture G__TTMixture;
08922 static int G__G__G3D_160_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08923 {
08924 char* gvp = (char*) G__getgvp();
08925 long soff = G__getstructoffset();
08926 int n = G__getaryconstruct();
08927
08928
08929
08930
08931
08932 if (!soff) {
08933 return(1);
08934 }
08935 if (n) {
08936 if (gvp == (char*)G__PVOID) {
08937 delete[] (TMixture*) soff;
08938 } else {
08939 G__setgvp((long) G__PVOID);
08940 for (int i = n - 1; i >= 0; --i) {
08941 ((TMixture*) (soff+(sizeof(TMixture)*i)))->~G__TTMixture();
08942 }
08943 G__setgvp((long)gvp);
08944 }
08945 } else {
08946 if (gvp == (char*)G__PVOID) {
08947 delete (TMixture*) soff;
08948 } else {
08949 G__setgvp((long) G__PVOID);
08950 ((TMixture*) (soff))->~G__TTMixture();
08951 G__setgvp((long)gvp);
08952 }
08953 }
08954 G__setnull(result7);
08955 return(1 || funcname || hash || result7 || libp) ;
08956 }
08957
08958
08959 static int G__G__G3D_160_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08960 {
08961 TMixture* dest = (TMixture*) G__getstructoffset();
08962 *dest = *(TMixture*) libp->para[0].ref;
08963 const TMixture& obj = *dest;
08964 result7->ref = (long) (&obj);
08965 result7->obj.i = (long) (&obj);
08966 return(1 || funcname || hash || result7 || libp) ;
08967 }
08968
08969
08970
08971 static int G__G__G3D_162_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08972 {
08973 TNodeDiv* p = NULL;
08974 char* gvp = (char*) G__getgvp();
08975 int n = G__getaryconstruct();
08976 if (n) {
08977 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08978 p = new TNodeDiv[n];
08979 } else {
08980 p = new((void*) gvp) TNodeDiv[n];
08981 }
08982 } else {
08983 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08984 p = new TNodeDiv;
08985 } else {
08986 p = new((void*) gvp) TNodeDiv;
08987 }
08988 }
08989 result7->obj.i = (long) p;
08990 result7->ref = (long) p;
08991 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv));
08992 return(1 || funcname || hash || result7 || libp) ;
08993 }
08994
08995 static int G__G__G3D_162_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08996 {
08997 TNodeDiv* p = NULL;
08998 char* gvp = (char*) G__getgvp();
08999 switch (libp->paran) {
09000 case 6:
09001
09002 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09003 p = new TNodeDiv(
09004 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09005 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09006 , (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
09007 } else {
09008 p = new((void*) gvp) TNodeDiv(
09009 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09010 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09011 , (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
09012 }
09013 break;
09014 case 5:
09015
09016 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09017 p = new TNodeDiv(
09018 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09019 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09020 , (Int_t) G__int(libp->para[4]));
09021 } else {
09022 p = new((void*) gvp) TNodeDiv(
09023 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09024 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09025 , (Int_t) G__int(libp->para[4]));
09026 }
09027 break;
09028 }
09029 result7->obj.i = (long) p;
09030 result7->ref = (long) p;
09031 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv));
09032 return(1 || funcname || hash || result7 || libp) ;
09033 }
09034
09035 static int G__G__G3D_162_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09036 {
09037 TNodeDiv* p = NULL;
09038 char* gvp = (char*) G__getgvp();
09039 switch (libp->paran) {
09040 case 6:
09041
09042 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09043 p = new TNodeDiv(
09044 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09045 , (TShape*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09046 , (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
09047 } else {
09048 p = new((void*) gvp) TNodeDiv(
09049 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09050 , (TShape*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09051 , (Int_t) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
09052 }
09053 break;
09054 case 5:
09055
09056 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09057 p = new TNodeDiv(
09058 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09059 , (TShape*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09060 , (Int_t) G__int(libp->para[4]));
09061 } else {
09062 p = new((void*) gvp) TNodeDiv(
09063 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09064 , (TShape*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09065 , (Int_t) G__int(libp->para[4]));
09066 }
09067 break;
09068 }
09069 result7->obj.i = (long) p;
09070 result7->ref = (long) p;
09071 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv));
09072 return(1 || funcname || hash || result7 || libp) ;
09073 }
09074
09075 static int G__G__G3D_162_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09076 {
09077 G__letint(result7, 85, (long) TNodeDiv::Class());
09078 return(1 || funcname || hash || result7 || libp) ;
09079 }
09080
09081 static int G__G__G3D_162_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09082 {
09083 G__letint(result7, 67, (long) TNodeDiv::Class_Name());
09084 return(1 || funcname || hash || result7 || libp) ;
09085 }
09086
09087 static int G__G__G3D_162_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09088 {
09089 G__letint(result7, 115, (long) TNodeDiv::Class_Version());
09090 return(1 || funcname || hash || result7 || libp) ;
09091 }
09092
09093 static int G__G__G3D_162_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09094 {
09095 TNodeDiv::Dictionary();
09096 G__setnull(result7);
09097 return(1 || funcname || hash || result7 || libp) ;
09098 }
09099
09100 static int G__G__G3D_162_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09101 {
09102 ((TNodeDiv*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09103 G__setnull(result7);
09104 return(1 || funcname || hash || result7 || libp) ;
09105 }
09106
09107 static int G__G__G3D_162_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09108 {
09109 G__letint(result7, 67, (long) TNodeDiv::DeclFileName());
09110 return(1 || funcname || hash || result7 || libp) ;
09111 }
09112
09113 static int G__G__G3D_162_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09114 {
09115 G__letint(result7, 105, (long) TNodeDiv::ImplFileLine());
09116 return(1 || funcname || hash || result7 || libp) ;
09117 }
09118
09119 static int G__G__G3D_162_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09120 {
09121 G__letint(result7, 67, (long) TNodeDiv::ImplFileName());
09122 return(1 || funcname || hash || result7 || libp) ;
09123 }
09124
09125 static int G__G__G3D_162_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09126 {
09127 G__letint(result7, 105, (long) TNodeDiv::DeclFileLine());
09128 return(1 || funcname || hash || result7 || libp) ;
09129 }
09130
09131
09132 static int G__G__G3D_162_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09133
09134 {
09135 TNodeDiv* p;
09136 void* tmp = (void*) G__int(libp->para[0]);
09137 p = new TNodeDiv(*(TNodeDiv*) tmp);
09138 result7->obj.i = (long) p;
09139 result7->ref = (long) p;
09140 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv));
09141 return(1 || funcname || hash || result7 || libp) ;
09142 }
09143
09144
09145 typedef TNodeDiv G__TTNodeDiv;
09146 static int G__G__G3D_162_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09147 {
09148 char* gvp = (char*) G__getgvp();
09149 long soff = G__getstructoffset();
09150 int n = G__getaryconstruct();
09151
09152
09153
09154
09155
09156 if (!soff) {
09157 return(1);
09158 }
09159 if (n) {
09160 if (gvp == (char*)G__PVOID) {
09161 delete[] (TNodeDiv*) soff;
09162 } else {
09163 G__setgvp((long) G__PVOID);
09164 for (int i = n - 1; i >= 0; --i) {
09165 ((TNodeDiv*) (soff+(sizeof(TNodeDiv)*i)))->~G__TTNodeDiv();
09166 }
09167 G__setgvp((long)gvp);
09168 }
09169 } else {
09170 if (gvp == (char*)G__PVOID) {
09171 delete (TNodeDiv*) soff;
09172 } else {
09173 G__setgvp((long) G__PVOID);
09174 ((TNodeDiv*) (soff))->~G__TTNodeDiv();
09175 G__setgvp((long)gvp);
09176 }
09177 }
09178 G__setnull(result7);
09179 return(1 || funcname || hash || result7 || libp) ;
09180 }
09181
09182
09183
09184 static int G__G__G3D_163_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09185 {
09186 TPARA* p = NULL;
09187 char* gvp = (char*) G__getgvp();
09188 int n = G__getaryconstruct();
09189 if (n) {
09190 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09191 p = new TPARA[n];
09192 } else {
09193 p = new((void*) gvp) TPARA[n];
09194 }
09195 } else {
09196 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09197 p = new TPARA;
09198 } else {
09199 p = new((void*) gvp) TPARA;
09200 }
09201 }
09202 result7->obj.i = (long) p;
09203 result7->ref = (long) p;
09204 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPARA));
09205 return(1 || funcname || hash || result7 || libp) ;
09206 }
09207
09208 static int G__G__G3D_163_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09209 {
09210 TPARA* p = NULL;
09211 char* gvp = (char*) G__getgvp();
09212
09213 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09214 p = new TPARA(
09215 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09216 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
09217 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
09218 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
09219 , (Float_t) G__double(libp->para[8]));
09220 } else {
09221 p = new((void*) gvp) TPARA(
09222 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09223 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
09224 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
09225 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
09226 , (Float_t) G__double(libp->para[8]));
09227 }
09228 result7->obj.i = (long) p;
09229 result7->ref = (long) p;
09230 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPARA));
09231 return(1 || funcname || hash || result7 || libp) ;
09232 }
09233
09234 static int G__G__G3D_163_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09235 {
09236 G__letdouble(result7, 102, (double) ((const TPARA*) G__getstructoffset())->GetAlpha());
09237 return(1 || funcname || hash || result7 || libp) ;
09238 }
09239
09240 static int G__G__G3D_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09241 {
09242 G__letdouble(result7, 102, (double) ((const TPARA*) G__getstructoffset())->GetTheta());
09243 return(1 || funcname || hash || result7 || libp) ;
09244 }
09245
09246 static int G__G__G3D_163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09247 {
09248 G__letdouble(result7, 102, (double) ((const TPARA*) G__getstructoffset())->GetPhi());
09249 return(1 || funcname || hash || result7 || libp) ;
09250 }
09251
09252 static int G__G__G3D_163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09253 {
09254 G__letint(result7, 85, (long) TPARA::Class());
09255 return(1 || funcname || hash || result7 || libp) ;
09256 }
09257
09258 static int G__G__G3D_163_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09259 {
09260 G__letint(result7, 67, (long) TPARA::Class_Name());
09261 return(1 || funcname || hash || result7 || libp) ;
09262 }
09263
09264 static int G__G__G3D_163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09265 {
09266 G__letint(result7, 115, (long) TPARA::Class_Version());
09267 return(1 || funcname || hash || result7 || libp) ;
09268 }
09269
09270 static int G__G__G3D_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09271 {
09272 TPARA::Dictionary();
09273 G__setnull(result7);
09274 return(1 || funcname || hash || result7 || libp) ;
09275 }
09276
09277 static int G__G__G3D_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09278 {
09279 ((TPARA*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09280 G__setnull(result7);
09281 return(1 || funcname || hash || result7 || libp) ;
09282 }
09283
09284 static int G__G__G3D_163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09285 {
09286 G__letint(result7, 67, (long) TPARA::DeclFileName());
09287 return(1 || funcname || hash || result7 || libp) ;
09288 }
09289
09290 static int G__G__G3D_163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09291 {
09292 G__letint(result7, 105, (long) TPARA::ImplFileLine());
09293 return(1 || funcname || hash || result7 || libp) ;
09294 }
09295
09296 static int G__G__G3D_163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09297 {
09298 G__letint(result7, 67, (long) TPARA::ImplFileName());
09299 return(1 || funcname || hash || result7 || libp) ;
09300 }
09301
09302 static int G__G__G3D_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09303 {
09304 G__letint(result7, 105, (long) TPARA::DeclFileLine());
09305 return(1 || funcname || hash || result7 || libp) ;
09306 }
09307
09308
09309 static int G__G__G3D_163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09310
09311 {
09312 TPARA* p;
09313 void* tmp = (void*) G__int(libp->para[0]);
09314 p = new TPARA(*(TPARA*) tmp);
09315 result7->obj.i = (long) p;
09316 result7->ref = (long) p;
09317 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPARA));
09318 return(1 || funcname || hash || result7 || libp) ;
09319 }
09320
09321
09322 typedef TPARA G__TTPARA;
09323 static int G__G__G3D_163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09324 {
09325 char* gvp = (char*) G__getgvp();
09326 long soff = G__getstructoffset();
09327 int n = G__getaryconstruct();
09328
09329
09330
09331
09332
09333 if (!soff) {
09334 return(1);
09335 }
09336 if (n) {
09337 if (gvp == (char*)G__PVOID) {
09338 delete[] (TPARA*) soff;
09339 } else {
09340 G__setgvp((long) G__PVOID);
09341 for (int i = n - 1; i >= 0; --i) {
09342 ((TPARA*) (soff+(sizeof(TPARA)*i)))->~G__TTPARA();
09343 }
09344 G__setgvp((long)gvp);
09345 }
09346 } else {
09347 if (gvp == (char*)G__PVOID) {
09348 delete (TPARA*) soff;
09349 } else {
09350 G__setgvp((long) G__PVOID);
09351 ((TPARA*) (soff))->~G__TTPARA();
09352 G__setgvp((long)gvp);
09353 }
09354 }
09355 G__setnull(result7);
09356 return(1 || funcname || hash || result7 || libp) ;
09357 }
09358
09359
09360 static int G__G__G3D_163_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09361 {
09362 TPARA* dest = (TPARA*) G__getstructoffset();
09363 *dest = *(TPARA*) libp->para[0].ref;
09364 const TPARA& obj = *dest;
09365 result7->ref = (long) (&obj);
09366 result7->obj.i = (long) (&obj);
09367 return(1 || funcname || hash || result7 || libp) ;
09368 }
09369
09370
09371
09372 static int G__G__G3D_164_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09373 {
09374 TPCON* p = NULL;
09375 char* gvp = (char*) G__getgvp();
09376 int n = G__getaryconstruct();
09377 if (n) {
09378 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09379 p = new TPCON[n];
09380 } else {
09381 p = new((void*) gvp) TPCON[n];
09382 }
09383 } else {
09384 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09385 p = new TPCON;
09386 } else {
09387 p = new((void*) gvp) TPCON;
09388 }
09389 }
09390 result7->obj.i = (long) p;
09391 result7->ref = (long) p;
09392 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPCON));
09393 return(1 || funcname || hash || result7 || libp) ;
09394 }
09395
09396 static int G__G__G3D_164_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09397 {
09398 TPCON* p = NULL;
09399 char* gvp = (char*) G__getgvp();
09400
09401 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09402 p = new TPCON(
09403 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09404 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
09405 , (Float_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
09406 } else {
09407 p = new((void*) gvp) TPCON(
09408 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09409 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
09410 , (Float_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
09411 }
09412 result7->obj.i = (long) p;
09413 result7->ref = (long) p;
09414 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPCON));
09415 return(1 || funcname || hash || result7 || libp) ;
09416 }
09417
09418 static int G__G__G3D_164_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09419 {
09420 ((TPCON*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
09421 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
09422 G__setnull(result7);
09423 return(1 || funcname || hash || result7 || libp) ;
09424 }
09425
09426 static int G__G__G3D_164_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09427 {
09428 G__letint(result7, 105, (long) ((const TPCON*) G__getstructoffset())->GetNumberOfDivisions());
09429 return(1 || funcname || hash || result7 || libp) ;
09430 }
09431
09432 static int G__G__G3D_164_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09433 {
09434 G__letdouble(result7, 102, (double) ((const TPCON*) G__getstructoffset())->GetPhi1());
09435 return(1 || funcname || hash || result7 || libp) ;
09436 }
09437
09438 static int G__G__G3D_164_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09439 {
09440 G__letdouble(result7, 102, (double) ((const TPCON*) G__getstructoffset())->GetDhi1());
09441 return(1 || funcname || hash || result7 || libp) ;
09442 }
09443
09444 static int G__G__G3D_164_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09445 {
09446 G__letint(result7, 105, (long) ((const TPCON*) G__getstructoffset())->GetNz());
09447 return(1 || funcname || hash || result7 || libp) ;
09448 }
09449
09450 static int G__G__G3D_164_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09451 {
09452 G__letint(result7, 70, (long) ((const TPCON*) G__getstructoffset())->GetRmin());
09453 return(1 || funcname || hash || result7 || libp) ;
09454 }
09455
09456 static int G__G__G3D_164_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09457 {
09458 G__letint(result7, 70, (long) ((const TPCON*) G__getstructoffset())->GetRmax());
09459 return(1 || funcname || hash || result7 || libp) ;
09460 }
09461
09462 static int G__G__G3D_164_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09463 {
09464 G__letint(result7, 70, (long) ((const TPCON*) G__getstructoffset())->GetDz());
09465 return(1 || funcname || hash || result7 || libp) ;
09466 }
09467
09468 static int G__G__G3D_164_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09469 {
09470 G__letint(result7, 105, (long) ((const TPCON*) G__getstructoffset())->GetNdiv());
09471 return(1 || funcname || hash || result7 || libp) ;
09472 }
09473
09474 static int G__G__G3D_164_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09475 {
09476 ((TPCON*) G__getstructoffset())->SetNumberOfDivisions((Int_t) G__int(libp->para[0]));
09477 G__setnull(result7);
09478 return(1 || funcname || hash || result7 || libp) ;
09479 }
09480
09481 static int G__G__G3D_164_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09482 {
09483 G__letint(result7, 85, (long) TPCON::Class());
09484 return(1 || funcname || hash || result7 || libp) ;
09485 }
09486
09487 static int G__G__G3D_164_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09488 {
09489 G__letint(result7, 67, (long) TPCON::Class_Name());
09490 return(1 || funcname || hash || result7 || libp) ;
09491 }
09492
09493 static int G__G__G3D_164_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09494 {
09495 G__letint(result7, 115, (long) TPCON::Class_Version());
09496 return(1 || funcname || hash || result7 || libp) ;
09497 }
09498
09499 static int G__G__G3D_164_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09500 {
09501 TPCON::Dictionary();
09502 G__setnull(result7);
09503 return(1 || funcname || hash || result7 || libp) ;
09504 }
09505
09506 static int G__G__G3D_164_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09507 {
09508 ((TPCON*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09509 G__setnull(result7);
09510 return(1 || funcname || hash || result7 || libp) ;
09511 }
09512
09513 static int G__G__G3D_164_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09514 {
09515 G__letint(result7, 67, (long) TPCON::DeclFileName());
09516 return(1 || funcname || hash || result7 || libp) ;
09517 }
09518
09519 static int G__G__G3D_164_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09520 {
09521 G__letint(result7, 105, (long) TPCON::ImplFileLine());
09522 return(1 || funcname || hash || result7 || libp) ;
09523 }
09524
09525 static int G__G__G3D_164_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09526 {
09527 G__letint(result7, 67, (long) TPCON::ImplFileName());
09528 return(1 || funcname || hash || result7 || libp) ;
09529 }
09530
09531 static int G__G__G3D_164_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09532 {
09533 G__letint(result7, 105, (long) TPCON::DeclFileLine());
09534 return(1 || funcname || hash || result7 || libp) ;
09535 }
09536
09537
09538 typedef TPCON G__TTPCON;
09539 static int G__G__G3D_164_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09540 {
09541 char* gvp = (char*) G__getgvp();
09542 long soff = G__getstructoffset();
09543 int n = G__getaryconstruct();
09544
09545
09546
09547
09548
09549 if (!soff) {
09550 return(1);
09551 }
09552 if (n) {
09553 if (gvp == (char*)G__PVOID) {
09554 delete[] (TPCON*) soff;
09555 } else {
09556 G__setgvp((long) G__PVOID);
09557 for (int i = n - 1; i >= 0; --i) {
09558 ((TPCON*) (soff+(sizeof(TPCON)*i)))->~G__TTPCON();
09559 }
09560 G__setgvp((long)gvp);
09561 }
09562 } else {
09563 if (gvp == (char*)G__PVOID) {
09564 delete (TPCON*) soff;
09565 } else {
09566 G__setgvp((long) G__PVOID);
09567 ((TPCON*) (soff))->~G__TTPCON();
09568 G__setgvp((long)gvp);
09569 }
09570 }
09571 G__setnull(result7);
09572 return(1 || funcname || hash || result7 || libp) ;
09573 }
09574
09575
09576
09577 static int G__G__G3D_165_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09578 {
09579 TPGON* p = NULL;
09580 char* gvp = (char*) G__getgvp();
09581 int n = G__getaryconstruct();
09582 if (n) {
09583 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09584 p = new TPGON[n];
09585 } else {
09586 p = new((void*) gvp) TPGON[n];
09587 }
09588 } else {
09589 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09590 p = new TPGON;
09591 } else {
09592 p = new((void*) gvp) TPGON;
09593 }
09594 }
09595 result7->obj.i = (long) p;
09596 result7->ref = (long) p;
09597 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPGON));
09598 return(1 || funcname || hash || result7 || libp) ;
09599 }
09600
09601 static int G__G__G3D_165_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09602 {
09603 TPGON* p = NULL;
09604 char* gvp = (char*) G__getgvp();
09605
09606 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09607 p = new TPGON(
09608 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09609 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
09610 , (Float_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
09611 , (Int_t) G__int(libp->para[6]));
09612 } else {
09613 p = new((void*) gvp) TPGON(
09614 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09615 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
09616 , (Float_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
09617 , (Int_t) G__int(libp->para[6]));
09618 }
09619 result7->obj.i = (long) p;
09620 result7->ref = (long) p;
09621 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPGON));
09622 return(1 || funcname || hash || result7 || libp) ;
09623 }
09624
09625 static int G__G__G3D_165_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09626 {
09627 G__letint(result7, 85, (long) TPGON::Class());
09628 return(1 || funcname || hash || result7 || libp) ;
09629 }
09630
09631 static int G__G__G3D_165_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09632 {
09633 G__letint(result7, 67, (long) TPGON::Class_Name());
09634 return(1 || funcname || hash || result7 || libp) ;
09635 }
09636
09637 static int G__G__G3D_165_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09638 {
09639 G__letint(result7, 115, (long) TPGON::Class_Version());
09640 return(1 || funcname || hash || result7 || libp) ;
09641 }
09642
09643 static int G__G__G3D_165_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09644 {
09645 TPGON::Dictionary();
09646 G__setnull(result7);
09647 return(1 || funcname || hash || result7 || libp) ;
09648 }
09649
09650 static int G__G__G3D_165_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09651 {
09652 ((TPGON*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09653 G__setnull(result7);
09654 return(1 || funcname || hash || result7 || libp) ;
09655 }
09656
09657 static int G__G__G3D_165_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09658 {
09659 G__letint(result7, 67, (long) TPGON::DeclFileName());
09660 return(1 || funcname || hash || result7 || libp) ;
09661 }
09662
09663 static int G__G__G3D_165_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09664 {
09665 G__letint(result7, 105, (long) TPGON::ImplFileLine());
09666 return(1 || funcname || hash || result7 || libp) ;
09667 }
09668
09669 static int G__G__G3D_165_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09670 {
09671 G__letint(result7, 67, (long) TPGON::ImplFileName());
09672 return(1 || funcname || hash || result7 || libp) ;
09673 }
09674
09675 static int G__G__G3D_165_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09676 {
09677 G__letint(result7, 105, (long) TPGON::DeclFileLine());
09678 return(1 || funcname || hash || result7 || libp) ;
09679 }
09680
09681
09682 static int G__G__G3D_165_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09683
09684 {
09685 TPGON* p;
09686 void* tmp = (void*) G__int(libp->para[0]);
09687 p = new TPGON(*(TPGON*) tmp);
09688 result7->obj.i = (long) p;
09689 result7->ref = (long) p;
09690 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPGON));
09691 return(1 || funcname || hash || result7 || libp) ;
09692 }
09693
09694
09695 typedef TPGON G__TTPGON;
09696 static int G__G__G3D_165_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09697 {
09698 char* gvp = (char*) G__getgvp();
09699 long soff = G__getstructoffset();
09700 int n = G__getaryconstruct();
09701
09702
09703
09704
09705
09706 if (!soff) {
09707 return(1);
09708 }
09709 if (n) {
09710 if (gvp == (char*)G__PVOID) {
09711 delete[] (TPGON*) soff;
09712 } else {
09713 G__setgvp((long) G__PVOID);
09714 for (int i = n - 1; i >= 0; --i) {
09715 ((TPGON*) (soff+(sizeof(TPGON)*i)))->~G__TTPGON();
09716 }
09717 G__setgvp((long)gvp);
09718 }
09719 } else {
09720 if (gvp == (char*)G__PVOID) {
09721 delete (TPGON*) soff;
09722 } else {
09723 G__setgvp((long) G__PVOID);
09724 ((TPGON*) (soff))->~G__TTPGON();
09725 G__setgvp((long)gvp);
09726 }
09727 }
09728 G__setnull(result7);
09729 return(1 || funcname || hash || result7 || libp) ;
09730 }
09731
09732
09733
09734 static int G__G__G3D_166_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09735 {
09736 switch (libp->paran) {
09737 case 7:
09738 G__letint(result7, 105, (long) TPoints3DABC::DistancetoLine(
09739 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09740 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
09741 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
09742 , (Int_t) G__int(libp->para[6])));
09743 break;
09744 case 6:
09745 G__letint(result7, 105, (long) TPoints3DABC::DistancetoLine((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09746 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
09747 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])));
09748 break;
09749 }
09750 return(1 || funcname || hash || result7 || libp) ;
09751 }
09752
09753 static int G__G__G3D_166_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09754 {
09755 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->Add((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
09756 , (Float_t) G__double(libp->para[2])));
09757 return(1 || funcname || hash || result7 || libp) ;
09758 }
09759
09760 static int G__G__G3D_166_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09761 {
09762 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->AddLast((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
09763 , (Float_t) G__double(libp->para[2])));
09764 return(1 || funcname || hash || result7 || libp) ;
09765 }
09766
09767 static int G__G__G3D_166_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09768 {
09769 G__letint(result7, 105, (long) ((const TPoints3DABC*) G__getstructoffset())->GetLastPosition());
09770 return(1 || funcname || hash || result7 || libp) ;
09771 }
09772
09773 static int G__G__G3D_166_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09774 {
09775 G__letint(result7, 105, (long) ((const TPoints3DABC*) G__getstructoffset())->GetN());
09776 return(1 || funcname || hash || result7 || libp) ;
09777 }
09778
09779 static int G__G__G3D_166_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09780 {
09781 G__letint(result7, 70, (long) ((const TPoints3DABC*) G__getstructoffset())->GetP());
09782 return(1 || funcname || hash || result7 || libp) ;
09783 }
09784
09785 static int G__G__G3D_166_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09786 {
09787 G__letdouble(result7, 102, (double) ((const TPoints3DABC*) G__getstructoffset())->GetX((Int_t) G__int(libp->para[0])));
09788 return(1 || funcname || hash || result7 || libp) ;
09789 }
09790
09791 static int G__G__G3D_166_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09792 {
09793 G__letdouble(result7, 102, (double) ((const TPoints3DABC*) G__getstructoffset())->GetY((Int_t) G__int(libp->para[0])));
09794 return(1 || funcname || hash || result7 || libp) ;
09795 }
09796
09797 static int G__G__G3D_166_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09798 {
09799 G__letdouble(result7, 102, (double) ((const TPoints3DABC*) G__getstructoffset())->GetZ((Int_t) G__int(libp->para[0])));
09800 return(1 || funcname || hash || result7 || libp) ;
09801 }
09802
09803 static int G__G__G3D_166_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09804 {
09805 switch (libp->paran) {
09806 case 3:
09807 G__letint(result7, 70, (long) ((const TPoints3DABC*) G__getstructoffset())->GetXYZ((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09808 , (Int_t) G__int(libp->para[2])));
09809 break;
09810 case 2:
09811 G__letint(result7, 70, (long) ((const TPoints3DABC*) G__getstructoffset())->GetXYZ((Float_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
09812 break;
09813 }
09814 return(1 || funcname || hash || result7 || libp) ;
09815 }
09816
09817 static int G__G__G3D_166_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09818 {
09819 G__letint(result7, 70, (long) ((TPoints3DABC*) G__getstructoffset())->GetXYZ((Int_t) G__int(libp->para[0])));
09820 return(1 || funcname || hash || result7 || libp) ;
09821 }
09822
09823 static int G__G__G3D_166_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09824 {
09825 switch (libp->paran) {
09826 case 3:
09827 ((TPoints3DABC*) G__getstructoffset())->PaintPoints((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
09828 , (Option_t*) G__int(libp->para[2]));
09829 G__setnull(result7);
09830 break;
09831 case 2:
09832 ((TPoints3DABC*) G__getstructoffset())->PaintPoints((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
09833 G__setnull(result7);
09834 break;
09835 }
09836 return(1 || funcname || hash || result7 || libp) ;
09837 }
09838
09839 static int G__G__G3D_166_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09840 {
09841 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->SetLastPosition((Int_t) G__int(libp->para[0])));
09842 return(1 || funcname || hash || result7 || libp) ;
09843 }
09844
09845 static int G__G__G3D_166_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09846 {
09847 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->SetNextPoint((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
09848 , (Float_t) G__double(libp->para[2])));
09849 return(1 || funcname || hash || result7 || libp) ;
09850 }
09851
09852 static int G__G__G3D_166_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09853 {
09854 switch (libp->paran) {
09855 case 1:
09856 ((TPoints3DABC*) G__getstructoffset())->SetOption((Option_t*) G__int(libp->para[0]));
09857 G__setnull(result7);
09858 break;
09859 case 0:
09860 ((TPoints3DABC*) G__getstructoffset())->SetOption();
09861 G__setnull(result7);
09862 break;
09863 }
09864 return(1 || funcname || hash || result7 || libp) ;
09865 }
09866
09867 static int G__G__G3D_166_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09868 {
09869 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
09870 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])));
09871 return(1 || funcname || hash || result7 || libp) ;
09872 }
09873
09874 static int G__G__G3D_166_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09875 {
09876 switch (libp->paran) {
09877 case 3:
09878 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->SetPoints((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
09879 , (Option_t*) G__int(libp->para[2])));
09880 break;
09881 case 2:
09882 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->SetPoints((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])));
09883 break;
09884 case 1:
09885 G__letint(result7, 105, (long) ((TPoints3DABC*) G__getstructoffset())->SetPoints((Int_t) G__int(libp->para[0])));
09886 break;
09887 }
09888 return(1 || funcname || hash || result7 || libp) ;
09889 }
09890
09891 static int G__G__G3D_166_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09892 {
09893 G__letint(result7, 105, (long) ((const TPoints3DABC*) G__getstructoffset())->Size());
09894 return(1 || funcname || hash || result7 || libp) ;
09895 }
09896
09897 static int G__G__G3D_166_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09898 {
09899 G__letint(result7, 85, (long) TPoints3DABC::Class());
09900 return(1 || funcname || hash || result7 || libp) ;
09901 }
09902
09903 static int G__G__G3D_166_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09904 {
09905 G__letint(result7, 67, (long) TPoints3DABC::Class_Name());
09906 return(1 || funcname || hash || result7 || libp) ;
09907 }
09908
09909 static int G__G__G3D_166_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09910 {
09911 G__letint(result7, 115, (long) TPoints3DABC::Class_Version());
09912 return(1 || funcname || hash || result7 || libp) ;
09913 }
09914
09915 static int G__G__G3D_166_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09916 {
09917 TPoints3DABC::Dictionary();
09918 G__setnull(result7);
09919 return(1 || funcname || hash || result7 || libp) ;
09920 }
09921
09922 static int G__G__G3D_166_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09923 {
09924 ((TPoints3DABC*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09925 G__setnull(result7);
09926 return(1 || funcname || hash || result7 || libp) ;
09927 }
09928
09929 static int G__G__G3D_166_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09930 {
09931 G__letint(result7, 67, (long) TPoints3DABC::DeclFileName());
09932 return(1 || funcname || hash || result7 || libp) ;
09933 }
09934
09935 static int G__G__G3D_166_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09936 {
09937 G__letint(result7, 105, (long) TPoints3DABC::ImplFileLine());
09938 return(1 || funcname || hash || result7 || libp) ;
09939 }
09940
09941 static int G__G__G3D_166_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09942 {
09943 G__letint(result7, 67, (long) TPoints3DABC::ImplFileName());
09944 return(1 || funcname || hash || result7 || libp) ;
09945 }
09946
09947 static int G__G__G3D_166_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09948 {
09949 G__letint(result7, 105, (long) TPoints3DABC::DeclFileLine());
09950 return(1 || funcname || hash || result7 || libp) ;
09951 }
09952
09953
09954 typedef TPoints3DABC G__TTPoints3DABC;
09955 static int G__G__G3D_166_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09956 {
09957 char* gvp = (char*) G__getgvp();
09958 long soff = G__getstructoffset();
09959 int n = G__getaryconstruct();
09960
09961
09962
09963
09964
09965 if (!soff) {
09966 return(1);
09967 }
09968 if (n) {
09969 if (gvp == (char*)G__PVOID) {
09970 delete[] (TPoints3DABC*) soff;
09971 } else {
09972 G__setgvp((long) G__PVOID);
09973 for (int i = n - 1; i >= 0; --i) {
09974 ((TPoints3DABC*) (soff+(sizeof(TPoints3DABC)*i)))->~G__TTPoints3DABC();
09975 }
09976 G__setgvp((long)gvp);
09977 }
09978 } else {
09979 if (gvp == (char*)G__PVOID) {
09980 delete (TPoints3DABC*) soff;
09981 } else {
09982 G__setgvp((long) G__PVOID);
09983 ((TPoints3DABC*) (soff))->~G__TTPoints3DABC();
09984 G__setgvp((long)gvp);
09985 }
09986 }
09987 G__setnull(result7);
09988 return(1 || funcname || hash || result7 || libp) ;
09989 }
09990
09991
09992 static int G__G__G3D_166_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09993 {
09994 TPoints3DABC* dest = (TPoints3DABC*) G__getstructoffset();
09995 *dest = *(TPoints3DABC*) libp->para[0].ref;
09996 const TPoints3DABC& obj = *dest;
09997 result7->ref = (long) (&obj);
09998 result7->obj.i = (long) (&obj);
09999 return(1 || funcname || hash || result7 || libp) ;
10000 }
10001
10002
10003
10004 static int G__G__G3D_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10005 {
10006 TPolyMarker3D* p = NULL;
10007 char* gvp = (char*) G__getgvp();
10008 int n = G__getaryconstruct();
10009 if (n) {
10010 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10011 p = new TPolyMarker3D[n];
10012 } else {
10013 p = new((void*) gvp) TPolyMarker3D[n];
10014 }
10015 } else {
10016 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10017 p = new TPolyMarker3D;
10018 } else {
10019 p = new((void*) gvp) TPolyMarker3D;
10020 }
10021 }
10022 result7->obj.i = (long) p;
10023 result7->ref = (long) p;
10024 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
10025 return(1 || funcname || hash || result7 || libp) ;
10026 }
10027
10028 static int G__G__G3D_169_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10029 {
10030 TPolyMarker3D* p = NULL;
10031 char* gvp = (char*) G__getgvp();
10032 switch (libp->paran) {
10033 case 3:
10034
10035 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10036 p = new TPolyMarker3D(
10037 (Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1])
10038 , (Option_t*) G__int(libp->para[2]));
10039 } else {
10040 p = new((void*) gvp) TPolyMarker3D(
10041 (Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1])
10042 , (Option_t*) G__int(libp->para[2]));
10043 }
10044 break;
10045 case 2:
10046
10047 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10048 p = new TPolyMarker3D((Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1]));
10049 } else {
10050 p = new((void*) gvp) TPolyMarker3D((Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1]));
10051 }
10052 break;
10053 case 1:
10054
10055 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10056 p = new TPolyMarker3D((Int_t) G__int(libp->para[0]));
10057 } else {
10058 p = new((void*) gvp) TPolyMarker3D((Int_t) G__int(libp->para[0]));
10059 }
10060 break;
10061 }
10062 result7->obj.i = (long) p;
10063 result7->ref = (long) p;
10064 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
10065 return(1 || funcname || hash || result7 || libp) ;
10066 }
10067
10068 static int G__G__G3D_169_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10069 {
10070 TPolyMarker3D* p = NULL;
10071 char* gvp = (char*) G__getgvp();
10072 switch (libp->paran) {
10073 case 4:
10074
10075 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10076 p = new TPolyMarker3D(
10077 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10078 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10079 } else {
10080 p = new((void*) gvp) TPolyMarker3D(
10081 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10082 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10083 }
10084 break;
10085 case 3:
10086
10087 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10088 p = new TPolyMarker3D(
10089 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10090 , (Marker_t) G__int(libp->para[2]));
10091 } else {
10092 p = new((void*) gvp) TPolyMarker3D(
10093 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10094 , (Marker_t) G__int(libp->para[2]));
10095 }
10096 break;
10097 case 2:
10098
10099 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10100 p = new TPolyMarker3D((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
10101 } else {
10102 p = new((void*) gvp) TPolyMarker3D((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
10103 }
10104 break;
10105 }
10106 result7->obj.i = (long) p;
10107 result7->ref = (long) p;
10108 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
10109 return(1 || funcname || hash || result7 || libp) ;
10110 }
10111
10112 static int G__G__G3D_169_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10113 {
10114 TPolyMarker3D* p = NULL;
10115 char* gvp = (char*) G__getgvp();
10116 switch (libp->paran) {
10117 case 4:
10118
10119 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10120 p = new TPolyMarker3D(
10121 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10122 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10123 } else {
10124 p = new((void*) gvp) TPolyMarker3D(
10125 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10126 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10127 }
10128 break;
10129 case 3:
10130
10131 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10132 p = new TPolyMarker3D(
10133 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10134 , (Marker_t) G__int(libp->para[2]));
10135 } else {
10136 p = new((void*) gvp) TPolyMarker3D(
10137 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10138 , (Marker_t) G__int(libp->para[2]));
10139 }
10140 break;
10141 case 2:
10142
10143 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10144 p = new TPolyMarker3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
10145 } else {
10146 p = new((void*) gvp) TPolyMarker3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
10147 }
10148 break;
10149 }
10150 result7->obj.i = (long) p;
10151 result7->ref = (long) p;
10152 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
10153 return(1 || funcname || hash || result7 || libp) ;
10154 }
10155
10156 static int G__G__G3D_169_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10157 {
10158 TPolyMarker3D* p = NULL;
10159 char* gvp = (char*) G__getgvp();
10160
10161 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10162 p = new TPolyMarker3D(*(TPolyMarker3D*) libp->para[0].ref);
10163 } else {
10164 p = new((void*) gvp) TPolyMarker3D(*(TPolyMarker3D*) libp->para[0].ref);
10165 }
10166 result7->obj.i = (long) p;
10167 result7->ref = (long) p;
10168 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
10169 return(1 || funcname || hash || result7 || libp) ;
10170 }
10171
10172 static int G__G__G3D_169_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10173 {
10174 switch (libp->paran) {
10175 case 4:
10176 ((TPolyMarker3D*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10177 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10178 G__setnull(result7);
10179 break;
10180 case 3:
10181 ((TPolyMarker3D*) G__getstructoffset())->DrawPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10182 , (Marker_t) G__int(libp->para[2]));
10183 G__setnull(result7);
10184 break;
10185 }
10186 return(1 || funcname || hash || result7 || libp) ;
10187 }
10188
10189 static int G__G__G3D_169_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10190 {
10191 G__letint(result7, 105, (long) ((const TPolyMarker3D*) G__getstructoffset())->GetLastPoint());
10192 return(1 || funcname || hash || result7 || libp) ;
10193 }
10194
10195 static int G__G__G3D_169_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10196 {
10197 G__letint(result7, 105, (long) ((const TPolyMarker3D*) G__getstructoffset())->GetN());
10198 return(1 || funcname || hash || result7 || libp) ;
10199 }
10200
10201 static int G__G__G3D_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10202 {
10203 G__letint(result7, 70, (long) ((const TPolyMarker3D*) G__getstructoffset())->GetP());
10204 return(1 || funcname || hash || result7 || libp) ;
10205 }
10206
10207 static int G__G__G3D_169_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10208 {
10209 ((const TPolyMarker3D*) G__getstructoffset())->GetPoint((Int_t) G__int(libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
10210 , *(Float_t*) G__Floatref(&libp->para[2]), *(Float_t*) G__Floatref(&libp->para[3]));
10211 G__setnull(result7);
10212 return(1 || funcname || hash || result7 || libp) ;
10213 }
10214
10215 static int G__G__G3D_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10216 {
10217 ((const TPolyMarker3D*) G__getstructoffset())->GetPoint((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
10218 , *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
10219 G__setnull(result7);
10220 return(1 || funcname || hash || result7 || libp) ;
10221 }
10222
10223 static int G__G__G3D_169_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10224 {
10225 G__letint(result7, 105, (long) ((TPolyMarker3D*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
10226 return(1 || funcname || hash || result7 || libp) ;
10227 }
10228
10229 static int G__G__G3D_169_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10230 {
10231 ((TPolyMarker3D*) G__getstructoffset())->SetName((const char*) G__int(libp->para[0]));
10232 G__setnull(result7);
10233 return(1 || funcname || hash || result7 || libp) ;
10234 }
10235
10236 static int G__G__G3D_169_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10237 {
10238 ((TPolyMarker3D*) G__getstructoffset())->SetPoint((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
10239 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
10240 G__setnull(result7);
10241 return(1 || funcname || hash || result7 || libp) ;
10242 }
10243
10244 static int G__G__G3D_169_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10245 {
10246 switch (libp->paran) {
10247 case 4:
10248 ((TPolyMarker3D*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10249 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10250 G__setnull(result7);
10251 break;
10252 case 3:
10253 ((TPolyMarker3D*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10254 , (Marker_t) G__int(libp->para[2]));
10255 G__setnull(result7);
10256 break;
10257 }
10258 return(1 || funcname || hash || result7 || libp) ;
10259 }
10260
10261 static int G__G__G3D_169_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10262 {
10263 switch (libp->paran) {
10264 case 4:
10265 ((TPolyMarker3D*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10266 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10267 G__setnull(result7);
10268 break;
10269 case 3:
10270 ((TPolyMarker3D*) G__getstructoffset())->SetPolyMarker((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10271 , (Marker_t) G__int(libp->para[2]));
10272 G__setnull(result7);
10273 break;
10274 }
10275 return(1 || funcname || hash || result7 || libp) ;
10276 }
10277
10278 static int G__G__G3D_169_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10279 {
10280 G__letint(result7, 105, (long) ((TPolyMarker3D*) G__getstructoffset())->SetNextPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
10281 , (Double_t) G__double(libp->para[2])));
10282 return(1 || funcname || hash || result7 || libp) ;
10283 }
10284
10285 static int G__G__G3D_169_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10286 {
10287 G__letint(result7, 105, (long) ((const TPolyMarker3D*) G__getstructoffset())->Size());
10288 return(1 || funcname || hash || result7 || libp) ;
10289 }
10290
10291 static int G__G__G3D_169_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10292 {
10293 TPolyMarker3D::PaintH3((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
10294 G__setnull(result7);
10295 return(1 || funcname || hash || result7 || libp) ;
10296 }
10297
10298 static int G__G__G3D_169_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10299 {
10300 G__letint(result7, 85, (long) TPolyMarker3D::Class());
10301 return(1 || funcname || hash || result7 || libp) ;
10302 }
10303
10304 static int G__G__G3D_169_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10305 {
10306 G__letint(result7, 67, (long) TPolyMarker3D::Class_Name());
10307 return(1 || funcname || hash || result7 || libp) ;
10308 }
10309
10310 static int G__G__G3D_169_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10311 {
10312 G__letint(result7, 115, (long) TPolyMarker3D::Class_Version());
10313 return(1 || funcname || hash || result7 || libp) ;
10314 }
10315
10316 static int G__G__G3D_169_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10317 {
10318 TPolyMarker3D::Dictionary();
10319 G__setnull(result7);
10320 return(1 || funcname || hash || result7 || libp) ;
10321 }
10322
10323 static int G__G__G3D_169_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10324 {
10325 ((TPolyMarker3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10326 G__setnull(result7);
10327 return(1 || funcname || hash || result7 || libp) ;
10328 }
10329
10330 static int G__G__G3D_169_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10331 {
10332 G__letint(result7, 67, (long) TPolyMarker3D::DeclFileName());
10333 return(1 || funcname || hash || result7 || libp) ;
10334 }
10335
10336 static int G__G__G3D_169_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10337 {
10338 G__letint(result7, 105, (long) TPolyMarker3D::ImplFileLine());
10339 return(1 || funcname || hash || result7 || libp) ;
10340 }
10341
10342 static int G__G__G3D_169_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10343 {
10344 G__letint(result7, 67, (long) TPolyMarker3D::ImplFileName());
10345 return(1 || funcname || hash || result7 || libp) ;
10346 }
10347
10348 static int G__G__G3D_169_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10349 {
10350 G__letint(result7, 105, (long) TPolyMarker3D::DeclFileLine());
10351 return(1 || funcname || hash || result7 || libp) ;
10352 }
10353
10354
10355 typedef TPolyMarker3D G__TTPolyMarker3D;
10356 static int G__G__G3D_169_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10357 {
10358 char* gvp = (char*) G__getgvp();
10359 long soff = G__getstructoffset();
10360 int n = G__getaryconstruct();
10361
10362
10363
10364
10365
10366 if (!soff) {
10367 return(1);
10368 }
10369 if (n) {
10370 if (gvp == (char*)G__PVOID) {
10371 delete[] (TPolyMarker3D*) soff;
10372 } else {
10373 G__setgvp((long) G__PVOID);
10374 for (int i = n - 1; i >= 0; --i) {
10375 ((TPolyMarker3D*) (soff+(sizeof(TPolyMarker3D)*i)))->~G__TTPolyMarker3D();
10376 }
10377 G__setgvp((long)gvp);
10378 }
10379 } else {
10380 if (gvp == (char*)G__PVOID) {
10381 delete (TPolyMarker3D*) soff;
10382 } else {
10383 G__setgvp((long) G__PVOID);
10384 ((TPolyMarker3D*) (soff))->~G__TTPolyMarker3D();
10385 G__setgvp((long)gvp);
10386 }
10387 }
10388 G__setnull(result7);
10389 return(1 || funcname || hash || result7 || libp) ;
10390 }
10391
10392
10393
10394 static int G__G__G3D_176_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10395 {
10396 TPointSet3D* p = NULL;
10397 char* gvp = (char*) G__getgvp();
10398 int n = G__getaryconstruct();
10399 if (n) {
10400 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10401 p = new TPointSet3D[n];
10402 } else {
10403 p = new((void*) gvp) TPointSet3D[n];
10404 }
10405 } else {
10406 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10407 p = new TPointSet3D;
10408 } else {
10409 p = new((void*) gvp) TPointSet3D;
10410 }
10411 }
10412 result7->obj.i = (long) p;
10413 result7->ref = (long) p;
10414 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
10415 return(1 || funcname || hash || result7 || libp) ;
10416 }
10417
10418 static int G__G__G3D_176_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10419 {
10420 TPointSet3D* p = NULL;
10421 char* gvp = (char*) G__getgvp();
10422 switch (libp->paran) {
10423 case 3:
10424
10425 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10426 p = new TPointSet3D(
10427 (Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1])
10428 , (Option_t*) G__int(libp->para[2]));
10429 } else {
10430 p = new((void*) gvp) TPointSet3D(
10431 (Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1])
10432 , (Option_t*) G__int(libp->para[2]));
10433 }
10434 break;
10435 case 2:
10436
10437 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10438 p = new TPointSet3D((Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1]));
10439 } else {
10440 p = new((void*) gvp) TPointSet3D((Int_t) G__int(libp->para[0]), (Marker_t) G__int(libp->para[1]));
10441 }
10442 break;
10443 case 1:
10444
10445 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10446 p = new TPointSet3D((Int_t) G__int(libp->para[0]));
10447 } else {
10448 p = new((void*) gvp) TPointSet3D((Int_t) G__int(libp->para[0]));
10449 }
10450 break;
10451 }
10452 result7->obj.i = (long) p;
10453 result7->ref = (long) p;
10454 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
10455 return(1 || funcname || hash || result7 || libp) ;
10456 }
10457
10458 static int G__G__G3D_176_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10459 {
10460 TPointSet3D* p = NULL;
10461 char* gvp = (char*) G__getgvp();
10462 switch (libp->paran) {
10463 case 4:
10464
10465 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10466 p = new TPointSet3D(
10467 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10468 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10469 } else {
10470 p = new((void*) gvp) TPointSet3D(
10471 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10472 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10473 }
10474 break;
10475 case 3:
10476
10477 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10478 p = new TPointSet3D(
10479 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10480 , (Marker_t) G__int(libp->para[2]));
10481 } else {
10482 p = new((void*) gvp) TPointSet3D(
10483 (Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
10484 , (Marker_t) G__int(libp->para[2]));
10485 }
10486 break;
10487 case 2:
10488
10489 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10490 p = new TPointSet3D((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
10491 } else {
10492 p = new((void*) gvp) TPointSet3D((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
10493 }
10494 break;
10495 }
10496 result7->obj.i = (long) p;
10497 result7->ref = (long) p;
10498 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
10499 return(1 || funcname || hash || result7 || libp) ;
10500 }
10501
10502 static int G__G__G3D_176_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10503 {
10504 TPointSet3D* p = NULL;
10505 char* gvp = (char*) G__getgvp();
10506 switch (libp->paran) {
10507 case 4:
10508
10509 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10510 p = new TPointSet3D(
10511 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10512 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10513 } else {
10514 p = new((void*) gvp) TPointSet3D(
10515 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10516 , (Marker_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
10517 }
10518 break;
10519 case 3:
10520
10521 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10522 p = new TPointSet3D(
10523 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10524 , (Marker_t) G__int(libp->para[2]));
10525 } else {
10526 p = new((void*) gvp) TPointSet3D(
10527 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
10528 , (Marker_t) G__int(libp->para[2]));
10529 }
10530 break;
10531 case 2:
10532
10533 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10534 p = new TPointSet3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
10535 } else {
10536 p = new((void*) gvp) TPointSet3D((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
10537 }
10538 break;
10539 }
10540 result7->obj.i = (long) p;
10541 result7->ref = (long) p;
10542 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
10543 return(1 || funcname || hash || result7 || libp) ;
10544 }
10545
10546 static int G__G__G3D_176_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10547 {
10548 TPointSet3D* p = NULL;
10549 char* gvp = (char*) G__getgvp();
10550
10551 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10552 p = new TPointSet3D(*(TPointSet3D*) libp->para[0].ref);
10553 } else {
10554 p = new((void*) gvp) TPointSet3D(*(TPointSet3D*) libp->para[0].ref);
10555 }
10556 result7->obj.i = (long) p;
10557 result7->ref = (long) p;
10558 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
10559 return(1 || funcname || hash || result7 || libp) ;
10560 }
10561
10562 static int G__G__G3D_176_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10563 {
10564 {
10565 const TPointSet3D& obj = ((TPointSet3D*) G__getstructoffset())->operator=(*(TPointSet3D*) libp->para[0].ref);
10566 result7->ref = (long) (&obj);
10567 result7->obj.i = (long) (&obj);
10568 }
10569 return(1 || funcname || hash || result7 || libp) ;
10570 }
10571
10572 static int G__G__G3D_176_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10573 {
10574 ((TPointSet3D*) G__getstructoffset())->SetPointId((TObject*) G__int(libp->para[0]));
10575 G__setnull(result7);
10576 return(1 || funcname || hash || result7 || libp) ;
10577 }
10578
10579 static int G__G__G3D_176_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10580 {
10581 ((TPointSet3D*) G__getstructoffset())->SetPointId((Int_t) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
10582 G__setnull(result7);
10583 return(1 || funcname || hash || result7 || libp) ;
10584 }
10585
10586 static int G__G__G3D_176_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10587 {
10588 G__letint(result7, 85, (long) ((const TPointSet3D*) G__getstructoffset())->GetPointId((Int_t) G__int(libp->para[0])));
10589 return(1 || funcname || hash || result7 || libp) ;
10590 }
10591
10592 static int G__G__G3D_176_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10593 {
10594 ((TPointSet3D*) G__getstructoffset())->ClearIds();
10595 G__setnull(result7);
10596 return(1 || funcname || hash || result7 || libp) ;
10597 }
10598
10599 static int G__G__G3D_176_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10600 {
10601 G__letint(result7, 103, (long) ((const TPointSet3D*) G__getstructoffset())->GetOwnIds());
10602 return(1 || funcname || hash || result7 || libp) ;
10603 }
10604
10605 static int G__G__G3D_176_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10606 {
10607 ((TPointSet3D*) G__getstructoffset())->SetOwnIds((Bool_t) G__int(libp->para[0]));
10608 G__setnull(result7);
10609 return(1 || funcname || hash || result7 || libp) ;
10610 }
10611
10612 static int G__G__G3D_176_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10613 {
10614 ((TPointSet3D*) G__getstructoffset())->PointSelected((Int_t) G__int(libp->para[0]));
10615 G__setnull(result7);
10616 return(1 || funcname || hash || result7 || libp) ;
10617 }
10618
10619 static int G__G__G3D_176_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10620 {
10621 G__letint(result7, 85, (long) TPointSet3D::Class());
10622 return(1 || funcname || hash || result7 || libp) ;
10623 }
10624
10625 static int G__G__G3D_176_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10626 {
10627 G__letint(result7, 67, (long) TPointSet3D::Class_Name());
10628 return(1 || funcname || hash || result7 || libp) ;
10629 }
10630
10631 static int G__G__G3D_176_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10632 {
10633 G__letint(result7, 115, (long) TPointSet3D::Class_Version());
10634 return(1 || funcname || hash || result7 || libp) ;
10635 }
10636
10637 static int G__G__G3D_176_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10638 {
10639 TPointSet3D::Dictionary();
10640 G__setnull(result7);
10641 return(1 || funcname || hash || result7 || libp) ;
10642 }
10643
10644 static int G__G__G3D_176_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10645 {
10646 ((TPointSet3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10647 G__setnull(result7);
10648 return(1 || funcname || hash || result7 || libp) ;
10649 }
10650
10651 static int G__G__G3D_176_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10652 {
10653 G__letint(result7, 67, (long) TPointSet3D::DeclFileName());
10654 return(1 || funcname || hash || result7 || libp) ;
10655 }
10656
10657 static int G__G__G3D_176_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10658 {
10659 G__letint(result7, 105, (long) TPointSet3D::ImplFileLine());
10660 return(1 || funcname || hash || result7 || libp) ;
10661 }
10662
10663 static int G__G__G3D_176_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10664 {
10665 G__letint(result7, 67, (long) TPointSet3D::ImplFileName());
10666 return(1 || funcname || hash || result7 || libp) ;
10667 }
10668
10669 static int G__G__G3D_176_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10670 {
10671 G__letint(result7, 105, (long) TPointSet3D::DeclFileLine());
10672 return(1 || funcname || hash || result7 || libp) ;
10673 }
10674
10675
10676 typedef TPointSet3D G__TTPointSet3D;
10677 static int G__G__G3D_176_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10678 {
10679 char* gvp = (char*) G__getgvp();
10680 long soff = G__getstructoffset();
10681 int n = G__getaryconstruct();
10682
10683
10684
10685
10686
10687 if (!soff) {
10688 return(1);
10689 }
10690 if (n) {
10691 if (gvp == (char*)G__PVOID) {
10692 delete[] (TPointSet3D*) soff;
10693 } else {
10694 G__setgvp((long) G__PVOID);
10695 for (int i = n - 1; i >= 0; --i) {
10696 ((TPointSet3D*) (soff+(sizeof(TPointSet3D)*i)))->~G__TTPointSet3D();
10697 }
10698 G__setgvp((long)gvp);
10699 }
10700 } else {
10701 if (gvp == (char*)G__PVOID) {
10702 delete (TPointSet3D*) soff;
10703 } else {
10704 G__setgvp((long) G__PVOID);
10705 ((TPointSet3D*) (soff))->~G__TTPointSet3D();
10706 G__setgvp((long)gvp);
10707 }
10708 }
10709 G__setnull(result7);
10710 return(1 || funcname || hash || result7 || libp) ;
10711 }
10712
10713
10714
10715 static int G__G__G3D_177_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10716 {
10717 TSPHE* p = NULL;
10718 char* gvp = (char*) G__getgvp();
10719 int n = G__getaryconstruct();
10720 if (n) {
10721 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10722 p = new TSPHE[n];
10723 } else {
10724 p = new((void*) gvp) TSPHE[n];
10725 }
10726 } else {
10727 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10728 p = new TSPHE;
10729 } else {
10730 p = new((void*) gvp) TSPHE;
10731 }
10732 }
10733 result7->obj.i = (long) p;
10734 result7->ref = (long) p;
10735 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TSPHE));
10736 return(1 || funcname || hash || result7 || libp) ;
10737 }
10738
10739 static int G__G__G3D_177_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10740 {
10741 TSPHE* p = NULL;
10742 char* gvp = (char*) G__getgvp();
10743
10744 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10745 p = new TSPHE(
10746 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10747 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
10748 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
10749 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
10750 , (Float_t) G__double(libp->para[8]));
10751 } else {
10752 p = new((void*) gvp) TSPHE(
10753 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10754 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
10755 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
10756 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
10757 , (Float_t) G__double(libp->para[8]));
10758 }
10759 result7->obj.i = (long) p;
10760 result7->ref = (long) p;
10761 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TSPHE));
10762 return(1 || funcname || hash || result7 || libp) ;
10763 }
10764
10765 static int G__G__G3D_177_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10766 {
10767 TSPHE* p = NULL;
10768 char* gvp = (char*) G__getgvp();
10769
10770 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10771 p = new TSPHE(
10772 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10773 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3]));
10774 } else {
10775 p = new((void*) gvp) TSPHE(
10776 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10777 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3]));
10778 }
10779 result7->obj.i = (long) p;
10780 result7->ref = (long) p;
10781 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TSPHE));
10782 return(1 || funcname || hash || result7 || libp) ;
10783 }
10784
10785 static int G__G__G3D_177_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10786 {
10787 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetRmin());
10788 return(1 || funcname || hash || result7 || libp) ;
10789 }
10790
10791 static int G__G__G3D_177_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10792 {
10793 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetRmax());
10794 return(1 || funcname || hash || result7 || libp) ;
10795 }
10796
10797 static int G__G__G3D_177_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10798 {
10799 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetThemin());
10800 return(1 || funcname || hash || result7 || libp) ;
10801 }
10802
10803 static int G__G__G3D_177_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10804 {
10805 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetThemax());
10806 return(1 || funcname || hash || result7 || libp) ;
10807 }
10808
10809 static int G__G__G3D_177_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10810 {
10811 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetPhimin());
10812 return(1 || funcname || hash || result7 || libp) ;
10813 }
10814
10815 static int G__G__G3D_177_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10816 {
10817 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetPhimax());
10818 return(1 || funcname || hash || result7 || libp) ;
10819 }
10820
10821 static int G__G__G3D_177_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10822 {
10823 G__letdouble(result7, 102, (double) ((const TSPHE*) G__getstructoffset())->GetAspectRatio());
10824 return(1 || funcname || hash || result7 || libp) ;
10825 }
10826
10827 static int G__G__G3D_177_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10828 {
10829 G__letint(result7, 105, (long) ((const TSPHE*) G__getstructoffset())->GetNumberOfDivisions());
10830 return(1 || funcname || hash || result7 || libp) ;
10831 }
10832
10833 static int G__G__G3D_177_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10834 {
10835 switch (libp->paran) {
10836 case 1:
10837 ((TSPHE*) G__getstructoffset())->SetAspectRatio((Float_t) G__double(libp->para[0]));
10838 G__setnull(result7);
10839 break;
10840 case 0:
10841 ((TSPHE*) G__getstructoffset())->SetAspectRatio();
10842 G__setnull(result7);
10843 break;
10844 }
10845 return(1 || funcname || hash || result7 || libp) ;
10846 }
10847
10848 static int G__G__G3D_177_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10849 {
10850 ((TSPHE*) G__getstructoffset())->SetEllipse((Float_t*) G__int(libp->para[0]));
10851 G__setnull(result7);
10852 return(1 || funcname || hash || result7 || libp) ;
10853 }
10854
10855 static int G__G__G3D_177_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10856 {
10857 ((TSPHE*) G__getstructoffset())->SetNumberOfDivisions((Int_t) G__int(libp->para[0]));
10858 G__setnull(result7);
10859 return(1 || funcname || hash || result7 || libp) ;
10860 }
10861
10862 static int G__G__G3D_177_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10863 {
10864 G__letint(result7, 85, (long) TSPHE::Class());
10865 return(1 || funcname || hash || result7 || libp) ;
10866 }
10867
10868 static int G__G__G3D_177_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10869 {
10870 G__letint(result7, 67, (long) TSPHE::Class_Name());
10871 return(1 || funcname || hash || result7 || libp) ;
10872 }
10873
10874 static int G__G__G3D_177_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10875 {
10876 G__letint(result7, 115, (long) TSPHE::Class_Version());
10877 return(1 || funcname || hash || result7 || libp) ;
10878 }
10879
10880 static int G__G__G3D_177_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10881 {
10882 TSPHE::Dictionary();
10883 G__setnull(result7);
10884 return(1 || funcname || hash || result7 || libp) ;
10885 }
10886
10887 static int G__G__G3D_177_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10888 {
10889 ((TSPHE*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10890 G__setnull(result7);
10891 return(1 || funcname || hash || result7 || libp) ;
10892 }
10893
10894 static int G__G__G3D_177_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10895 {
10896 G__letint(result7, 67, (long) TSPHE::DeclFileName());
10897 return(1 || funcname || hash || result7 || libp) ;
10898 }
10899
10900 static int G__G__G3D_177_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10901 {
10902 G__letint(result7, 105, (long) TSPHE::ImplFileLine());
10903 return(1 || funcname || hash || result7 || libp) ;
10904 }
10905
10906 static int G__G__G3D_177_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10907 {
10908 G__letint(result7, 67, (long) TSPHE::ImplFileName());
10909 return(1 || funcname || hash || result7 || libp) ;
10910 }
10911
10912 static int G__G__G3D_177_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10913 {
10914 G__letint(result7, 105, (long) TSPHE::DeclFileLine());
10915 return(1 || funcname || hash || result7 || libp) ;
10916 }
10917
10918
10919 static int G__G__G3D_177_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10920
10921 {
10922 TSPHE* p;
10923 void* tmp = (void*) G__int(libp->para[0]);
10924 p = new TSPHE(*(TSPHE*) tmp);
10925 result7->obj.i = (long) p;
10926 result7->ref = (long) p;
10927 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TSPHE));
10928 return(1 || funcname || hash || result7 || libp) ;
10929 }
10930
10931
10932 typedef TSPHE G__TTSPHE;
10933 static int G__G__G3D_177_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10934 {
10935 char* gvp = (char*) G__getgvp();
10936 long soff = G__getstructoffset();
10937 int n = G__getaryconstruct();
10938
10939
10940
10941
10942
10943 if (!soff) {
10944 return(1);
10945 }
10946 if (n) {
10947 if (gvp == (char*)G__PVOID) {
10948 delete[] (TSPHE*) soff;
10949 } else {
10950 G__setgvp((long) G__PVOID);
10951 for (int i = n - 1; i >= 0; --i) {
10952 ((TSPHE*) (soff+(sizeof(TSPHE)*i)))->~G__TTSPHE();
10953 }
10954 G__setgvp((long)gvp);
10955 }
10956 } else {
10957 if (gvp == (char*)G__PVOID) {
10958 delete (TSPHE*) soff;
10959 } else {
10960 G__setgvp((long) G__PVOID);
10961 ((TSPHE*) (soff))->~G__TTSPHE();
10962 G__setgvp((long)gvp);
10963 }
10964 }
10965 G__setnull(result7);
10966 return(1 || funcname || hash || result7 || libp) ;
10967 }
10968
10969
10970 static int G__G__G3D_177_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10971 {
10972 TSPHE* dest = (TSPHE*) G__getstructoffset();
10973 *dest = *(TSPHE*) libp->para[0].ref;
10974 const TSPHE& obj = *dest;
10975 result7->ref = (long) (&obj);
10976 result7->obj.i = (long) (&obj);
10977 return(1 || funcname || hash || result7 || libp) ;
10978 }
10979
10980
10981
10982 static int G__G__G3D_178_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10983 {
10984 TTRAP* p = NULL;
10985 char* gvp = (char*) G__getgvp();
10986 int n = G__getaryconstruct();
10987 if (n) {
10988 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10989 p = new TTRAP[n];
10990 } else {
10991 p = new((void*) gvp) TTRAP[n];
10992 }
10993 } else {
10994 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10995 p = new TTRAP;
10996 } else {
10997 p = new((void*) gvp) TTRAP;
10998 }
10999 }
11000 result7->obj.i = (long) p;
11001 result7->ref = (long) p;
11002 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRAP));
11003 return(1 || funcname || hash || result7 || libp) ;
11004 }
11005
11006 static int G__G__G3D_178_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11007 {
11008 TTRAP* p = NULL;
11009 char* gvp = (char*) G__getgvp();
11010
11011 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11012 p = new TTRAP(
11013 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11014 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
11015 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11016 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
11017 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
11018 , (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
11019 , (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13]));
11020 } else {
11021 p = new((void*) gvp) TTRAP(
11022 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11023 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
11024 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11025 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
11026 , (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
11027 , (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
11028 , (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13]));
11029 }
11030 result7->obj.i = (long) p;
11031 result7->ref = (long) p;
11032 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRAP));
11033 return(1 || funcname || hash || result7 || libp) ;
11034 }
11035
11036 static int G__G__G3D_178_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11037 {
11038 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetH1());
11039 return(1 || funcname || hash || result7 || libp) ;
11040 }
11041
11042 static int G__G__G3D_178_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11043 {
11044 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetBl1());
11045 return(1 || funcname || hash || result7 || libp) ;
11046 }
11047
11048 static int G__G__G3D_178_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11049 {
11050 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetTl1());
11051 return(1 || funcname || hash || result7 || libp) ;
11052 }
11053
11054 static int G__G__G3D_178_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11055 {
11056 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetAlpha1());
11057 return(1 || funcname || hash || result7 || libp) ;
11058 }
11059
11060 static int G__G__G3D_178_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11061 {
11062 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetH2());
11063 return(1 || funcname || hash || result7 || libp) ;
11064 }
11065
11066 static int G__G__G3D_178_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11067 {
11068 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetBl2());
11069 return(1 || funcname || hash || result7 || libp) ;
11070 }
11071
11072 static int G__G__G3D_178_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11073 {
11074 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetTl2());
11075 return(1 || funcname || hash || result7 || libp) ;
11076 }
11077
11078 static int G__G__G3D_178_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11079 {
11080 G__letdouble(result7, 102, (double) ((const TTRAP*) G__getstructoffset())->GetAlpha2());
11081 return(1 || funcname || hash || result7 || libp) ;
11082 }
11083
11084 static int G__G__G3D_178_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11085 {
11086 G__letint(result7, 85, (long) TTRAP::Class());
11087 return(1 || funcname || hash || result7 || libp) ;
11088 }
11089
11090 static int G__G__G3D_178_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11091 {
11092 G__letint(result7, 67, (long) TTRAP::Class_Name());
11093 return(1 || funcname || hash || result7 || libp) ;
11094 }
11095
11096 static int G__G__G3D_178_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11097 {
11098 G__letint(result7, 115, (long) TTRAP::Class_Version());
11099 return(1 || funcname || hash || result7 || libp) ;
11100 }
11101
11102 static int G__G__G3D_178_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11103 {
11104 TTRAP::Dictionary();
11105 G__setnull(result7);
11106 return(1 || funcname || hash || result7 || libp) ;
11107 }
11108
11109 static int G__G__G3D_178_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11110 {
11111 ((TTRAP*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11112 G__setnull(result7);
11113 return(1 || funcname || hash || result7 || libp) ;
11114 }
11115
11116 static int G__G__G3D_178_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11117 {
11118 G__letint(result7, 67, (long) TTRAP::DeclFileName());
11119 return(1 || funcname || hash || result7 || libp) ;
11120 }
11121
11122 static int G__G__G3D_178_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11123 {
11124 G__letint(result7, 105, (long) TTRAP::ImplFileLine());
11125 return(1 || funcname || hash || result7 || libp) ;
11126 }
11127
11128 static int G__G__G3D_178_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11129 {
11130 G__letint(result7, 67, (long) TTRAP::ImplFileName());
11131 return(1 || funcname || hash || result7 || libp) ;
11132 }
11133
11134 static int G__G__G3D_178_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11135 {
11136 G__letint(result7, 105, (long) TTRAP::DeclFileLine());
11137 return(1 || funcname || hash || result7 || libp) ;
11138 }
11139
11140
11141 static int G__G__G3D_178_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11142
11143 {
11144 TTRAP* p;
11145 void* tmp = (void*) G__int(libp->para[0]);
11146 p = new TTRAP(*(TTRAP*) tmp);
11147 result7->obj.i = (long) p;
11148 result7->ref = (long) p;
11149 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRAP));
11150 return(1 || funcname || hash || result7 || libp) ;
11151 }
11152
11153
11154 typedef TTRAP G__TTTRAP;
11155 static int G__G__G3D_178_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11156 {
11157 char* gvp = (char*) G__getgvp();
11158 long soff = G__getstructoffset();
11159 int n = G__getaryconstruct();
11160
11161
11162
11163
11164
11165 if (!soff) {
11166 return(1);
11167 }
11168 if (n) {
11169 if (gvp == (char*)G__PVOID) {
11170 delete[] (TTRAP*) soff;
11171 } else {
11172 G__setgvp((long) G__PVOID);
11173 for (int i = n - 1; i >= 0; --i) {
11174 ((TTRAP*) (soff+(sizeof(TTRAP)*i)))->~G__TTTRAP();
11175 }
11176 G__setgvp((long)gvp);
11177 }
11178 } else {
11179 if (gvp == (char*)G__PVOID) {
11180 delete (TTRAP*) soff;
11181 } else {
11182 G__setgvp((long) G__PVOID);
11183 ((TTRAP*) (soff))->~G__TTTRAP();
11184 G__setgvp((long)gvp);
11185 }
11186 }
11187 G__setnull(result7);
11188 return(1 || funcname || hash || result7 || libp) ;
11189 }
11190
11191
11192 static int G__G__G3D_178_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11193 {
11194 TTRAP* dest = (TTRAP*) G__getstructoffset();
11195 *dest = *(TTRAP*) libp->para[0].ref;
11196 const TTRAP& obj = *dest;
11197 result7->ref = (long) (&obj);
11198 result7->obj.i = (long) (&obj);
11199 return(1 || funcname || hash || result7 || libp) ;
11200 }
11201
11202
11203
11204 static int G__G__G3D_179_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11205 {
11206 TTRD1* p = NULL;
11207 char* gvp = (char*) G__getgvp();
11208 int n = G__getaryconstruct();
11209 if (n) {
11210 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11211 p = new TTRD1[n];
11212 } else {
11213 p = new((void*) gvp) TTRD1[n];
11214 }
11215 } else {
11216 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11217 p = new TTRD1;
11218 } else {
11219 p = new((void*) gvp) TTRD1;
11220 }
11221 }
11222 result7->obj.i = (long) p;
11223 result7->ref = (long) p;
11224 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRD1));
11225 return(1 || funcname || hash || result7 || libp) ;
11226 }
11227
11228 static int G__G__G3D_179_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11229 {
11230 TTRD1* p = NULL;
11231 char* gvp = (char*) G__getgvp();
11232
11233 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11234 p = new TTRD1(
11235 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11236 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
11237 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11238 , (Float_t) G__double(libp->para[6]));
11239 } else {
11240 p = new((void*) gvp) TTRD1(
11241 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11242 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
11243 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11244 , (Float_t) G__double(libp->para[6]));
11245 }
11246 result7->obj.i = (long) p;
11247 result7->ref = (long) p;
11248 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRD1));
11249 return(1 || funcname || hash || result7 || libp) ;
11250 }
11251
11252 static int G__G__G3D_179_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11253 {
11254 G__letdouble(result7, 102, (double) ((const TTRD1*) G__getstructoffset())->GetDx2());
11255 return(1 || funcname || hash || result7 || libp) ;
11256 }
11257
11258 static int G__G__G3D_179_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11259 {
11260 G__letint(result7, 85, (long) TTRD1::Class());
11261 return(1 || funcname || hash || result7 || libp) ;
11262 }
11263
11264 static int G__G__G3D_179_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11265 {
11266 G__letint(result7, 67, (long) TTRD1::Class_Name());
11267 return(1 || funcname || hash || result7 || libp) ;
11268 }
11269
11270 static int G__G__G3D_179_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11271 {
11272 G__letint(result7, 115, (long) TTRD1::Class_Version());
11273 return(1 || funcname || hash || result7 || libp) ;
11274 }
11275
11276 static int G__G__G3D_179_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11277 {
11278 TTRD1::Dictionary();
11279 G__setnull(result7);
11280 return(1 || funcname || hash || result7 || libp) ;
11281 }
11282
11283 static int G__G__G3D_179_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11284 {
11285 ((TTRD1*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11286 G__setnull(result7);
11287 return(1 || funcname || hash || result7 || libp) ;
11288 }
11289
11290 static int G__G__G3D_179_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11291 {
11292 G__letint(result7, 67, (long) TTRD1::DeclFileName());
11293 return(1 || funcname || hash || result7 || libp) ;
11294 }
11295
11296 static int G__G__G3D_179_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11297 {
11298 G__letint(result7, 105, (long) TTRD1::ImplFileLine());
11299 return(1 || funcname || hash || result7 || libp) ;
11300 }
11301
11302 static int G__G__G3D_179_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11303 {
11304 G__letint(result7, 67, (long) TTRD1::ImplFileName());
11305 return(1 || funcname || hash || result7 || libp) ;
11306 }
11307
11308 static int G__G__G3D_179_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11309 {
11310 G__letint(result7, 105, (long) TTRD1::DeclFileLine());
11311 return(1 || funcname || hash || result7 || libp) ;
11312 }
11313
11314
11315 static int G__G__G3D_179_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11316
11317 {
11318 TTRD1* p;
11319 void* tmp = (void*) G__int(libp->para[0]);
11320 p = new TTRD1(*(TTRD1*) tmp);
11321 result7->obj.i = (long) p;
11322 result7->ref = (long) p;
11323 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRD1));
11324 return(1 || funcname || hash || result7 || libp) ;
11325 }
11326
11327
11328 typedef TTRD1 G__TTTRD1;
11329 static int G__G__G3D_179_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11330 {
11331 char* gvp = (char*) G__getgvp();
11332 long soff = G__getstructoffset();
11333 int n = G__getaryconstruct();
11334
11335
11336
11337
11338
11339 if (!soff) {
11340 return(1);
11341 }
11342 if (n) {
11343 if (gvp == (char*)G__PVOID) {
11344 delete[] (TTRD1*) soff;
11345 } else {
11346 G__setgvp((long) G__PVOID);
11347 for (int i = n - 1; i >= 0; --i) {
11348 ((TTRD1*) (soff+(sizeof(TTRD1)*i)))->~G__TTTRD1();
11349 }
11350 G__setgvp((long)gvp);
11351 }
11352 } else {
11353 if (gvp == (char*)G__PVOID) {
11354 delete (TTRD1*) soff;
11355 } else {
11356 G__setgvp((long) G__PVOID);
11357 ((TTRD1*) (soff))->~G__TTTRD1();
11358 G__setgvp((long)gvp);
11359 }
11360 }
11361 G__setnull(result7);
11362 return(1 || funcname || hash || result7 || libp) ;
11363 }
11364
11365
11366 static int G__G__G3D_179_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11367 {
11368 TTRD1* dest = (TTRD1*) G__getstructoffset();
11369 *dest = *(TTRD1*) libp->para[0].ref;
11370 const TTRD1& obj = *dest;
11371 result7->ref = (long) (&obj);
11372 result7->obj.i = (long) (&obj);
11373 return(1 || funcname || hash || result7 || libp) ;
11374 }
11375
11376
11377
11378 static int G__G__G3D_180_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11379 {
11380 TTRD2* p = NULL;
11381 char* gvp = (char*) G__getgvp();
11382 int n = G__getaryconstruct();
11383 if (n) {
11384 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11385 p = new TTRD2[n];
11386 } else {
11387 p = new((void*) gvp) TTRD2[n];
11388 }
11389 } else {
11390 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11391 p = new TTRD2;
11392 } else {
11393 p = new((void*) gvp) TTRD2;
11394 }
11395 }
11396 result7->obj.i = (long) p;
11397 result7->ref = (long) p;
11398 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRD2));
11399 return(1 || funcname || hash || result7 || libp) ;
11400 }
11401
11402 static int G__G__G3D_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11403 {
11404 TTRD2* p = NULL;
11405 char* gvp = (char*) G__getgvp();
11406
11407 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11408 p = new TTRD2(
11409 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11410 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
11411 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11412 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
11413 } else {
11414 p = new((void*) gvp) TTRD2(
11415 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11416 , (const char*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3])
11417 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11418 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
11419 }
11420 result7->obj.i = (long) p;
11421 result7->ref = (long) p;
11422 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRD2));
11423 return(1 || funcname || hash || result7 || libp) ;
11424 }
11425
11426 static int G__G__G3D_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11427 {
11428 G__letdouble(result7, 102, (double) ((const TTRD2*) G__getstructoffset())->GetDx2());
11429 return(1 || funcname || hash || result7 || libp) ;
11430 }
11431
11432 static int G__G__G3D_180_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11433 {
11434 G__letdouble(result7, 102, (double) ((const TTRD2*) G__getstructoffset())->GetDy2());
11435 return(1 || funcname || hash || result7 || libp) ;
11436 }
11437
11438 static int G__G__G3D_180_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11439 {
11440 G__letint(result7, 85, (long) TTRD2::Class());
11441 return(1 || funcname || hash || result7 || libp) ;
11442 }
11443
11444 static int G__G__G3D_180_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11445 {
11446 G__letint(result7, 67, (long) TTRD2::Class_Name());
11447 return(1 || funcname || hash || result7 || libp) ;
11448 }
11449
11450 static int G__G__G3D_180_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11451 {
11452 G__letint(result7, 115, (long) TTRD2::Class_Version());
11453 return(1 || funcname || hash || result7 || libp) ;
11454 }
11455
11456 static int G__G__G3D_180_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11457 {
11458 TTRD2::Dictionary();
11459 G__setnull(result7);
11460 return(1 || funcname || hash || result7 || libp) ;
11461 }
11462
11463 static int G__G__G3D_180_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11464 {
11465 ((TTRD2*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11466 G__setnull(result7);
11467 return(1 || funcname || hash || result7 || libp) ;
11468 }
11469
11470 static int G__G__G3D_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11471 {
11472 G__letint(result7, 67, (long) TTRD2::DeclFileName());
11473 return(1 || funcname || hash || result7 || libp) ;
11474 }
11475
11476 static int G__G__G3D_180_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11477 {
11478 G__letint(result7, 105, (long) TTRD2::ImplFileLine());
11479 return(1 || funcname || hash || result7 || libp) ;
11480 }
11481
11482 static int G__G__G3D_180_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11483 {
11484 G__letint(result7, 67, (long) TTRD2::ImplFileName());
11485 return(1 || funcname || hash || result7 || libp) ;
11486 }
11487
11488 static int G__G__G3D_180_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11489 {
11490 G__letint(result7, 105, (long) TTRD2::DeclFileLine());
11491 return(1 || funcname || hash || result7 || libp) ;
11492 }
11493
11494
11495 static int G__G__G3D_180_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11496
11497 {
11498 TTRD2* p;
11499 void* tmp = (void*) G__int(libp->para[0]);
11500 p = new TTRD2(*(TTRD2*) tmp);
11501 result7->obj.i = (long) p;
11502 result7->ref = (long) p;
11503 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TTRD2));
11504 return(1 || funcname || hash || result7 || libp) ;
11505 }
11506
11507
11508 typedef TTRD2 G__TTTRD2;
11509 static int G__G__G3D_180_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11510 {
11511 char* gvp = (char*) G__getgvp();
11512 long soff = G__getstructoffset();
11513 int n = G__getaryconstruct();
11514
11515
11516
11517
11518
11519 if (!soff) {
11520 return(1);
11521 }
11522 if (n) {
11523 if (gvp == (char*)G__PVOID) {
11524 delete[] (TTRD2*) soff;
11525 } else {
11526 G__setgvp((long) G__PVOID);
11527 for (int i = n - 1; i >= 0; --i) {
11528 ((TTRD2*) (soff+(sizeof(TTRD2)*i)))->~G__TTTRD2();
11529 }
11530 G__setgvp((long)gvp);
11531 }
11532 } else {
11533 if (gvp == (char*)G__PVOID) {
11534 delete (TTRD2*) soff;
11535 } else {
11536 G__setgvp((long) G__PVOID);
11537 ((TTRD2*) (soff))->~G__TTTRD2();
11538 G__setgvp((long)gvp);
11539 }
11540 }
11541 G__setnull(result7);
11542 return(1 || funcname || hash || result7 || libp) ;
11543 }
11544
11545
11546 static int G__G__G3D_180_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11547 {
11548 TTRD2* dest = (TTRD2*) G__getstructoffset();
11549 *dest = *(TTRD2*) libp->para[0].ref;
11550 const TTRD2& obj = *dest;
11551 result7->ref = (long) (&obj);
11552 result7->obj.i = (long) (&obj);
11553 return(1 || funcname || hash || result7 || libp) ;
11554 }
11555
11556
11557
11558 static int G__G__G3D_181_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11559 {
11560 TView3D* p = NULL;
11561 char* gvp = (char*) G__getgvp();
11562 int n = G__getaryconstruct();
11563 if (n) {
11564 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11565 p = new TView3D[n];
11566 } else {
11567 p = new((void*) gvp) TView3D[n];
11568 }
11569 } else {
11570 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11571 p = new TView3D;
11572 } else {
11573 p = new((void*) gvp) TView3D;
11574 }
11575 }
11576 result7->obj.i = (long) p;
11577 result7->ref = (long) p;
11578 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TView3D));
11579 return(1 || funcname || hash || result7 || libp) ;
11580 }
11581
11582 static int G__G__G3D_181_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11583 {
11584 TView3D* p = NULL;
11585 char* gvp = (char*) G__getgvp();
11586
11587 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11588 p = new TView3D(
11589 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
11590 , (Double_t*) G__int(libp->para[2]));
11591 } else {
11592 p = new((void*) gvp) TView3D(
11593 (Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
11594 , (Double_t*) G__int(libp->para[2]));
11595 }
11596 result7->obj.i = (long) p;
11597 result7->ref = (long) p;
11598 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TView3D));
11599 return(1 || funcname || hash || result7 || libp) ;
11600 }
11601
11602 static int G__G__G3D_181_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11603 {
11604 switch (libp->paran) {
11605 case 1:
11606 TView3D::AdjustPad((TVirtualPad*) G__int(libp->para[0]));
11607 G__setnull(result7);
11608 break;
11609 case 0:
11610 TView3D::AdjustPad();
11611 G__setnull(result7);
11612 break;
11613 }
11614 return(1 || funcname || hash || result7 || libp) ;
11615 }
11616
11617 static int G__G__G3D_181_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11618 {
11619 G__letint(result7, 85, (long) TView3D::Class());
11620 return(1 || funcname || hash || result7 || libp) ;
11621 }
11622
11623 static int G__G__G3D_181_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11624 {
11625 G__letint(result7, 67, (long) TView3D::Class_Name());
11626 return(1 || funcname || hash || result7 || libp) ;
11627 }
11628
11629 static int G__G__G3D_181_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11630 {
11631 G__letint(result7, 115, (long) TView3D::Class_Version());
11632 return(1 || funcname || hash || result7 || libp) ;
11633 }
11634
11635 static int G__G__G3D_181_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11636 {
11637 TView3D::Dictionary();
11638 G__setnull(result7);
11639 return(1 || funcname || hash || result7 || libp) ;
11640 }
11641
11642 static int G__G__G3D_181_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11643 {
11644 ((TView3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11645 G__setnull(result7);
11646 return(1 || funcname || hash || result7 || libp) ;
11647 }
11648
11649 static int G__G__G3D_181_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11650 {
11651 G__letint(result7, 67, (long) TView3D::DeclFileName());
11652 return(1 || funcname || hash || result7 || libp) ;
11653 }
11654
11655 static int G__G__G3D_181_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11656 {
11657 G__letint(result7, 105, (long) TView3D::ImplFileLine());
11658 return(1 || funcname || hash || result7 || libp) ;
11659 }
11660
11661 static int G__G__G3D_181_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11662 {
11663 G__letint(result7, 67, (long) TView3D::ImplFileName());
11664 return(1 || funcname || hash || result7 || libp) ;
11665 }
11666
11667 static int G__G__G3D_181_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11668 {
11669 G__letint(result7, 105, (long) TView3D::DeclFileLine());
11670 return(1 || funcname || hash || result7 || libp) ;
11671 }
11672
11673
11674 typedef TView3D G__TTView3D;
11675 static int G__G__G3D_181_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11676 {
11677 char* gvp = (char*) G__getgvp();
11678 long soff = G__getstructoffset();
11679 int n = G__getaryconstruct();
11680
11681
11682
11683
11684
11685 if (!soff) {
11686 return(1);
11687 }
11688 if (n) {
11689 if (gvp == (char*)G__PVOID) {
11690 delete[] (TView3D*) soff;
11691 } else {
11692 G__setgvp((long) G__PVOID);
11693 for (int i = n - 1; i >= 0; --i) {
11694 ((TView3D*) (soff+(sizeof(TView3D)*i)))->~G__TTView3D();
11695 }
11696 G__setgvp((long)gvp);
11697 }
11698 } else {
11699 if (gvp == (char*)G__PVOID) {
11700 delete (TView3D*) soff;
11701 } else {
11702 G__setgvp((long) G__PVOID);
11703 ((TView3D*) (soff))->~G__TTView3D();
11704 G__setgvp((long)gvp);
11705 }
11706 }
11707 G__setnull(result7);
11708 return(1 || funcname || hash || result7 || libp) ;
11709 }
11710
11711
11712
11713 static int G__G__G3D_183_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11714 {
11715 TXTRU* p = NULL;
11716 char* gvp = (char*) G__getgvp();
11717 int n = G__getaryconstruct();
11718 if (n) {
11719 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11720 p = new TXTRU[n];
11721 } else {
11722 p = new((void*) gvp) TXTRU[n];
11723 }
11724 } else {
11725 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11726 p = new TXTRU;
11727 } else {
11728 p = new((void*) gvp) TXTRU;
11729 }
11730 }
11731 result7->obj.i = (long) p;
11732 result7->ref = (long) p;
11733 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TXTRU));
11734 return(1 || funcname || hash || result7 || libp) ;
11735 }
11736
11737 static int G__G__G3D_183_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11738 {
11739 TXTRU* p = NULL;
11740 char* gvp = (char*) G__getgvp();
11741
11742 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11743 p = new TXTRU(
11744 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11745 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11746 , (Int_t) G__int(libp->para[4]));
11747 } else {
11748 p = new((void*) gvp) TXTRU(
11749 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11750 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
11751 , (Int_t) G__int(libp->para[4]));
11752 }
11753 result7->obj.i = (long) p;
11754 result7->ref = (long) p;
11755 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TXTRU));
11756 return(1 || funcname || hash || result7 || libp) ;
11757 }
11758
11759 static int G__G__G3D_183_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11760 {
11761 TXTRU* p = NULL;
11762 char* gvp = (char*) G__getgvp();
11763
11764 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11765 p = new TXTRU(*(TXTRU*) libp->para[0].ref);
11766 } else {
11767 p = new((void*) gvp) TXTRU(*(TXTRU*) libp->para[0].ref);
11768 }
11769 result7->obj.i = (long) p;
11770 result7->ref = (long) p;
11771 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__G3DLN_TXTRU));
11772 return(1 || funcname || hash || result7 || libp) ;
11773 }
11774
11775 static int G__G__G3D_183_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11776 {
11777 {
11778 const TXTRU& obj = ((TXTRU*) G__getstructoffset())->operator=(*(TXTRU*) libp->para[0].ref);
11779 result7->ref = (long) (&obj);
11780 result7->obj.i = (long) (&obj);
11781 }
11782 return(1 || funcname || hash || result7 || libp) ;
11783 }
11784
11785 static int G__G__G3D_183_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11786 {
11787 switch (libp->paran) {
11788 case 5:
11789 ((TXTRU*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
11790 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
11791 , (Float_t) G__double(libp->para[4]));
11792 G__setnull(result7);
11793 break;
11794 case 4:
11795 ((TXTRU*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
11796 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
11797 G__setnull(result7);
11798 break;
11799 case 3:
11800 ((TXTRU*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
11801 , (Float_t) G__double(libp->para[2]));
11802 G__setnull(result7);
11803 break;
11804 case 2:
11805 ((TXTRU*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
11806 G__setnull(result7);
11807 break;
11808 }
11809 return(1 || funcname || hash || result7 || libp) ;
11810 }
11811
11812 static int G__G__G3D_183_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11813 {
11814 ((TXTRU*) G__getstructoffset())->DefineVertex((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
11815 , (Float_t) G__double(libp->para[2]));
11816 G__setnull(result7);
11817 return(1 || funcname || hash || result7 || libp) ;
11818 }
11819
11820 static int G__G__G3D_183_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11821 {
11822 G__letint(result7, 105, (long) ((const TXTRU*) G__getstructoffset())->GetNxy());
11823 return(1 || funcname || hash || result7 || libp) ;
11824 }
11825
11826 static int G__G__G3D_183_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11827 {
11828 G__letint(result7, 105, (long) ((const TXTRU*) G__getstructoffset())->GetNz());
11829 return(1 || funcname || hash || result7 || libp) ;
11830 }
11831
11832 static int G__G__G3D_183_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11833 {
11834 G__letdouble(result7, 102, (double) ((const TXTRU*) G__getstructoffset())->GetOutlinePointX((Int_t) G__int(libp->para[0])));
11835 return(1 || funcname || hash || result7 || libp) ;
11836 }
11837
11838 static int G__G__G3D_183_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11839 {
11840 G__letdouble(result7, 102, (double) ((const TXTRU*) G__getstructoffset())->GetOutlinePointY((Int_t) G__int(libp->para[0])));
11841 return(1 || funcname || hash || result7 || libp) ;
11842 }
11843
11844 static int G__G__G3D_183_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11845 {
11846 G__letdouble(result7, 102, (double) ((const TXTRU*) G__getstructoffset())->GetSectionX0((Int_t) G__int(libp->para[0])));
11847 return(1 || funcname || hash || result7 || libp) ;
11848 }
11849
11850 static int G__G__G3D_183_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11851 {
11852 G__letdouble(result7, 102, (double) ((const TXTRU*) G__getstructoffset())->GetSectionY0((Int_t) G__int(libp->para[0])));
11853 return(1 || funcname || hash || result7 || libp) ;
11854 }
11855
11856 static int G__G__G3D_183_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11857 {
11858 G__letdouble(result7, 102, (double) ((const TXTRU*) G__getstructoffset())->GetSectionScale((Int_t) G__int(libp->para[0])));
11859 return(1 || funcname || hash || result7 || libp) ;
11860 }
11861
11862 static int G__G__G3D_183_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11863 {
11864 G__letdouble(result7, 102, (double) ((const TXTRU*) G__getstructoffset())->GetSectionZ((Int_t) G__int(libp->para[0])));
11865 return(1 || funcname || hash || result7 || libp) ;
11866 }
11867
11868 static int G__G__G3D_183_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11869 {
11870 G__letint(result7, 70, (long) ((const TXTRU*) G__getstructoffset())->GetXvtx());
11871 return(1 || funcname || hash || result7 || libp) ;
11872 }
11873
11874 static int G__G__G3D_183_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11875 {
11876 G__letint(result7, 70, (long) ((const TXTRU*) G__getstructoffset())->GetYvtx());
11877 return(1 || funcname || hash || result7 || libp) ;
11878 }
11879
11880 static int G__G__G3D_183_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11881 {
11882 G__letint(result7, 70, (long) ((const TXTRU*) G__getstructoffset())->GetZ());
11883 return(1 || funcname || hash || result7 || libp) ;
11884 }
11885
11886 static int G__G__G3D_183_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11887 {
11888 G__letint(result7, 70, (long) ((const TXTRU*) G__getstructoffset())->GetScale());
11889 return(1 || funcname || hash || result7 || libp) ;
11890 }
11891
11892 static int G__G__G3D_183_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11893 {
11894 G__letint(result7, 70, (long) ((const TXTRU*) G__getstructoffset())->GetX0());
11895 return(1 || funcname || hash || result7 || libp) ;
11896 }
11897
11898 static int G__G__G3D_183_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11899 {
11900 G__letint(result7, 70, (long) ((const TXTRU*) G__getstructoffset())->GetY0());
11901 return(1 || funcname || hash || result7 || libp) ;
11902 }
11903
11904 static int G__G__G3D_183_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11905 {
11906 switch (libp->paran) {
11907 case 1:
11908 ((TXTRU*) G__getstructoffset())->SplitConcavePolygon((Bool_t) G__int(libp->para[0]));
11909 G__setnull(result7);
11910 break;
11911 case 0:
11912 ((TXTRU*) G__getstructoffset())->SplitConcavePolygon();
11913 G__setnull(result7);
11914 break;
11915 }
11916 return(1 || funcname || hash || result7 || libp) ;
11917 }
11918
11919 static int G__G__G3D_183_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11920 {
11921 ((TXTRU*) G__getstructoffset())->TruncateNxy((Int_t) G__int(libp->para[0]));
11922 G__setnull(result7);
11923 return(1 || funcname || hash || result7 || libp) ;
11924 }
11925
11926 static int G__G__G3D_183_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11927 {
11928 ((TXTRU*) G__getstructoffset())->TruncateNz((Int_t) G__int(libp->para[0]));
11929 G__setnull(result7);
11930 return(1 || funcname || hash || result7 || libp) ;
11931 }
11932
11933 static int G__G__G3D_183_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11934 {
11935 G__letint(result7, 85, (long) TXTRU::Class());
11936 return(1 || funcname || hash || result7 || libp) ;
11937 }
11938
11939 static int G__G__G3D_183_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11940 {
11941 G__letint(result7, 67, (long) TXTRU::Class_Name());
11942 return(1 || funcname || hash || result7 || libp) ;
11943 }
11944
11945 static int G__G__G3D_183_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11946 {
11947 G__letint(result7, 115, (long) TXTRU::Class_Version());
11948 return(1 || funcname || hash || result7 || libp) ;
11949 }
11950
11951 static int G__G__G3D_183_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11952 {
11953 TXTRU::Dictionary();
11954 G__setnull(result7);
11955 return(1 || funcname || hash || result7 || libp) ;
11956 }
11957
11958 static int G__G__G3D_183_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11959 {
11960 ((TXTRU*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11961 G__setnull(result7);
11962 return(1 || funcname || hash || result7 || libp) ;
11963 }
11964
11965 static int G__G__G3D_183_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11966 {
11967 G__letint(result7, 67, (long) TXTRU::DeclFileName());
11968 return(1 || funcname || hash || result7 || libp) ;
11969 }
11970
11971 static int G__G__G3D_183_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11972 {
11973 G__letint(result7, 105, (long) TXTRU::ImplFileLine());
11974 return(1 || funcname || hash || result7 || libp) ;
11975 }
11976
11977 static int G__G__G3D_183_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11978 {
11979 G__letint(result7, 67, (long) TXTRU::ImplFileName());
11980 return(1 || funcname || hash || result7 || libp) ;
11981 }
11982
11983 static int G__G__G3D_183_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11984 {
11985 G__letint(result7, 105, (long) TXTRU::DeclFileLine());
11986 return(1 || funcname || hash || result7 || libp) ;
11987 }
11988
11989
11990 typedef TXTRU G__TTXTRU;
11991 static int G__G__G3D_183_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11992 {
11993 char* gvp = (char*) G__getgvp();
11994 long soff = G__getstructoffset();
11995 int n = G__getaryconstruct();
11996
11997
11998
11999
12000
12001 if (!soff) {
12002 return(1);
12003 }
12004 if (n) {
12005 if (gvp == (char*)G__PVOID) {
12006 delete[] (TXTRU*) soff;
12007 } else {
12008 G__setgvp((long) G__PVOID);
12009 for (int i = n - 1; i >= 0; --i) {
12010 ((TXTRU*) (soff+(sizeof(TXTRU)*i)))->~G__TTXTRU();
12011 }
12012 G__setgvp((long)gvp);
12013 }
12014 } else {
12015 if (gvp == (char*)G__PVOID) {
12016 delete (TXTRU*) soff;
12017 } else {
12018 G__setgvp((long) G__PVOID);
12019 ((TXTRU*) (soff))->~G__TTXTRU();
12020 G__setgvp((long)gvp);
12021 }
12022 }
12023 G__setnull(result7);
12024 return(1 || funcname || hash || result7 || libp) ;
12025 }
12026
12027
12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105 class G__Sizep2memfuncG__G3D {
12106 public:
12107 G__Sizep2memfuncG__G3D(): p(&G__Sizep2memfuncG__G3D::sizep2memfunc) {}
12108 size_t sizep2memfunc() { return(sizeof(p)); }
12109 private:
12110 size_t (G__Sizep2memfuncG__G3D::*p)();
12111 };
12112
12113 size_t G__get_sizep2memfuncG__G3D()
12114 {
12115 G__Sizep2memfuncG__G3D a;
12116 G__setsizep2memfunc((int)a.sizep2memfunc());
12117 return((size_t)a.sizep2memfunc());
12118 }
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130 extern "C" void G__cpp_setup_inheritanceG__G3D() {
12131
12132
12133 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TAxis3D))) {
12134 TAxis3D *G__Lderived;
12135 G__Lderived=(TAxis3D*)0x1000;
12136 {
12137 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12138 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TAxis3D),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12139 }
12140 {
12141 TObject *G__Lpbase=(TObject*)G__Lderived;
12142 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TAxis3D),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12143 }
12144 }
12145 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TMaterial))) {
12146 TMaterial *G__Lderived;
12147 G__Lderived=(TMaterial*)0x1000;
12148 {
12149 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12150 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMaterial),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12151 }
12152 {
12153 TObject *G__Lpbase=(TObject*)G__Lderived;
12154 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMaterial),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12155 }
12156 {
12157 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12158 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMaterial),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
12159 }
12160 }
12161 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TNode))) {
12162 TNode *G__Lderived;
12163 G__Lderived=(TNode*)0x1000;
12164 {
12165 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12166 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12167 }
12168 {
12169 TObject *G__Lpbase=(TObject*)G__Lderived;
12170 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12171 }
12172 {
12173 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12174 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
12175 }
12176 {
12177 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12178 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
12179 }
12180 {
12181 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12182 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12183 }
12184 }
12185 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TShape))) {
12186 TShape *G__Lderived;
12187 G__Lderived=(TShape*)0x1000;
12188 {
12189 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12190 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12191 }
12192 {
12193 TObject *G__Lpbase=(TObject*)G__Lderived;
12194 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12195 }
12196 {
12197 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12198 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
12199 }
12200 {
12201 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12202 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
12203 }
12204 {
12205 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12206 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12207 }
12208 }
12209 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TBRIK))) {
12210 TBRIK *G__Lderived;
12211 G__Lderived=(TBRIK*)0x1000;
12212 {
12213 TShape *G__Lpbase=(TShape*)G__Lderived;
12214 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,1);
12215 }
12216 {
12217 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12218 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12219 }
12220 {
12221 TObject *G__Lpbase=(TObject*)G__Lderived;
12222 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12223 }
12224 {
12225 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12226 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12227 }
12228 {
12229 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12230 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12231 }
12232 {
12233 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12234 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12235 }
12236 }
12237 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TTUBE))) {
12238 TTUBE *G__Lderived;
12239 G__Lderived=(TTUBE*)0x1000;
12240 {
12241 TShape *G__Lpbase=(TShape*)G__Lderived;
12242 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,1);
12243 }
12244 {
12245 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12246 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12247 }
12248 {
12249 TObject *G__Lpbase=(TObject*)G__Lderived;
12250 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12251 }
12252 {
12253 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12254 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12255 }
12256 {
12257 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12258 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12259 }
12260 {
12261 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12262 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12263 }
12264 }
12265 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TCONE))) {
12266 TCONE *G__Lderived;
12267 G__Lderived=(TCONE*)0x1000;
12268 {
12269 TTUBE *G__Lpbase=(TTUBE*)G__Lderived;
12270 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TTUBE),(long)G__Lpbase-(long)G__Lderived,1,1);
12271 }
12272 {
12273 TShape *G__Lpbase=(TShape*)G__Lderived;
12274 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12275 }
12276 {
12277 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12278 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12279 }
12280 {
12281 TObject *G__Lpbase=(TObject*)G__Lderived;
12282 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12283 }
12284 {
12285 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12286 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12287 }
12288 {
12289 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12290 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12291 }
12292 {
12293 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12294 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12295 }
12296 }
12297 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TTUBS))) {
12298 TTUBS *G__Lderived;
12299 G__Lderived=(TTUBS*)0x1000;
12300 {
12301 TTUBE *G__Lpbase=(TTUBE*)G__Lderived;
12302 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TTUBE),(long)G__Lpbase-(long)G__Lderived,1,1);
12303 }
12304 {
12305 TShape *G__Lpbase=(TShape*)G__Lderived;
12306 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12307 }
12308 {
12309 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12310 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12311 }
12312 {
12313 TObject *G__Lpbase=(TObject*)G__Lderived;
12314 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12315 }
12316 {
12317 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12318 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12319 }
12320 {
12321 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12322 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12323 }
12324 {
12325 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12326 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12327 }
12328 }
12329 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TCONS))) {
12330 TCONS *G__Lderived;
12331 G__Lderived=(TCONS*)0x1000;
12332 {
12333 TTUBS *G__Lpbase=(TTUBS*)G__Lderived;
12334 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TTUBS),(long)G__Lpbase-(long)G__Lderived,1,1);
12335 }
12336 {
12337 TTUBE *G__Lpbase=(TTUBE*)G__Lderived;
12338 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TTUBE),(long)G__Lpbase-(long)G__Lderived,1,0);
12339 }
12340 {
12341 TShape *G__Lpbase=(TShape*)G__Lderived;
12342 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12343 }
12344 {
12345 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12346 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12347 }
12348 {
12349 TObject *G__Lpbase=(TObject*)G__Lderived;
12350 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12351 }
12352 {
12353 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12354 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12355 }
12356 {
12357 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12358 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12359 }
12360 {
12361 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12362 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12363 }
12364 }
12365 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TCTUB))) {
12366 TCTUB *G__Lderived;
12367 G__Lderived=(TCTUB*)0x1000;
12368 {
12369 TTUBS *G__Lpbase=(TTUBS*)G__Lderived;
12370 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TTUBS),(long)G__Lpbase-(long)G__Lderived,1,1);
12371 }
12372 {
12373 TTUBE *G__Lpbase=(TTUBE*)G__Lderived;
12374 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TTUBE),(long)G__Lpbase-(long)G__Lderived,1,0);
12375 }
12376 {
12377 TShape *G__Lpbase=(TShape*)G__Lderived;
12378 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12379 }
12380 {
12381 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12382 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12383 }
12384 {
12385 TObject *G__Lpbase=(TObject*)G__Lderived;
12386 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12387 }
12388 {
12389 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12390 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12391 }
12392 {
12393 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12394 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12395 }
12396 {
12397 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12398 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12399 }
12400 }
12401 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TELTU))) {
12402 TELTU *G__Lderived;
12403 G__Lderived=(TELTU*)0x1000;
12404 {
12405 TTUBE *G__Lpbase=(TTUBE*)G__Lderived;
12406 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TTUBE),(long)G__Lpbase-(long)G__Lderived,1,1);
12407 }
12408 {
12409 TShape *G__Lpbase=(TShape*)G__Lderived;
12410 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12411 }
12412 {
12413 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12414 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12415 }
12416 {
12417 TObject *G__Lpbase=(TObject*)G__Lderived;
12418 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12419 }
12420 {
12421 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12422 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12423 }
12424 {
12425 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12426 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12427 }
12428 {
12429 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12430 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12431 }
12432 }
12433 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix))) {
12434 TRotMatrix *G__Lderived;
12435 G__Lderived=(TRotMatrix*)0x1000;
12436 {
12437 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12438 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12439 }
12440 {
12441 TObject *G__Lpbase=(TObject*)G__Lderived;
12442 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12443 }
12444 }
12445 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TGeometry))) {
12446 TGeometry *G__Lderived;
12447 G__Lderived=(TGeometry*)0x1000;
12448 {
12449 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12450 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGeometry),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
12451 }
12452 {
12453 TObject *G__Lpbase=(TObject*)G__Lderived;
12454 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGeometry),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12455 }
12456 }
12457 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TGTRA))) {
12458 TGTRA *G__Lderived;
12459 G__Lderived=(TGTRA*)0x1000;
12460 {
12461 TBRIK *G__Lpbase=(TBRIK*)G__Lderived;
12462 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TBRIK),(long)G__Lpbase-(long)G__Lderived,1,1);
12463 }
12464 {
12465 TShape *G__Lpbase=(TShape*)G__Lderived;
12466 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12467 }
12468 {
12469 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12470 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12471 }
12472 {
12473 TObject *G__Lpbase=(TObject*)G__Lderived;
12474 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12475 }
12476 {
12477 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12478 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12479 }
12480 {
12481 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12482 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12483 }
12484 {
12485 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12486 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12487 }
12488 }
12489 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D))) {
12490 TPolyLine3D *G__Lderived;
12491 G__Lderived=(TPolyLine3D*)0x1000;
12492 {
12493 TObject *G__Lpbase=(TObject*)G__Lderived;
12494 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12495 }
12496 {
12497 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12498 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
12499 }
12500 {
12501 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12502 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12503 }
12504 }
12505 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_THelix))) {
12506 THelix *G__Lderived;
12507 G__Lderived=(THelix*)0x1000;
12508 {
12509 TPolyLine3D *G__Lpbase=(TPolyLine3D*)G__Lderived;
12510 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THelix),G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12511 }
12512 {
12513 TObject *G__Lpbase=(TObject*)G__Lderived;
12514 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THelix),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12515 }
12516 {
12517 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12518 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THelix),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12519 }
12520 {
12521 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12522 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THelix),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12523 }
12524 }
12525 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_THYPE))) {
12526 THYPE *G__Lderived;
12527 G__Lderived=(THYPE*)0x1000;
12528 {
12529 TTUBE *G__Lpbase=(TTUBE*)G__Lderived;
12530 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TTUBE),(long)G__Lpbase-(long)G__Lderived,1,1);
12531 }
12532 {
12533 TShape *G__Lpbase=(TShape*)G__Lderived;
12534 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12535 }
12536 {
12537 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12538 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12539 }
12540 {
12541 TObject *G__Lpbase=(TObject*)G__Lderived;
12542 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12543 }
12544 {
12545 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12546 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12547 }
12548 {
12549 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12550 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12551 }
12552 {
12553 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12554 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12555 }
12556 }
12557 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox))) {
12558 TMarker3DBox *G__Lderived;
12559 G__Lderived=(TMarker3DBox*)0x1000;
12560 {
12561 TObject *G__Lpbase=(TObject*)G__Lderived;
12562 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12563 }
12564 {
12565 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12566 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
12567 }
12568 {
12569 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12570 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
12571 }
12572 {
12573 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12574 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12575 }
12576 }
12577 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TMixture))) {
12578 TMixture *G__Lderived;
12579 G__Lderived=(TMixture*)0x1000;
12580 {
12581 TMaterial *G__Lpbase=(TMaterial*)G__Lderived;
12582 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMixture),G__get_linked_tagnum(&G__G__G3DLN_TMaterial),(long)G__Lpbase-(long)G__Lderived,1,1);
12583 }
12584 {
12585 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12586 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMixture),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12587 }
12588 {
12589 TObject *G__Lpbase=(TObject*)G__Lderived;
12590 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMixture),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12591 }
12592 {
12593 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12594 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TMixture),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12595 }
12596 }
12597 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv))) {
12598 TNodeDiv *G__Lderived;
12599 G__Lderived=(TNodeDiv*)0x1000;
12600 {
12601 TNode *G__Lpbase=(TNode*)G__Lderived;
12602 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv),G__get_linked_tagnum(&G__G__G3DLN_TNode),(long)G__Lpbase-(long)G__Lderived,1,1);
12603 }
12604 {
12605 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12606 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12607 }
12608 {
12609 TObject *G__Lpbase=(TObject*)G__Lderived;
12610 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12611 }
12612 {
12613 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12614 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12615 }
12616 {
12617 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12618 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12619 }
12620 {
12621 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12622 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12623 }
12624 }
12625 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPARA))) {
12626 TPARA *G__Lderived;
12627 G__Lderived=(TPARA*)0x1000;
12628 {
12629 TBRIK *G__Lpbase=(TBRIK*)G__Lderived;
12630 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TBRIK),(long)G__Lpbase-(long)G__Lderived,1,1);
12631 }
12632 {
12633 TShape *G__Lpbase=(TShape*)G__Lderived;
12634 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12635 }
12636 {
12637 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12638 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12639 }
12640 {
12641 TObject *G__Lpbase=(TObject*)G__Lderived;
12642 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12643 }
12644 {
12645 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12646 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12647 }
12648 {
12649 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12650 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12651 }
12652 {
12653 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12654 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12655 }
12656 }
12657 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPCON))) {
12658 TPCON *G__Lderived;
12659 G__Lderived=(TPCON*)0x1000;
12660 {
12661 TShape *G__Lpbase=(TShape*)G__Lderived;
12662 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,1);
12663 }
12664 {
12665 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12666 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12667 }
12668 {
12669 TObject *G__Lpbase=(TObject*)G__Lderived;
12670 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12671 }
12672 {
12673 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12674 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12675 }
12676 {
12677 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12678 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12679 }
12680 {
12681 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12682 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12683 }
12684 }
12685 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPGON))) {
12686 TPGON *G__Lderived;
12687 G__Lderived=(TPGON*)0x1000;
12688 {
12689 TPCON *G__Lpbase=(TPCON*)G__Lderived;
12690 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TPCON),(long)G__Lpbase-(long)G__Lderived,1,1);
12691 }
12692 {
12693 TShape *G__Lpbase=(TShape*)G__Lderived;
12694 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12695 }
12696 {
12697 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12698 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12699 }
12700 {
12701 TObject *G__Lpbase=(TObject*)G__Lderived;
12702 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12703 }
12704 {
12705 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12706 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12707 }
12708 {
12709 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12710 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12711 }
12712 {
12713 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12714 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12715 }
12716 }
12717 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPoints3DABC))) {
12718 TPoints3DABC *G__Lderived;
12719 G__Lderived=(TPoints3DABC*)0x1000;
12720 {
12721 TObject *G__Lpbase=(TObject*)G__Lderived;
12722 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPoints3DABC),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12723 }
12724 }
12725 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D))) {
12726 TPolyMarker3D *G__Lderived;
12727 G__Lderived=(TPolyMarker3D*)0x1000;
12728 {
12729 TObject *G__Lpbase=(TObject*)G__Lderived;
12730 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12731 }
12732 {
12733 TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
12734 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D),G__get_linked_tagnum(&G__G__G3DLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
12735 }
12736 {
12737 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12738 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12739 }
12740 }
12741 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D))) {
12742 TPointSet3D *G__Lderived;
12743 G__Lderived=(TPointSet3D*)0x1000;
12744 {
12745 TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
12746 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D),G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,1);
12747 }
12748 {
12749 TObject *G__Lpbase=(TObject*)G__Lderived;
12750 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12751 }
12752 {
12753 TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
12754 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D),G__get_linked_tagnum(&G__G__G3DLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
12755 }
12756 {
12757 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12758 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12759 }
12760 {
12761 TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
12762 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D),G__get_linked_tagnum(&G__G__G3DLN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
12763 }
12764 }
12765 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TSPHE))) {
12766 TSPHE *G__Lderived;
12767 G__Lderived=(TSPHE*)0x1000;
12768 {
12769 TShape *G__Lpbase=(TShape*)G__Lderived;
12770 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,1);
12771 }
12772 {
12773 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12774 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12775 }
12776 {
12777 TObject *G__Lpbase=(TObject*)G__Lderived;
12778 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12779 }
12780 {
12781 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12782 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12783 }
12784 {
12785 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12786 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12787 }
12788 {
12789 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12790 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12791 }
12792 }
12793 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TTRAP))) {
12794 TTRAP *G__Lderived;
12795 G__Lderived=(TTRAP*)0x1000;
12796 {
12797 TBRIK *G__Lpbase=(TBRIK*)G__Lderived;
12798 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TBRIK),(long)G__Lpbase-(long)G__Lderived,1,1);
12799 }
12800 {
12801 TShape *G__Lpbase=(TShape*)G__Lderived;
12802 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12803 }
12804 {
12805 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12806 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12807 }
12808 {
12809 TObject *G__Lpbase=(TObject*)G__Lderived;
12810 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12811 }
12812 {
12813 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12814 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12815 }
12816 {
12817 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12818 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12819 }
12820 {
12821 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12822 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12823 }
12824 }
12825 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TTRD1))) {
12826 TTRD1 *G__Lderived;
12827 G__Lderived=(TTRD1*)0x1000;
12828 {
12829 TBRIK *G__Lpbase=(TBRIK*)G__Lderived;
12830 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TBRIK),(long)G__Lpbase-(long)G__Lderived,1,1);
12831 }
12832 {
12833 TShape *G__Lpbase=(TShape*)G__Lderived;
12834 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12835 }
12836 {
12837 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12838 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12839 }
12840 {
12841 TObject *G__Lpbase=(TObject*)G__Lderived;
12842 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12843 }
12844 {
12845 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12846 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12847 }
12848 {
12849 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12850 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12851 }
12852 {
12853 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12854 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12855 }
12856 }
12857 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TTRD2))) {
12858 TTRD2 *G__Lderived;
12859 G__Lderived=(TTRD2*)0x1000;
12860 {
12861 TBRIK *G__Lpbase=(TBRIK*)G__Lderived;
12862 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TBRIK),(long)G__Lpbase-(long)G__Lderived,1,1);
12863 }
12864 {
12865 TShape *G__Lpbase=(TShape*)G__Lderived;
12866 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,0);
12867 }
12868 {
12869 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12870 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12871 }
12872 {
12873 TObject *G__Lpbase=(TObject*)G__Lderived;
12874 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12875 }
12876 {
12877 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12878 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12879 }
12880 {
12881 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12882 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12883 }
12884 {
12885 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12886 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12887 }
12888 }
12889 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TView3D))) {
12890 TView3D *G__Lderived;
12891 G__Lderived=(TView3D*)0x1000;
12892 {
12893 TView *G__Lpbase=(TView*)G__Lderived;
12894 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TView3D),G__get_linked_tagnum(&G__G__G3DLN_TView),(long)G__Lpbase-(long)G__Lderived,1,1);
12895 }
12896 {
12897 TObject *G__Lpbase=(TObject*)G__Lderived;
12898 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TView3D),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12899 }
12900 {
12901 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12902 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TView3D),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12903 }
12904 }
12905 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__G3DLN_TXTRU))) {
12906 TXTRU *G__Lderived;
12907 G__Lderived=(TXTRU*)0x1000;
12908 {
12909 TShape *G__Lpbase=(TShape*)G__Lderived;
12910 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU),G__get_linked_tagnum(&G__G__G3DLN_TShape),(long)G__Lpbase-(long)G__Lderived,1,1);
12911 }
12912 {
12913 TNamed *G__Lpbase=(TNamed*)G__Lderived;
12914 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU),G__get_linked_tagnum(&G__G__G3DLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
12915 }
12916 {
12917 TObject *G__Lpbase=(TObject*)G__Lderived;
12918 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU),G__get_linked_tagnum(&G__G__G3DLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12919 }
12920 {
12921 TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
12922 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU),G__get_linked_tagnum(&G__G__G3DLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
12923 }
12924 {
12925 TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
12926 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU),G__get_linked_tagnum(&G__G__G3DLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
12927 }
12928 {
12929 TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
12930 G__inheritance_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU),G__get_linked_tagnum(&G__G__G3DLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
12931 }
12932 }
12933 }
12934
12935
12936
12937
12938 extern "C" void G__cpp_setup_typetableG__G3D() {
12939
12940
12941 G__search_typename2("Int_t",105,-1,0,-1);
12942 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
12943 G__search_typename2("UInt_t",104,-1,0,-1);
12944 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
12945 G__search_typename2("Float_t",102,-1,0,-1);
12946 G__setnewtype(-1,"Float 4 bytes (float)",0);
12947 G__search_typename2("Double_t",100,-1,0,-1);
12948 G__setnewtype(-1,"Double 8 bytes",0);
12949 G__search_typename2("Bool_t",103,-1,0,-1);
12950 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
12951 G__search_typename2("Version_t",115,-1,0,-1);
12952 G__setnewtype(-1,"Class version identifier (short)",0);
12953 G__search_typename2("Option_t",99,-1,256,-1);
12954 G__setnewtype(-1,"Option string (const char)",0);
12955 G__search_typename2("Axis_t",100,-1,0,-1);
12956 G__setnewtype(-1,"Axis values type (double)",0);
12957 G__search_typename2("Style_t",115,-1,0,-1);
12958 G__setnewtype(-1,"Style number (short)",0);
12959 G__search_typename2("Marker_t",115,-1,0,-1);
12960 G__setnewtype(-1,"Marker number (short)",0);
12961 G__search_typename2("Color_t",115,-1,0,-1);
12962 G__setnewtype(-1,"Color number (short)",0);
12963 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__G3DLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
12964 G__setnewtype(-1,NULL,0);
12965 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__G3DLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__G3DLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
12966 G__setnewtype(-1,NULL,0);
12967 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__G3DLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__G3DLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
12968 G__setnewtype(-1,NULL,0);
12969 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__G3DLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
12970 G__setnewtype(-1,NULL,0);
12971 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__G3DLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__G3DLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
12972 G__setnewtype(-1,NULL,0);
12973 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__G3DLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__G3DLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
12974 G__setnewtype(-1,NULL,0);
12975 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12976 G__setnewtype(-1,NULL,0);
12977 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12978 G__setnewtype(-1,NULL,0);
12979 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12980 G__setnewtype(-1,NULL,0);
12981 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
12982 G__setnewtype(-1,NULL,0);
12983 }
12984
12985
12986
12987
12988
12989
12990
12991
12992 static void G__setup_memvarTAxis3D(void) {
12993 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TAxis3D));
12994 { TAxis3D *p; p=(TAxis3D*)0x1000; if (p) { }
12995 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TAxis),-1,-1,2,"fAxis[3]=",0,"X/Y/Z axis");
12996 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TString),-1,-1,2,"fOption=",0,"Options (is not use yet)");
12997 G__memvar_setup((void*)0,67,0,1,-1,-1,-2,2,"fgRulerName=",0,"The default object name");
12998 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TAxis),-1,-1,2,"fSelected=",0,"! The selected axis to play with");
12999 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fZoomMode=",0,"Zoom mode for the entire parent TPad");
13000 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStickyZoom=",0,"StickyZoom mode: zoom will not be disabled after zooming attempt if true");
13001 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13002 }
13003 G__tag_memvar_reset();
13004 }
13005
13006
13007
13008 static void G__setup_memvarTMaterial(void) {
13009 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TMaterial));
13010 { TMaterial *p; p=(TMaterial*)0x1000; if (p) { }
13011 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"Material matrix number");
13012 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fA=",0,"A of Material");
13013 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fZ=",0,"Z of Material");
13014 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDensity=",0,"Material density in gr/cm3");
13015 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRadLength=",0,"Material radiation length");
13016 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fInterLength=",0,"Material interaction length");
13017 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13018 }
13019 G__tag_memvar_reset();
13020 }
13021
13022
13023
13024 static void G__setup_memvarTNode(void) {
13025 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode));
13026 { TNode *p; p=(TNode*)0x1000; if (p) { }
13027 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TNodecLcLdA),-1,-2,2,"kSonsInvisible=131072LL",0,(char*)NULL);
13028 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"X offset with respect to parent object");
13029 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"Y offset with respect to parent object");
13030 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"Z offset with respect to parent object");
13031 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix),-1,-1,2,"fMatrix=",0,"Pointer to rotation matrix");
13032 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TShape),-1,-1,2,"fShape=",0,"Pointer to shape definition");
13033 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TNode),-1,-1,2,"fParent=",0,"Pointer to parent positioned volume");
13034 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TList),-1,-1,2,"fNodes=",0,"List of son nodes (if any)");
13035 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TString),-1,-1,2,"fOption=",0,"List of options if any");
13036 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVisibility=",0,"Visibility flag");
13037 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13038 }
13039 G__tag_memvar_reset();
13040 }
13041
13042
13043
13044 static void G__setup_memvarTShape(void) {
13045 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape));
13046 { TShape *p; p=(TShape*)0x1000; if (p) { }
13047 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"Shape number");
13048 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVisibility=",0,"Visibility flag");
13049 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TMaterial),-1,-1,2,"fMaterial=",0,"Pointer to material");
13050 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13051 }
13052 G__tag_memvar_reset();
13053 }
13054
13055
13056
13057 static void G__setup_memvarTBRIK(void) {
13058 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK));
13059 { TBRIK *p; p=(TBRIK*)0x1000; if (p) { }
13060 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDx=",0,"half length in x");
13061 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDy=",0,"half length in y");
13062 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDz=",0,"half length in z");
13063 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13064 }
13065 G__tag_memvar_reset();
13066 }
13067
13068
13069
13070 static void G__setup_memvarTTUBE(void) {
13071 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE));
13072 { TTUBE *p; p=(TTUBE*)0x1000; if (p) { }
13073 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmin=",0,"ellipse semi-axis in X inside");
13074 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmax=",0,"ellipse semi-axis in X outside");
13075 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDz=",0,"half length in z");
13076 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiv=",0,"number of segments (precision)");
13077 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAspectRatio=",0,"defines (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)");
13078 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSiTab=",0,"! Table of sin(fPhi1) .... sin(fPhil+fDphi1)");
13079 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCoTab=",0,"! Table of cos(fPhi1) .... cos(fPhil+fDphi1)");
13080 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13081 }
13082 G__tag_memvar_reset();
13083 }
13084
13085
13086
13087 static void G__setup_memvarTCONE(void) {
13088 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE));
13089 { TCONE *p; p=(TCONE*)0x1000; if (p) { }
13090 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmin2=",0,"inside radius at the high z limit");
13091 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmax2=",0,"outside radius at the high z limit");
13092 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13093 }
13094 G__tag_memvar_reset();
13095 }
13096
13097
13098
13099 static void G__setup_memvarTTUBS(void) {
13100 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS));
13101 { TTUBS *p; p=(TTUBS*)0x1000; if (p) { }
13102 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi1=",0,"first phi limit");
13103 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi2=",0,"second phi limit");
13104 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13105 }
13106 G__tag_memvar_reset();
13107 }
13108
13109
13110
13111 static void G__setup_memvarTCONS(void) {
13112 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS));
13113 { TCONS *p; p=(TCONS*)0x1000; if (p) { }
13114 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmin2=",0,"inside radius at the high z limit");
13115 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmax2=",0,"outside radius at the high z limit");
13116 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13117 }
13118 G__tag_memvar_reset();
13119 }
13120
13121
13122
13123 static void G__setup_memvarTCTUB(void) {
13124 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB));
13125 { TCTUB *p; p=(TCTUB*)0x1000; if (p) { }
13126 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fCosLow[3]=",0,"dir cosinus of surface cutting tube at low z");
13127 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fCosHigh[3]=",0,"dir cosinus of surface cutting tube at high z");
13128 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13129 }
13130 G__tag_memvar_reset();
13131 }
13132
13133
13134
13135 static void G__setup_memvarTELTU(void) {
13136 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU));
13137 { TELTU *p; p=(TELTU*)0x1000; if (p) { }
13138 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13139 }
13140 G__tag_memvar_reset();
13141 }
13142
13143
13144
13145 static void G__setup_memvarTRotMatrix(void) {
13146 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
13147 { TRotMatrix *p; p=(TRotMatrix*)0x1000; if (p) { }
13148 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"Rotation matrix number");
13149 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"Type of matrix (0=identity, 1=reflexion, 2=otherwise)");
13150 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta=",0,"theta angle");
13151 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi=",0,"phi angle");
13152 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsi=",0,"psi angle");
13153 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMatrix[9]=",0,"Rotation matrix");
13154 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrixcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kReflection=%lldLL",(long long)TRotMatrix::kReflection).data(),0,(char*)NULL);
13155 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13156 }
13157 G__tag_memvar_reset();
13158 }
13159
13160
13161
13162 static void G__setup_memvarTGeometry(void) {
13163 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TGeometry));
13164 { TGeometry *p; p=(TGeometry*)0x1000; if (p) { }
13165 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_THashList),-1,-1,4,"fMaterials=",0,"->Collection of materials");
13166 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_THashList),-1,-1,4,"fMatrices=",0,"->Collection of rotation matrices");
13167 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_THashList),-1,-1,4,"fShapes=",0,"->Collection of shapes");
13168 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TList),-1,-1,4,"fNodes=",0,"->Collection of nodes");
13169 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix),-1,-1,4,"fMatrix=",0,"!Pointers to current rotation matrices");
13170 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TNode),-1,-1,4,"fCurrentNode=",0,"!Pointer to current node");
13171 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__G3DLN_TMaterial),-1,-1,4,"fMaterialPointer=",0,"!Pointers to materials");
13172 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix),-1,-1,4,"fMatrixPointer=",0,"!Pointers to rotation matrices");
13173 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__G3DLN_TShape),-1,-1,4,"fShapePointer=",0,"!Pointers to shapes");
13174 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBomb=",0,"Bomb factor for exploded geometry");
13175 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGeomLevel=",0,"!");
13176 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fX=",0,"!");
13177 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fY=",0,"! The global translation of the current node");
13178 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fZ=",0,"!");
13179 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTranslation[20][3]=",0,"!");
13180 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRotMatrix[20][9]=",0,"!");
13181 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsReflection[20]=",0,"!");
13182 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13183 }
13184 G__tag_memvar_reset();
13185 }
13186
13187
13188
13189 static void G__setup_memvarTGTRA(void) {
13190 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA));
13191 { TGTRA *p; p=(TGTRA*)0x1000; if (p) { }
13192 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTwist=",0,"twisting parameter");
13193 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fH1=",0,"half length in y at low z");
13194 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBl1=",0,"half length in x at low z and y low edge");
13195 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTl1=",0,"half length in x at low z and y high edge");
13196 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAlpha1=",0,"angle w.r.t. the y axis");
13197 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fH2=",0,"half length in y at high z");
13198 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBl2=",0,"half length in x at high z and y low edge");
13199 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTl2=",0,"half length in x at high z and y high edge");
13200 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAlpha2=",0,"angle w.r.t. the y axis");
13201 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13202 }
13203 G__tag_memvar_reset();
13204 }
13205
13206
13207
13208 static void G__setup_memvarTPolyLine3D(void) {
13209 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
13210 { TPolyLine3D *p; p=(TPolyLine3D*)0x1000; if (p) { }
13211 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"Number of points");
13212 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fP=",0,"[3*fN] Array of 3-D coordinates (x,y,z)");
13213 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TString),-1,-1,2,"fOption=",0,"options");
13214 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastPoint=",0,"The index of the last filled point");
13215 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13216 }
13217 G__tag_memvar_reset();
13218 }
13219
13220
13221
13222 static void G__setup_memvarTHelix(void) {
13223 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_THelix));
13224 { THelix *p; p=(THelix*)0x1000; if (p) { }
13225 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX0=",0,"Pivot's x position (see parametrization in class doc)");
13226 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY0=",0,"Pivot's y position (see parametrization in class doc)");
13227 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ0=",0,"Pivot's z position (see parametrization in class doc)");
13228 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVt=",0,"Transverse velocity (constant of motion)");
13229 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi0=",0,"Initial phase, so vx0 = fVt*cos(fPhi0)");
13230 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVz=",0,"Z velocity (constant of motion)");
13231 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fW=",0,"Angular frequency");
13232 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAxis[3]=",0,"Direction unit vector of the helix axis");
13233 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix),-1,-1,2,"fRotMat=",0,"Rotation matrix: axis // z --> axis // fAxis");
13234 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRange[2]=",0,"Range of helix parameter t");
13235 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgMinNSeg=",0,"minimal number of segments in polyline");
13236 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13237 }
13238 G__tag_memvar_reset();
13239 }
13240
13241
13242
13243 static void G__setup_memvarTHYPE(void) {
13244 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE));
13245 { THYPE *p; p=(THYPE*)0x1000; if (p) { }
13246 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi=",0,"stereo angle");
13247 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13248 }
13249 G__tag_memvar_reset();
13250 }
13251
13252
13253
13254 static void G__setup_memvarTMarker3DBox(void) {
13255 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox));
13256 { TMarker3DBox *p; p=(TMarker3DBox*)0x1000; if (p) { }
13257 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fX=",0,"X coordinate of center of box");
13258 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fY=",0,"Y coordinate of center of box");
13259 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fZ=",0,"Z coordinate of center of box");
13260 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDx=",0,"half length in x");
13261 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDy=",0,"half length in y");
13262 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDz=",0,"half length in z");
13263 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTheta=",0,"Angle of box z axis with respect to main Z axis");
13264 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi=",0,"Angle of box x axis with respect to main Xaxis");
13265 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TObject),-1,-1,2,"fRefObject=",0,"Pointer to an object");
13266 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBoxcLcLdA),-1,-2,2,"kTemporary=8388608LL",0,(char*)NULL);
13267 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13268 }
13269 G__tag_memvar_reset();
13270 }
13271
13272
13273
13274 static void G__setup_memvarTMixture(void) {
13275 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TMixture));
13276 { TMixture *p; p=(TMixture*)0x1000; if (p) { }
13277 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNmixt=",0,"Number of elements in mixture");
13278 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAmixt=",0,"[fNmixt] Array of A of mixtures");
13279 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fZmixt=",0,"[fNmixt] Array of Z of mixtures");
13280 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fWmixt=",0,"[fNmixt] Array of relative weights");
13281 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13282 }
13283 G__tag_memvar_reset();
13284 }
13285
13286
13287
13288 static void G__setup_memvarTNodeDiv(void) {
13289 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv));
13290 { TNodeDiv *p; p=(TNodeDiv*)0x1000; if (p) { }
13291 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiv=",0,"Number of divisions");
13292 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fAxis=",0,"Axis number where object is divided");
13293 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13294 }
13295 G__tag_memvar_reset();
13296 }
13297
13298
13299
13300 static void G__setup_memvarTPARA(void) {
13301 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA));
13302 { TPARA *p; p=(TPARA*)0x1000; if (p) { }
13303 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAlpha=",0,"angle w.r.t. the y axis from the centre of the low y to the high y");
13304 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTheta=",0,"polar angle from the centre of the low z to the high z");
13305 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi=",0,"polar angle from the centre of the low z to the high z");
13306 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13307 }
13308 G__tag_memvar_reset();
13309 }
13310
13311
13312
13313 static void G__setup_memvarTPCON(void) {
13314 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON));
13315 { TPCON *p; p=(TPCON*)0x1000; if (p) { }
13316 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSiTab=",0,"! Table of sin(fPhi1) .... sin(fPhil+fDphi1)");
13317 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCoTab=",0,"! Table of cos(fPhi1) .... cos(fPhil+fDphi1)");
13318 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi1=",0,"lower phi limit");
13319 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDphi1=",0,"range in phi");
13320 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiv=",0,"number of divisions");
13321 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z segments");
13322 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmin=",0,"[fNz] pointer to array of inside radiuses");
13323 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmax=",0,"[fNz] pointer to array of outside radiuses");
13324 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDz=",0,"[fNz] pointer to array of half lengths in z");
13325 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13326 }
13327 G__tag_memvar_reset();
13328 }
13329
13330
13331
13332 static void G__setup_memvarTPGON(void) {
13333 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON));
13334 { TPGON *p; p=(TPGON*)0x1000; if (p) { }
13335 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13336 }
13337 G__tag_memvar_reset();
13338 }
13339
13340
13341
13342 static void G__setup_memvarTPoints3DABC(void) {
13343 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPoints3DABC));
13344 { TPoints3DABC *p; p=(TPoints3DABC*)0x1000; if (p) { }
13345 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13346 }
13347 G__tag_memvar_reset();
13348 }
13349
13350
13351
13352 static void G__setup_memvarTPolyMarker3D(void) {
13353 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
13354 { TPolyMarker3D *p; p=(TPolyMarker3D*)0x1000; if (p) { }
13355 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"number of points");
13356 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fP=",0,"[3*fN] Array of X,Y,Z coordinates");
13357 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TString),-1,-1,2,"fOption=",0,"options");
13358 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastPoint=",0,"The index of the last filled point");
13359 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TString),-1,-1,2,"fName=",0,"name of polymarker");
13360 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13361 }
13362 G__tag_memvar_reset();
13363 }
13364
13365
13366
13367 static void G__setup_memvarTPointSet3D(void) {
13368 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
13369 { TPointSet3D *p; p=(TPointSet3D*)0x1000; if (p) { }
13370 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnIds=",0,"Flag specifying id-objects are owned by the point-set");
13371 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__G3DLN_TRefArray),-1,-1,2,"fIds=",0,"User-provided point identifications");
13372 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13373 }
13374 G__tag_memvar_reset();
13375 }
13376
13377
13378
13379 static void G__setup_memvarTSPHE(void) {
13380 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE));
13381 { TSPHE *p; p=(TSPHE*)0x1000; if (p) { }
13382 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSiTab=",0,"! Table of sin(fPhimin) .... sin(Phi)");
13383 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoTab=",0,"! Table of cos(fPhimin) .... cos(Phi)");
13384 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoThetaTab=",0,"! Table of sin(gThemin) .... cos(Theta)");
13385 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdiv=",0,"number of divisions");
13386 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNz=",0,"! number of sections");
13387 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAspectRatio=",0,"Relation between asumth and grid size (by default 1.0)");
13388 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmin=",0,"minimum radius");
13389 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRmax=",0,"maximum radius");
13390 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fThemin=",0,"minimum theta");
13391 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fThemax=",0,"maximum theta");
13392 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhimin=",0,"minimum phi");
13393 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhimax=",0,"maximum phi");
13394 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"faX=",0,"Coeff along Ox");
13395 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"faY=",0,"Coeff along Oy");
13396 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"faZ=",0,"Coeff along Oz");
13397 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13398 }
13399 G__tag_memvar_reset();
13400 }
13401
13402
13403
13404 static void G__setup_memvarTTRAP(void) {
13405 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP));
13406 { TTRAP *p; p=(TTRAP*)0x1000; if (p) { }
13407 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fH1=",0,"half length in y at low z");
13408 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBl1=",0,"half length in x at low z and y low edge");
13409 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTl1=",0,"half length in x at low z and y high edge");
13410 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAlpha1=",0,"angle w.r.t. the y axis");
13411 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fH2=",0,"half length in y at high z");
13412 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBl2=",0,"half length in x at high z and y low edge");
13413 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTl2=",0,"half length in x at high z and y high edge");
13414 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fAlpha2=",0,"angle w.r.t. the y axis");
13415 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13416 }
13417 G__tag_memvar_reset();
13418 }
13419
13420
13421
13422 static void G__setup_memvarTTRD1(void) {
13423 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1));
13424 { TTRD1 *p; p=(TTRD1*)0x1000; if (p) { }
13425 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDx2=",0,"half length in x at the high z surface");
13426 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13427 }
13428 G__tag_memvar_reset();
13429 }
13430
13431
13432
13433 static void G__setup_memvarTTRD2(void) {
13434 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2));
13435 { TTRD2 *p; p=(TTRD2*)0x1000; if (p) { }
13436 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDx2=",0,"half length in x at the high z surface");
13437 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDy2=",0,"half length in y at the high z surface");
13438 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13439 }
13440 G__tag_memvar_reset();
13441 }
13442
13443
13444
13445 static void G__setup_memvarTView3D(void) {
13446 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TView3D));
13447 { TView3D *p; p=(TView3D*)0x1000; if (p) { }
13448 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLatitude=",0,"View angle latitude");
13449 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLongitude=",0,"View angle longitude");
13450 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsi=",0,"View angle psi");
13451 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDview=",0,"Distance from COP to COV");
13452 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDproj=",0,"Distance from COP to projection plane");
13453 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUpix=",0,"pad X size in pixels");
13454 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVpix=",0,"pad Y size in pixels");
13455 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTN[16]=",0,(char*)NULL);
13456 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTB[16]=",0,(char*)NULL);
13457 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax[3]=",0,"Upper limits of object");
13458 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin[3]=",0,"Lower limits of object");
13459 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUVcoord[4]=",0,"Viewing window limits");
13460 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTnorm[16]=",0,"Transformation matrix");
13461 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTback[16]=",0,"Back transformation matrix");
13462 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX1[3]=",0,"First coordinate of X axis");
13463 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX2[3]=",0,"Second coordinate of X axis");
13464 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY1[3]=",0,"First coordinate of Y axis");
13465 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY2[3]=",0,"Second coordinate of Y axis");
13466 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ1[3]=",0,"First coordinate of Z axis");
13467 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ2[3]=",0,"Second coordinate of Z axis");
13468 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSystem=",0,"Coordinate system");
13469 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TSeqCollection),-1,-1,2,"fOutline=",0,"Collection of outline's objects");
13470 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDefaultOutline=",0,"Set to TRUE if outline is default cube");
13471 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoRange=",0,"Set to TRUE if range computed automatically");
13472 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,"! Set to TRUE after ExecuteRotateView");
13473 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TView3DcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kPerspective=%lldLL",(long long)TView3D::kPerspective).data(),0,(char*)NULL);
13474 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13475 }
13476 G__tag_memvar_reset();
13477 }
13478
13479
13480
13481 static void G__setup_memvarTXTRU(void) {
13482 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU));
13483 { TXTRU *p; p=(TXTRU*)0x1000; if (p) { }
13484 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNxy=",0,"number of x-y points in the cross section");
13485 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNxyAlloc=",0,"number of x-y points allocated");
13486 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes");
13487 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNzAlloc=",0,"number of z planes allocated");
13488 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fXvtx=",0,"[fNxyAlloc] array of x positions");
13489 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fYvtx=",0,"[fNxyAlloc] array of y positions");
13490 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fZ=",0,"[fNzAlloc] array of z planes");
13491 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScale=",0,"[fNzAlloc] array of scale factors (for each z)");
13492 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fX0=",0,"[fNzAlloc] array of x offsets (for each z)");
13493 G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fY0=",0,"[fNzAlloc] array of y offsets (for each z)");
13494 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-2,2,"kUncheckedXY=0LL",0,(char*)NULL);
13495 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-2,2,"kMalformedXY=1LL",0,(char*)NULL);
13496 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-2,2,"kConvexCCW=2LL",0,(char*)NULL);
13497 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-2,2,"kConvexCW=3LL",0,(char*)NULL);
13498 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-2,2,"kConcaveCCW=4LL",0,(char*)NULL);
13499 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-2,2,"kConcaveCW=5LL",0,(char*)NULL);
13500 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-2,2,"kUncheckedZ=0LL",0,(char*)NULL);
13501 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-2,2,"kMalformedZ=1LL",0,(char*)NULL);
13502 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-2,2,"kConvexIncZ=2LL",0,(char*)NULL);
13503 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-2,2,"kConvexDecZ=3LL",0,(char*)NULL);
13504 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-2,2,"kConcaveIncZ=4LL",0,(char*)NULL);
13505 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-2,2,"kConcaveDecZ=5LL",0,(char*)NULL);
13506 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEXYChecked),-1,-1,2,"fPolygonShape=",0,"CCW vs. CW, convex vs. concave");
13507 G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__G3DLN_TXTRUcLcLEZChecked),-1,-1,2,"fZOrdering=",0,"increasing or decreasing");
13508 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSplitConcave=",0,(char*)NULL);
13509 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13510 }
13511 G__tag_memvar_reset();
13512 }
13513
13514 extern "C" void G__cpp_setup_memvarG__G3D() {
13515 }
13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528 static void G__setup_memfuncTAxis3D(void) {
13529
13530 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TAxis3D));
13531 G__memfunc_setup("AxisChoice",992,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "C - 'Option_t' 10 - axis", (char*)NULL, (void*) NULL, 0);
13532 G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
13533 G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TObject' - 1 - hnew", (char*)NULL, (void*) NULL, 1);
13534 G__memfunc_setup("InitSet",704,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
13535 G__memfunc_setup("SwitchZoom",1047,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
13536 G__memfunc_setup("TAxis3D",608,G__G__G3D_120_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_TAxis3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13537 G__memfunc_setup("TAxis3D",608,G__G__G3D_120_0_7, 105, G__get_linked_tagnum(&G__G__G3DLN_TAxis3D), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
13538 G__memfunc_setup("TAxis3D",608,G__G__G3D_120_0_8, 105, G__get_linked_tagnum(&G__G__G3DLN_TAxis3D), -1, 0, 1, 1, 1, 0, "u 'TAxis3D' - 11 - axis", (char*)NULL, (void*) NULL, 0);
13539 G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
13540 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13541 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13542 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
13543 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
13544 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13545 G__memfunc_setup("StickyZoom",1052,G__G__G3D_120_0_12, 103, -1, G__defined_typename("Bool_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13546 G__memfunc_setup("Zoom",421,G__G__G3D_120_0_13, 103, -1, G__defined_typename("Bool_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13547 G__memfunc_setup("GetNdivisions",1350,G__G__G3D_120_0_14, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13548 G__memfunc_setup("GetAxisColor",1204,G__G__G3D_120_0_15, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13549 G__memfunc_setup("GetLabelColor",1279,G__G__G3D_120_0_16, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13550 G__memfunc_setup("GetLabelFont",1175,G__G__G3D_120_0_17, 115, -1, G__defined_typename("Style_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13551 G__memfunc_setup("GetLabelOffset",1383,G__G__G3D_120_0_18, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13552 G__memfunc_setup("GetLabelSize",1179,G__G__G3D_120_0_19, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13553 G__memfunc_setup("GetPadAxis",970,G__G__G3D_120_0_20, 85, G__get_linked_tagnum(&G__G__G3DLN_TAxis3D), -1, 0, 1, 3, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) G__func2void( (TAxis3D* (*)(TVirtualPad*))(&TAxis3D::GetPadAxis) ), 0);
13554 G__memfunc_setup("GetTitleOffset",1417,G__G__G3D_120_0_21, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13555 G__memfunc_setup("GetTickLength",1293,G__G__G3D_120_0_22, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"X\"' axis", (char*)NULL, (void*) NULL, 1);
13556 G__memfunc_setup("GetCenter",897,G__G__G3D_120_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Axis_t' 0 - center", (char*)NULL, (void*) NULL, 1);
13557 G__memfunc_setup("GetLowEdge",967,G__G__G3D_120_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Axis_t' 0 - edge", (char*)NULL, (void*) NULL, 1);
13558 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
13559 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13560 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13561 G__memfunc_setup("GetXaxis",813,G__G__G3D_120_0_27, 85, G__get_linked_tagnum(&G__G__G3DLN_TAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13562 G__memfunc_setup("GetYaxis",814,G__G__G3D_120_0_28, 85, G__get_linked_tagnum(&G__G__G3DLN_TAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13563 G__memfunc_setup("GetZaxis",815,G__G__G3D_120_0_29, 85, G__get_linked_tagnum(&G__G__G3DLN_TAxis), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13564 G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13565 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13566 G__memfunc_setup("PaintAxis",913,G__G__G3D_120_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
13567 "U 'TGaxis' - 0 - axis f - 'Float_t' 0 - ang", (char*)NULL, (void*) NULL, 0);
13568 G__memfunc_setup("PixeltoXYZ",1008,G__G__G3D_120_0_33, 68, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0,
13569 "d - 'Double_t' 0 - px d - 'Double_t' 0 - py "
13570 "D - 'Double_t' 0 - point3D U 'TView' - 0 '0' view", (char*)NULL, (void*) G__func2void( (Double_t* (*)(Double_t, Double_t, Double_t*, TView*))(&TAxis3D::PixeltoXYZ) ), 0);
13571 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
13572 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13573 G__memfunc_setup("SetAxisColor",1216,G__G__G3D_120_0_35, 121, -1, -1, 0, 2, 1, 1, 0,
13574 "s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13575 G__memfunc_setup("SetAxisRange",1198,G__G__G3D_120_0_36, 121, -1, -1, 0, 3, 1, 1, 0,
13576 "d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
13577 "C - 'Option_t' 10 '\"*\"' axis", (char*)NULL, (void*) NULL, 1);
13578 G__memfunc_setup("SetLabelColor",1291,G__G__G3D_120_0_37, 121, -1, -1, 0, 2, 1, 1, 0,
13579 "s - 'Color_t' 0 '1' color C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13580 G__memfunc_setup("SetLabelFont",1187,G__G__G3D_120_0_38, 121, -1, -1, 0, 2, 1, 1, 0,
13581 "s - 'Style_t' 0 '62' font C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13582 G__memfunc_setup("SetLabelOffset",1395,G__G__G3D_120_0_39, 121, -1, -1, 0, 2, 1, 1, 0,
13583 "f - 'Float_t' 0 '0.005' offset C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13584 G__memfunc_setup("SetLabelSize",1191,G__G__G3D_120_0_40, 121, -1, -1, 0, 2, 1, 1, 0,
13585 "f - 'Float_t' 0 '0.02' size C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13586 G__memfunc_setup("SetNdivisions",1362,G__G__G3D_120_0_41, 121, -1, -1, 0, 2, 1, 1, 0,
13587 "i - 'Int_t' 0 '510' n C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13588 G__memfunc_setup("SetOption",933,G__G__G3D_120_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\" \"' option", (char*)NULL, (void*) NULL, 1);
13589 G__memfunc_setup("SetTickLength",1305,G__G__G3D_120_0_43, 121, -1, -1, 0, 2, 1, 1, 0,
13590 "f - 'Float_t' 0 '0.02' length C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13591 G__memfunc_setup("SetTitleOffset",1429,G__G__G3D_120_0_44, 121, -1, -1, 0, 2, 1, 1, 0,
13592 "f - 'Float_t' 0 '1' offset C - 'Option_t' 10 '\"*\"' axis", "*MENU*", (void*) NULL, 1);
13593 G__memfunc_setup("SetXTitle",902,G__G__G3D_120_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", "*MENU*", (void*) NULL, 1);
13594 G__memfunc_setup("SetYTitle",903,G__G__G3D_120_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", "*MENU*", (void*) NULL, 1);
13595 G__memfunc_setup("SetZTitle",904,G__G__G3D_120_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", "*MENU*", (void*) NULL, 1);
13596 G__memfunc_setup("ToggleRulers",1247,G__G__G3D_120_0_48, 85, G__get_linked_tagnum(&G__G__G3DLN_TAxis3D), -1, 0, 1, 3, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) G__func2void( (TAxis3D* (*)(TVirtualPad*))(&TAxis3D::ToggleRulers) ), 0);
13597 G__memfunc_setup("ToggleZoom",1031,G__G__G3D_120_0_49, 85, G__get_linked_tagnum(&G__G__G3DLN_TAxis3D), -1, 0, 1, 3, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) G__func2void( (TAxis3D* (*)(TVirtualPad*))(&TAxis3D::ToggleZoom) ), 0);
13598 G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13599 G__memfunc_setup("Class",502,G__G__G3D_120_0_51, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAxis3D::Class) ), 0);
13600 G__memfunc_setup("Class_Name",982,G__G__G3D_120_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxis3D::Class_Name) ), 0);
13601 G__memfunc_setup("Class_Version",1339,G__G__G3D_120_0_53, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAxis3D::Class_Version) ), 0);
13602 G__memfunc_setup("Dictionary",1046,G__G__G3D_120_0_54, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAxis3D::Dictionary) ), 0);
13603 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13604 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13605 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13606 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_120_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13607 G__memfunc_setup("DeclFileName",1145,G__G__G3D_120_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxis3D::DeclFileName) ), 0);
13608 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_120_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxis3D::ImplFileLine) ), 0);
13609 G__memfunc_setup("ImplFileName",1171,G__G__G3D_120_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxis3D::ImplFileName) ), 0);
13610 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_120_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxis3D::DeclFileLine) ), 0);
13611
13612 G__memfunc_setup("~TAxis3D", 734, G__G__G3D_120_0_63, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13613 G__tag_memfunc_reset();
13614 }
13615
13616 static void G__setup_memfuncTMaterial(void) {
13617
13618 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TMaterial));
13619 G__memfunc_setup("TMaterial",899,G__G__G3D_122_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13620 G__memfunc_setup("TMaterial",899,G__G__G3D_122_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 5, 1, 1, 0,
13621 "C - - 10 - name C - - 10 - title "
13622 "f - 'Float_t' 0 - a f - 'Float_t' 0 - z "
13623 "f - 'Float_t' 0 - density", (char*)NULL, (void*) NULL, 0);
13624 G__memfunc_setup("TMaterial",899,G__G__G3D_122_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 7, 1, 1, 0,
13625 "C - - 10 - name C - - 10 - title "
13626 "f - 'Float_t' 0 - a f - 'Float_t' 0 - z "
13627 "f - 'Float_t' 0 - density f - 'Float_t' 0 - radl "
13628 "f - 'Float_t' 0 - inter", (char*)NULL, (void*) NULL, 0);
13629 G__memfunc_setup("GetNumber",905,G__G__G3D_122_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13630 G__memfunc_setup("GetA",353,G__G__G3D_122_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13631 G__memfunc_setup("GetZ",378,G__G__G3D_122_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13632 G__memfunc_setup("GetDensity",1024,G__G__G3D_122_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13633 G__memfunc_setup("GetRadLength",1177,G__G__G3D_122_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13634 G__memfunc_setup("GetInterLength",1412,G__G__G3D_122_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13635 G__memfunc_setup("Class",502,G__G__G3D_122_0_10, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMaterial::Class) ), 0);
13636 G__memfunc_setup("Class_Name",982,G__G__G3D_122_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMaterial::Class_Name) ), 0);
13637 G__memfunc_setup("Class_Version",1339,G__G__G3D_122_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMaterial::Class_Version) ), 0);
13638 G__memfunc_setup("Dictionary",1046,G__G__G3D_122_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMaterial::Dictionary) ), 0);
13639 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13640 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13641 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13642 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_122_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13643 G__memfunc_setup("DeclFileName",1145,G__G__G3D_122_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMaterial::DeclFileName) ), 0);
13644 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_122_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMaterial::ImplFileLine) ), 0);
13645 G__memfunc_setup("ImplFileName",1171,G__G__G3D_122_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMaterial::ImplFileName) ), 0);
13646 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_122_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMaterial::DeclFileLine) ), 0);
13647
13648 G__memfunc_setup("TMaterial", 899, G__G__G3D_122_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 1, 1, 1, 0, "u 'TMaterial' - 11 - -", (char*) NULL, (void*) NULL, 0);
13649
13650 G__memfunc_setup("~TMaterial", 1025, G__G__G3D_122_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13651
13652 G__memfunc_setup("operator=", 937, G__G__G3D_122_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 1, 1, 1, 1, 0, "u 'TMaterial' - 11 - -", (char*) NULL, (void*) NULL, 0);
13653 G__tag_memfunc_reset();
13654 }
13655
13656 static void G__setup_memfuncTNode(void) {
13657
13658 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TNode));
13659 G__memfunc_setup("TNode",474,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 1, 1, 2, 0, "u 'TNode' - 11 - -", (char*)NULL, (void*) NULL, 0);
13660 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 1, 1, 1, 2, 0, "u 'TNode' - 11 - -", (char*)NULL, (void*) NULL, 0);
13661 G__memfunc_setup("TNode",474,G__G__G3D_129_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13662 G__memfunc_setup("TNode",474,G__G__G3D_129_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 8, 1, 1, 0,
13663 "C - - 10 - name C - - 10 - title "
13664 "C - - 10 - shapename d - 'Double_t' 0 '0' x "
13665 "d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
13666 "C - - 10 '\"\"' matrixname C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
13667 G__memfunc_setup("TNode",474,G__G__G3D_129_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 8, 1, 1, 0,
13668 "C - - 10 - name C - - 10 - title "
13669 "U 'TShape' - 0 - shape d - 'Double_t' 0 '0' x "
13670 "d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
13671 "U 'TRotMatrix' - 0 '0' matrix C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
13672 G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
13673 G__memfunc_setup("BuildListOfNodes",1594,G__G__G3D_129_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13674 G__memfunc_setup("cd",199,G__G__G3D_129_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' path", "*MENU*", (void*) NULL, 1);
13675 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13676 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13677 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
13678 G__memfunc_setup("DrawOnly",816,G__G__G3D_129_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13679 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
13680 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
13681 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13682 G__memfunc_setup("GetListOfNodes",1386,G__G__G3D_129_0_13, 85, G__get_linked_tagnum(&G__G__G3DLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13683 G__memfunc_setup("GetMatrix",917,G__G__G3D_129_0_14, 85, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13684 G__memfunc_setup("GetNode",678,G__G__G3D_129_0_15, 85, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
13685 G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8,
13686 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13687 G__memfunc_setup("GetOption",921,G__G__G3D_129_0_17, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
13688 G__memfunc_setup("GetParent",906,G__G__G3D_129_0_18, 85, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13689 G__memfunc_setup("GetShape",785,G__G__G3D_129_0_19, 85, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13690 G__memfunc_setup("GetVisibility",1352,G__G__G3D_129_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13691 G__memfunc_setup("GetX",376,G__G__G3D_129_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13692 G__memfunc_setup("GetY",377,G__G__G3D_129_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13693 G__memfunc_setup("GetZ",378,G__G__G3D_129_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13694 G__memfunc_setup("ImportShapeAttributes",2195,G__G__G3D_129_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13695 G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13696 G__memfunc_setup("Local2Master",1161,G__G__G3D_129_0_26, 121, -1, -1, 0, 2, 1, 1, 0,
13697 "D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
13698 G__memfunc_setup("Local2Master",1161,G__G__G3D_129_0_27, 121, -1, -1, 0, 2, 1, 1, 0,
13699 "F - 'Float_t' 10 - local F - 'Float_t' 0 - master", (char*)NULL, (void*) NULL, 1);
13700 G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"2\"' option", "*MENU*", (void*) NULL, 1);
13701 G__memfunc_setup("Master2Local",1161,G__G__G3D_129_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
13702 "D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
13703 G__memfunc_setup("Master2Local",1161,G__G__G3D_129_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
13704 "F - 'Float_t' 10 - master F - 'Float_t' 0 - local", (char*)NULL, (void*) NULL, 1);
13705 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13706 G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
13707 G__memfunc_setup("SetMatrix",929,G__G__G3D_129_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRotMatrix' - 0 '0' matrix", (char*)NULL, (void*) NULL, 1);
13708 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
13709 G__memfunc_setup("SetParent",918,G__G__G3D_129_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TNode' - 0 - parent", (char*)NULL, (void*) NULL, 1);
13710 G__memfunc_setup("SetNameTitle",1199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
13711 "C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
13712 G__memfunc_setup("SetPosition",1153,G__G__G3D_129_0_37, 121, -1, -1, 0, 3, 1, 1, 0,
13713 "d - 'Double_t' 0 '0' x d - 'Double_t' 0 '0' y "
13714 "d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 1);
13715 G__memfunc_setup("SetVisibility",1364,G__G__G3D_129_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' vis", "*MENU*", (void*) NULL, 1);
13716 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13717 G__memfunc_setup("UpdateMatrix",1240,G__G__G3D_129_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
13718 G__memfunc_setup("UpdateTempMatrix",1646,G__G__G3D_129_0_41, 121, -1, -1, 0, 8, 1, 1, 0,
13719 "D - 'Double_t' 10 - dx1 D - 'Double_t' 10 - rmat1 "
13720 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
13721 "d - 'Double_t' 0 - z D - 'Double_t' 0 - matrix "
13722 "D - 'Double_t' 0 - dxnew D - 'Double_t' 0 - rmatnew", (char*)NULL, (void*) NULL, 1);
13723 G__memfunc_setup("Class",502,G__G__G3D_129_0_42, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNode::Class) ), 0);
13724 G__memfunc_setup("Class_Name",982,G__G__G3D_129_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNode::Class_Name) ), 0);
13725 G__memfunc_setup("Class_Version",1339,G__G__G3D_129_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNode::Class_Version) ), 0);
13726 G__memfunc_setup("Dictionary",1046,G__G__G3D_129_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNode::Dictionary) ), 0);
13727 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13728 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13729 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13730 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_129_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13731 G__memfunc_setup("DeclFileName",1145,G__G__G3D_129_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNode::DeclFileName) ), 0);
13732 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_129_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNode::ImplFileLine) ), 0);
13733 G__memfunc_setup("ImplFileName",1171,G__G__G3D_129_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNode::ImplFileName) ), 0);
13734 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_129_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNode::DeclFileLine) ), 0);
13735
13736 G__memfunc_setup("~TNode", 600, G__G__G3D_129_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13737 G__tag_memfunc_reset();
13738 }
13739
13740 static void G__setup_memfuncTShape(void) {
13741
13742 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TShape));
13743 G__memfunc_setup("FillBuffer3D",1112,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8,
13744 "u 'TBuffer3D' - 1 - buffer i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
13745 G__memfunc_setup("GetBasicColor",1281,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
13746 G__memfunc_setup("ShapeDistancetoPrimitive",2488,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0,
13747 "i - 'Int_t' 0 - numPoints i - 'Int_t' 0 - px "
13748 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
13749 G__memfunc_setup("TShape",581,G__G__G3D_130_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13750 G__memfunc_setup("TShape",581,G__G__G3D_130_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 0, 3, 1, 1, 0,
13751 "C - - 10 - name C - - 10 - title "
13752 "C - - 10 - material", (char*)NULL, (void*) NULL, 0);
13753 G__memfunc_setup("TShape",581,G__G__G3D_130_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 0, 1, 1, 1, 0, "u 'TShape' - 11 - -", (char*)NULL, (void*) NULL, 0);
13754 G__memfunc_setup("operator=",937,G__G__G3D_130_0_7, 117, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 1, 1, 1, 1, 0, "u 'TShape' - 11 - -", (char*)NULL, (void*) NULL, 0);
13755 G__memfunc_setup("GetBuffer3D",1009,G__G__G3D_130_0_8, 117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
13756 G__memfunc_setup("GetMaterial",1103,G__G__G3D_130_0_9, 85, G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13757 G__memfunc_setup("GetNumber",905,G__G__G3D_130_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13758 G__memfunc_setup("GetVisibility",1352,G__G__G3D_130_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13759 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
13760 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
13761 G__memfunc_setup("SetPoints",937,G__G__G3D_130_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13762 G__memfunc_setup("SetVisibility",1364,G__G__G3D_130_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vis", "*MENU*", (void*) NULL, 1);
13763 G__memfunc_setup("TransformPoints",1593,G__G__G3D_130_0_16, 121, -1, -1, 0, 2, 1, 1, 8,
13764 "D - 'Double_t' 0 - points h - 'UInt_t' 0 - NbPnts", (char*)NULL, (void*) NULL, 0);
13765 G__memfunc_setup("Class",502,G__G__G3D_130_0_17, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TShape::Class) ), 0);
13766 G__memfunc_setup("Class_Name",982,G__G__G3D_130_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TShape::Class_Name) ), 0);
13767 G__memfunc_setup("Class_Version",1339,G__G__G3D_130_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TShape::Class_Version) ), 0);
13768 G__memfunc_setup("Dictionary",1046,G__G__G3D_130_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TShape::Dictionary) ), 0);
13769 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13770 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13771 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13772 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_130_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13773 G__memfunc_setup("DeclFileName",1145,G__G__G3D_130_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TShape::DeclFileName) ), 0);
13774 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_130_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TShape::ImplFileLine) ), 0);
13775 G__memfunc_setup("ImplFileName",1171,G__G__G3D_130_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TShape::ImplFileName) ), 0);
13776 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_130_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TShape::DeclFileLine) ), 0);
13777
13778 G__memfunc_setup("~TShape", 707, G__G__G3D_130_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13779 G__tag_memfunc_reset();
13780 }
13781
13782 static void G__setup_memfuncTBRIK(void) {
13783
13784 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TBRIK));
13785 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13786 G__memfunc_setup("TBRIK",380,G__G__G3D_131_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TBRIK), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13787 G__memfunc_setup("TBRIK",380,G__G__G3D_131_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TBRIK), -1, 0, 6, 1, 1, 0,
13788 "C - - 10 - name C - - 10 - title "
13789 "C - - 10 - material f - 'Float_t' 0 - dx "
13790 "f - 'Float_t' 0 - dy f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
13791 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13792 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13793 G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
13794 G__memfunc_setup("GetDx",476,G__G__G3D_131_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13795 G__memfunc_setup("GetDy",477,G__G__G3D_131_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13796 G__memfunc_setup("GetDz",478,G__G__G3D_131_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13797 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13798 G__memfunc_setup("Class",502,G__G__G3D_131_0_10, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBRIK::Class) ), 0);
13799 G__memfunc_setup("Class_Name",982,G__G__G3D_131_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBRIK::Class_Name) ), 0);
13800 G__memfunc_setup("Class_Version",1339,G__G__G3D_131_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBRIK::Class_Version) ), 0);
13801 G__memfunc_setup("Dictionary",1046,G__G__G3D_131_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBRIK::Dictionary) ), 0);
13802 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13803 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13804 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13805 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_131_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13806 G__memfunc_setup("DeclFileName",1145,G__G__G3D_131_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBRIK::DeclFileName) ), 0);
13807 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_131_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBRIK::ImplFileLine) ), 0);
13808 G__memfunc_setup("ImplFileName",1171,G__G__G3D_131_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBRIK::ImplFileName) ), 0);
13809 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_131_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBRIK::DeclFileLine) ), 0);
13810
13811 G__memfunc_setup("TBRIK", 380, G__G__G3D_131_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TBRIK), -1, 0, 1, 1, 1, 0, "u 'TBRIK' - 11 - -", (char*) NULL, (void*) NULL, 0);
13812
13813 G__memfunc_setup("~TBRIK", 506, G__G__G3D_131_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13814
13815 G__memfunc_setup("operator=", 937, G__G__G3D_131_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TBRIK), -1, 1, 1, 1, 1, 0, "u 'TBRIK' - 11 - -", (char*) NULL, (void*) NULL, 0);
13816 G__tag_memfunc_reset();
13817 }
13818
13819 static void G__setup_memfuncTTUBE(void) {
13820
13821 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBE));
13822 G__memfunc_setup("TTUBE",388,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBE), -1, 0, 1, 1, 2, 0, "u 'TTUBE' - 11 - -", (char*)NULL, (void*) NULL, 0);
13823 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TTUBE), -1, 1, 1, 1, 2, 0, "u 'TTUBE' - 11 - -", (char*)NULL, (void*) NULL, 0);
13824 G__memfunc_setup("MakeTableOfCoSin",1527,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", "Create the table of the fSiTab; fCoTab", (void*) NULL, 1);
13825 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13826 G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TBuffer3D' - 1 - buffer", (char*)NULL, (void*) NULL, 1);
13827 G__memfunc_setup("TTUBE",388,G__G__G3D_132_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBE), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13828 G__memfunc_setup("TTUBE",388,G__G__G3D_132_0_7, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBE), -1, 0, 7, 1, 1, 0,
13829 "C - - 10 - name C - - 10 - title "
13830 "C - - 10 - material f - 'Float_t' 0 - rmin "
13831 "f - 'Float_t' 0 - rmax f - 'Float_t' 0 - dz "
13832 "f - 'Float_t' 0 '1' aspect", (char*)NULL, (void*) NULL, 0);
13833 G__memfunc_setup("TTUBE",388,G__G__G3D_132_0_8, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBE), -1, 0, 5, 1, 1, 0,
13834 "C - - 10 - name C - - 10 - title "
13835 "C - - 10 - material f - 'Float_t' 0 - rmax "
13836 "f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
13837 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13838 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13839 G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
13840 G__memfunc_setup("GetRmin",694,G__G__G3D_132_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13841 G__memfunc_setup("GetRmax",696,G__G__G3D_132_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13842 G__memfunc_setup("GetDz",478,G__G__G3D_132_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13843 G__memfunc_setup("GetNdiv",689,G__G__G3D_132_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13844 G__memfunc_setup("GetAspectRatio",1407,G__G__G3D_132_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13845 G__memfunc_setup("GetNumberOfDivisions",2038,G__G__G3D_132_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13846 G__memfunc_setup("SetNumberOfDivisions",2050,G__G__G3D_132_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndiv", (char*)NULL, (void*) NULL, 1);
13847 G__memfunc_setup("SetAspectRatio",1419,G__G__G3D_132_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1' factor", (char*)NULL, (void*) NULL, 1);
13848 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13849 G__memfunc_setup("Class",502,G__G__G3D_132_0_20, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTUBE::Class) ), 0);
13850 G__memfunc_setup("Class_Name",982,G__G__G3D_132_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTUBE::Class_Name) ), 0);
13851 G__memfunc_setup("Class_Version",1339,G__G__G3D_132_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTUBE::Class_Version) ), 0);
13852 G__memfunc_setup("Dictionary",1046,G__G__G3D_132_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTUBE::Dictionary) ), 0);
13853 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13854 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13855 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13856 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_132_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13857 G__memfunc_setup("DeclFileName",1145,G__G__G3D_132_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTUBE::DeclFileName) ), 0);
13858 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_132_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTUBE::ImplFileLine) ), 0);
13859 G__memfunc_setup("ImplFileName",1171,G__G__G3D_132_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTUBE::ImplFileName) ), 0);
13860 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_132_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTUBE::DeclFileLine) ), 0);
13861
13862 G__memfunc_setup("~TTUBE", 514, G__G__G3D_132_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13863 G__tag_memfunc_reset();
13864 }
13865
13866 static void G__setup_memfuncTCONE(void) {
13867
13868 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONE));
13869 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13870 G__memfunc_setup("TCONE",377,G__G__G3D_133_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TCONE), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13871 G__memfunc_setup("TCONE",377,G__G__G3D_133_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TCONE), -1, 0, 8, 1, 1, 0,
13872 "C - - 10 - name C - - 10 - title "
13873 "C - - 10 - material f - 'Float_t' 0 - dz "
13874 "f - 'Float_t' 0 - rmin1 f - 'Float_t' 0 - rmax1 "
13875 "f - 'Float_t' 0 - rmin2 f - 'Float_t' 0 - rmax2", (char*)NULL, (void*) NULL, 0);
13876 G__memfunc_setup("TCONE",377,G__G__G3D_133_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TCONE), -1, 0, 6, 1, 1, 0,
13877 "C - - 10 - name C - - 10 - title "
13878 "C - - 10 - material f - 'Float_t' 0 - dz "
13879 "f - 'Float_t' 0 - rmax1 f - 'Float_t' 0 '0' rmax2", (char*)NULL, (void*) NULL, 0);
13880 G__memfunc_setup("GetRmin2",744,G__G__G3D_133_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13881 G__memfunc_setup("GetRmax2",746,G__G__G3D_133_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
13882 G__memfunc_setup("Class",502,G__G__G3D_133_0_7, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCONE::Class) ), 0);
13883 G__memfunc_setup("Class_Name",982,G__G__G3D_133_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCONE::Class_Name) ), 0);
13884 G__memfunc_setup("Class_Version",1339,G__G__G3D_133_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCONE::Class_Version) ), 0);
13885 G__memfunc_setup("Dictionary",1046,G__G__G3D_133_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCONE::Dictionary) ), 0);
13886 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13887 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13888 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13889 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_133_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13890 G__memfunc_setup("DeclFileName",1145,G__G__G3D_133_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCONE::DeclFileName) ), 0);
13891 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_133_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCONE::ImplFileLine) ), 0);
13892 G__memfunc_setup("ImplFileName",1171,G__G__G3D_133_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCONE::ImplFileName) ), 0);
13893 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_133_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCONE::DeclFileLine) ), 0);
13894
13895 G__memfunc_setup("TCONE", 377, G__G__G3D_133_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TCONE), -1, 0, 1, 1, 1, 0, "u 'TCONE' - 11 - -", (char*) NULL, (void*) NULL, 0);
13896
13897 G__memfunc_setup("~TCONE", 503, G__G__G3D_133_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13898 G__tag_memfunc_reset();
13899 }
13900
13901 static void G__setup_memfuncTTUBS(void) {
13902
13903 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TTUBS));
13904 G__memfunc_setup("MakeTableOfCoSin",1527,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", "Create the table of the fSiTab; fCoTab", (void*) NULL, 1);
13905 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13906 G__memfunc_setup("TTUBS",402,G__G__G3D_134_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBS), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13907 G__memfunc_setup("TTUBS",402,G__G__G3D_134_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBS), -1, 0, 8, 1, 1, 0,
13908 "C - - 10 - name C - - 10 - title "
13909 "C - - 10 - material f - 'Float_t' 0 - rmin "
13910 "f - 'Float_t' 0 - rmax f - 'Float_t' 0 - dz "
13911 "f - 'Float_t' 0 - phi1 f - 'Float_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
13912 G__memfunc_setup("TTUBS",402,G__G__G3D_134_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TTUBS), -1, 0, 7, 1, 1, 0,
13913 "C - - 10 - name C - - 10 - title "
13914 "C - - 10 - material f - 'Float_t' 0 - rmax "
13915 "f - 'Float_t' 0 - dz f - 'Float_t' 0 - phi1 "
13916 "f - 'Float_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
13917 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
13918 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
13919 G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
13920 G__memfunc_setup("GetPhi1",626,G__G__G3D_134_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13921 G__memfunc_setup("GetPhi2",627,G__G__G3D_134_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13922 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13923 G__memfunc_setup("Class",502,G__G__G3D_134_0_11, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTUBS::Class) ), 0);
13924 G__memfunc_setup("Class_Name",982,G__G__G3D_134_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTUBS::Class_Name) ), 0);
13925 G__memfunc_setup("Class_Version",1339,G__G__G3D_134_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTUBS::Class_Version) ), 0);
13926 G__memfunc_setup("Dictionary",1046,G__G__G3D_134_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTUBS::Dictionary) ), 0);
13927 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13928 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13929 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13930 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_134_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13931 G__memfunc_setup("DeclFileName",1145,G__G__G3D_134_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTUBS::DeclFileName) ), 0);
13932 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_134_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTUBS::ImplFileLine) ), 0);
13933 G__memfunc_setup("ImplFileName",1171,G__G__G3D_134_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTUBS::ImplFileName) ), 0);
13934 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_134_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTUBS::DeclFileLine) ), 0);
13935
13936 G__memfunc_setup("TTUBS", 402, G__G__G3D_134_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TTUBS), -1, 0, 1, 1, 1, 0, "u 'TTUBS' - 11 - -", (char*) NULL, (void*) NULL, 0);
13937
13938 G__memfunc_setup("~TTUBS", 528, G__G__G3D_134_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13939 G__tag_memfunc_reset();
13940 }
13941
13942 static void G__setup_memfuncTCONS(void) {
13943
13944 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TCONS));
13945 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13946 G__memfunc_setup("TCONS",391,G__G__G3D_135_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TCONS), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13947 G__memfunc_setup("TCONS",391,G__G__G3D_135_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TCONS), -1, 0, 10, 1, 1, 0,
13948 "C - - 10 - name C - - 10 - title "
13949 "C - - 10 - material f - 'Float_t' 0 - dz "
13950 "f - 'Float_t' 0 - rmin1 f - 'Float_t' 0 - rmax1 "
13951 "f - 'Float_t' 0 - rmin2 f - 'Float_t' 0 - rmax2 "
13952 "f - 'Float_t' 0 - phi1 f - 'Float_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
13953 G__memfunc_setup("TCONS",391,G__G__G3D_135_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TCONS), -1, 0, 8, 1, 1, 0,
13954 "C - - 10 - name C - - 10 - title "
13955 "C - - 10 - material f - 'Float_t' 0 - rmax1 "
13956 "f - 'Float_t' 0 - dz f - 'Float_t' 0 - phi1 "
13957 "f - 'Float_t' 0 - phi2 f - 'Float_t' 0 '0' rmax2", (char*)NULL, (void*) NULL, 0);
13958 G__memfunc_setup("GetRmin2",744,G__G__G3D_135_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13959 G__memfunc_setup("GetRmax2",746,G__G__G3D_135_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13960 G__memfunc_setup("Class",502,G__G__G3D_135_0_7, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCONS::Class) ), 0);
13961 G__memfunc_setup("Class_Name",982,G__G__G3D_135_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCONS::Class_Name) ), 0);
13962 G__memfunc_setup("Class_Version",1339,G__G__G3D_135_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCONS::Class_Version) ), 0);
13963 G__memfunc_setup("Dictionary",1046,G__G__G3D_135_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCONS::Dictionary) ), 0);
13964 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
13965 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
13966 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
13967 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_135_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
13968 G__memfunc_setup("DeclFileName",1145,G__G__G3D_135_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCONS::DeclFileName) ), 0);
13969 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_135_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCONS::ImplFileLine) ), 0);
13970 G__memfunc_setup("ImplFileName",1171,G__G__G3D_135_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCONS::ImplFileName) ), 0);
13971 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_135_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCONS::DeclFileLine) ), 0);
13972
13973 G__memfunc_setup("TCONS", 391, G__G__G3D_135_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TCONS), -1, 0, 1, 1, 1, 0, "u 'TCONS' - 11 - -", (char*) NULL, (void*) NULL, 0);
13974
13975 G__memfunc_setup("~TCONS", 517, G__G__G3D_135_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
13976 G__tag_memfunc_reset();
13977 }
13978
13979 static void G__setup_memfuncTCTUB(void) {
13980
13981 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TCTUB));
13982 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
13983 G__memfunc_setup("TCTUB",386,G__G__G3D_136_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TCTUB), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
13984 G__memfunc_setup("TCTUB",386,G__G__G3D_136_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TCTUB), -1, 0, 14, 1, 1, 0,
13985 "C - - 10 - name C - - 10 - title "
13986 "C - - 10 - material f - 'Float_t' 0 - rmin "
13987 "f - 'Float_t' 0 - rmax f - 'Float_t' 0 - dz "
13988 "f - 'Float_t' 0 - phi1 f - 'Float_t' 0 - phi2 "
13989 "f - 'Float_t' 0 - coslx f - 'Float_t' 0 - cosly "
13990 "f - 'Float_t' 0 - coslz f - 'Float_t' 0 - coshx "
13991 "f - 'Float_t' 0 - coshy f - 'Float_t' 0 - coshz", (char*)NULL, (void*) NULL, 0);
13992 G__memfunc_setup("TCTUB",386,G__G__G3D_136_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TCTUB), -1, 0, 10, 1, 1, 0,
13993 "C - - 10 - name C - - 10 - title "
13994 "C - - 10 - material f - 'Float_t' 0 - rmin "
13995 "f - 'Float_t' 0 - rmax f - 'Float_t' 0 - dz "
13996 "f - 'Float_t' 0 - phi1 f - 'Float_t' 0 - phi2 "
13997 "F - 'Float_t' 0 - lowNormal F - 'Float_t' 0 - highNormal", (char*)NULL, (void*) NULL, 0);
13998 G__memfunc_setup("Class",502,G__G__G3D_136_0_5, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCTUB::Class) ), 0);
13999 G__memfunc_setup("Class_Name",982,G__G__G3D_136_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCTUB::Class_Name) ), 0);
14000 G__memfunc_setup("Class_Version",1339,G__G__G3D_136_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCTUB::Class_Version) ), 0);
14001 G__memfunc_setup("Dictionary",1046,G__G__G3D_136_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCTUB::Dictionary) ), 0);
14002 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14003 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14004 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14005 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_136_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14006 G__memfunc_setup("DeclFileName",1145,G__G__G3D_136_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCTUB::DeclFileName) ), 0);
14007 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_136_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCTUB::ImplFileLine) ), 0);
14008 G__memfunc_setup("ImplFileName",1171,G__G__G3D_136_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCTUB::ImplFileName) ), 0);
14009 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_136_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCTUB::DeclFileLine) ), 0);
14010
14011 G__memfunc_setup("TCTUB", 386, G__G__G3D_136_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TCTUB), -1, 0, 1, 1, 1, 0, "u 'TCTUB' - 11 - -", (char*) NULL, (void*) NULL, 0);
14012
14013 G__memfunc_setup("~TCTUB", 512, G__G__G3D_136_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14014 G__tag_memfunc_reset();
14015 }
14016
14017 static void G__setup_memfuncTELTU(void) {
14018
14019 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TELTU));
14020 G__memfunc_setup("TELTU",398,G__G__G3D_137_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_TELTU), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14021 G__memfunc_setup("TELTU",398,G__G__G3D_137_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TELTU), -1, 0, 6, 1, 1, 0,
14022 "C - - 10 - name C - - 10 - title "
14023 "C - - 10 - material f - 'Float_t' 0 - rx "
14024 "f - 'Float_t' 0 - ry f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
14025 G__memfunc_setup("Class",502,G__G__G3D_137_0_3, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TELTU::Class) ), 0);
14026 G__memfunc_setup("Class_Name",982,G__G__G3D_137_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TELTU::Class_Name) ), 0);
14027 G__memfunc_setup("Class_Version",1339,G__G__G3D_137_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TELTU::Class_Version) ), 0);
14028 G__memfunc_setup("Dictionary",1046,G__G__G3D_137_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TELTU::Dictionary) ), 0);
14029 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14030 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14031 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14032 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_137_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14033 G__memfunc_setup("DeclFileName",1145,G__G__G3D_137_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TELTU::DeclFileName) ), 0);
14034 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_137_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TELTU::ImplFileLine) ), 0);
14035 G__memfunc_setup("ImplFileName",1171,G__G__G3D_137_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TELTU::ImplFileName) ), 0);
14036 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_137_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TELTU::DeclFileLine) ), 0);
14037
14038 G__memfunc_setup("TELTU", 398, G__G__G3D_137_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TELTU), -1, 0, 1, 1, 1, 0, "u 'TELTU' - 11 - -", (char*) NULL, (void*) NULL, 0);
14039
14040 G__memfunc_setup("~TELTU", 524, G__G__G3D_137_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14041 G__tag_memfunc_reset();
14042 }
14043
14044 static void G__setup_memfuncTRotMatrix(void) {
14045
14046 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix));
14047 G__memfunc_setup("SetReflection",1335,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "Set the \"reflection\" flag if det < 0", (void*) NULL, 1);
14048 G__memfunc_setup("TRotMatrix",1022,G__G__G3D_149_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14049 G__memfunc_setup("TRotMatrix",1022,G__G__G3D_149_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 3, 1, 1, 0,
14050 "C - - 10 - name C - - 10 - title "
14051 "D - 'Double_t' 0 - matrix", (char*)NULL, (void*) NULL, 0);
14052 G__memfunc_setup("TRotMatrix",1022,G__G__G3D_149_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 5, 1, 1, 0,
14053 "C - - 10 - name C - - 10 - title "
14054 "d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi "
14055 "d - 'Double_t' 0 - psi", (char*)NULL, (void*) NULL, 0);
14056 G__memfunc_setup("TRotMatrix",1022,G__G__G3D_149_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 8, 1, 1, 0,
14057 "C - - 10 - name C - - 10 - title "
14058 "d - 'Double_t' 0 - theta1 d - 'Double_t' 0 - phi1 "
14059 "d - 'Double_t' 0 - theta2 d - 'Double_t' 0 - phi2 "
14060 "d - 'Double_t' 0 - theta3 d - 'Double_t' 0 - phi3", (char*)NULL, (void*) NULL, 0);
14061 G__memfunc_setup("Determinant",1147,G__G__G3D_149_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "returns the determinant of this matrix", (void*) NULL, 1);
14062 G__memfunc_setup("GetMatrix",917,G__G__G3D_149_0_7, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14063 G__memfunc_setup("GetNumber",905,G__G__G3D_149_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14064 G__memfunc_setup("GetType",706,G__G__G3D_149_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14065 G__memfunc_setup("GetTheta",790,G__G__G3D_149_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14066 G__memfunc_setup("GetPhi",577,G__G__G3D_149_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14067 G__memfunc_setup("GetPsi",588,G__G__G3D_149_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14068 G__memfunc_setup("GetGLMatrix",1064,G__G__G3D_149_0_13, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - rGLMatrix", "Convert this matrix to the OpenGL [4x4]", (void*) NULL, 1);
14069 G__memfunc_setup("IsReflection",1223,G__G__G3D_149_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", "Return kTRUE if this matrix defines the reflection", (void*) NULL, 1);
14070 G__memfunc_setup("SetAngles",902,G__G__G3D_149_0_15, 68, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 1,
14071 "d - 'Double_t' 0 - theta1 d - 'Double_t' 0 - phi1 "
14072 "d - 'Double_t' 0 - theta2 d - 'Double_t' 0 - phi2 "
14073 "d - 'Double_t' 0 - theta3 d - 'Double_t' 0 - phi3", (char*)NULL, (void*) NULL, 1);
14074 G__memfunc_setup("SetMatrix",929,G__G__G3D_149_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - matrix", (char*)NULL, (void*) NULL, 1);
14075 G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14076 G__memfunc_setup("Class",502,G__G__G3D_149_0_18, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRotMatrix::Class) ), 0);
14077 G__memfunc_setup("Class_Name",982,G__G__G3D_149_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRotMatrix::Class_Name) ), 0);
14078 G__memfunc_setup("Class_Version",1339,G__G__G3D_149_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRotMatrix::Class_Version) ), 0);
14079 G__memfunc_setup("Dictionary",1046,G__G__G3D_149_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRotMatrix::Dictionary) ), 0);
14080 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14081 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14082 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14083 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_149_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14084 G__memfunc_setup("DeclFileName",1145,G__G__G3D_149_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRotMatrix::DeclFileName) ), 0);
14085 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_149_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRotMatrix::ImplFileLine) ), 0);
14086 G__memfunc_setup("ImplFileName",1171,G__G__G3D_149_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRotMatrix::ImplFileName) ), 0);
14087 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_149_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRotMatrix::DeclFileLine) ), 0);
14088
14089 G__memfunc_setup("TRotMatrix", 1022, G__G__G3D_149_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 1, 1, 1, 0, "u 'TRotMatrix' - 11 - -", (char*) NULL, (void*) NULL, 0);
14090
14091 G__memfunc_setup("~TRotMatrix", 1148, G__G__G3D_149_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14092
14093 G__memfunc_setup("operator=", 937, G__G__G3D_149_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 1, 1, 1, 1, 0, "u 'TRotMatrix' - 11 - -", (char*) NULL, (void*) NULL, 0);
14094 G__tag_memfunc_reset();
14095 }
14096
14097 static void G__setup_memfuncTGeometry(void) {
14098
14099 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TGeometry));
14100 G__memfunc_setup("TGeometry",928,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__G3DLN_TGeometry), -1, 0, 1, 1, 2, 0, "u 'TGeometry' - 11 - -", (char*)NULL, (void*) NULL, 0);
14101 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TGeometry), -1, 1, 1, 1, 2, 0, "u 'TGeometry' - 11 - -", (char*)NULL, (void*) NULL, 0);
14102 G__memfunc_setup("TGeometry",928,G__G__G3D_150_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TGeometry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14103 G__memfunc_setup("TGeometry",928,G__G__G3D_150_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TGeometry), -1, 0, 2, 1, 1, 0,
14104 "C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
14105 G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
14106 G__memfunc_setup("cd",199,G__G__G3D_150_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' path", (char*)NULL, (void*) NULL, 1);
14107 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14108 G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14109 G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
14110 G__memfunc_setup("GetBomb",672,G__G__G3D_150_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14111 G__memfunc_setup("GeomLevel",896,G__G__G3D_150_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14112 G__memfunc_setup("GetListOfShapes",1493,G__G__G3D_150_0_12, 85, G__get_linked_tagnum(&G__G__G3DLN_THashList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14113 G__memfunc_setup("GetListOfNodes",1386,G__G__G3D_150_0_13, 85, G__get_linked_tagnum(&G__G__G3DLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14114 G__memfunc_setup("GetListOfMaterials",1811,G__G__G3D_150_0_14, 85, G__get_linked_tagnum(&G__G__G3DLN_THashList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14115 G__memfunc_setup("GetListOfMatrices",1705,G__G__G3D_150_0_15, 85, G__get_linked_tagnum(&G__G__G3DLN_THashList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14116 G__memfunc_setup("GetCurrentNode",1417,G__G__G3D_150_0_16, 85, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14117 G__memfunc_setup("GetMaterial",1103,G__G__G3D_150_0_17, 85, G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
14118 G__memfunc_setup("GetMaterialByNumber",1907,G__G__G3D_150_0_18, 85, G__get_linked_tagnum(&G__G__G3DLN_TMaterial), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
14119 G__memfunc_setup("GetNode",678,G__G__G3D_150_0_19, 85, G__get_linked_tagnum(&G__G__G3DLN_TNode), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
14120 G__memfunc_setup("GetShape",785,G__G__G3D_150_0_20, 85, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
14121 G__memfunc_setup("GetShapeByNumber",1589,G__G__G3D_150_0_21, 85, G__get_linked_tagnum(&G__G__G3DLN_TShape), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
14122 G__memfunc_setup("GetRotMatrix",1226,G__G__G3D_150_0_22, 85, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
14123 G__memfunc_setup("GetRotMatrixByNumber",2030,G__G__G3D_150_0_23, 85, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
14124 G__memfunc_setup("GetCurrentMatrix",1656,G__G__G3D_150_0_24, 85, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14125 G__memfunc_setup("GetCurrentPosition",1880,G__G__G3D_150_0_25, 85, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 3, 1, 1, 8,
14126 "D - 'Double_t' 0 - x D - 'Double_t' 0 - y "
14127 "D - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
14128 G__memfunc_setup("GetCurrentPosition",1880,G__G__G3D_150_0_26, 85, G__get_linked_tagnum(&G__G__G3DLN_TRotMatrix), -1, 0, 3, 1, 1, 8,
14129 "F - 'Float_t' 0 - x F - 'Float_t' 0 - y "
14130 "F - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
14131 G__memfunc_setup("GetCurrentReflection",2062,G__G__G3D_150_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14132 G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14133 G__memfunc_setup("Local2Master",1161,G__G__G3D_150_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
14134 "D - 'Double_t' 0 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
14135 G__memfunc_setup("Local2Master",1161,G__G__G3D_150_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
14136 "F - 'Float_t' 0 - local F - 'Float_t' 0 - master", (char*)NULL, (void*) NULL, 1);
14137 G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"rsn2\"' option", (char*)NULL, (void*) NULL, 1);
14138 G__memfunc_setup("Master2Local",1161,G__G__G3D_150_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
14139 "D - 'Double_t' 0 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
14140 G__memfunc_setup("Master2Local",1161,G__G__G3D_150_0_33, 121, -1, -1, 0, 2, 1, 1, 0,
14141 "F - 'Float_t' 0 - master F - 'Float_t' 0 - local", (char*)NULL, (void*) NULL, 1);
14142 G__memfunc_setup("Node",390,G__G__G3D_150_0_34, 121, -1, -1, 0, 8, 1, 1, 0,
14143 "C - - 10 - name C - - 10 - title "
14144 "C - - 10 - shapename d - 'Double_t' 0 '0' x "
14145 "d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z "
14146 "C - - 10 '\"\"' matrixname C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14147 G__memfunc_setup("PushLevel",920,G__G__G3D_150_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14148 G__memfunc_setup("PopLevel",807,G__G__G3D_150_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14149 G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
14150 G__memfunc_setup("SetBomb",684,G__G__G3D_150_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1.4' bomb", (char*)NULL, (void*) NULL, 1);
14151 G__memfunc_setup("SetCurrentNode",1429,G__G__G3D_150_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TNode' - 0 - node", (char*)NULL, (void*) NULL, 1);
14152 G__memfunc_setup("SetGeomLevel",1196,G__G__G3D_150_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' level", (char*)NULL, (void*) NULL, 1);
14153 G__memfunc_setup("SetMatrix",929,G__G__G3D_150_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRotMatrix' - 0 '0' matrix", (char*)NULL, (void*) NULL, 1);
14154 G__memfunc_setup("SetPosition",1153,G__G__G3D_150_0_42, 121, -1, -1, 0, 4, 1, 1, 0,
14155 "U 'TRotMatrix' - 0 - matrix d - 'Double_t' 0 '0' x "
14156 "d - 'Double_t' 0 '0' y d - 'Double_t' 0 '0' z", (char*)NULL, (void*) NULL, 1);
14157 G__memfunc_setup("SetPosition",1153,G__G__G3D_150_0_43, 121, -1, -1, 0, 4, 1, 1, 0,
14158 "U 'TRotMatrix' - 0 - matrix f - 'Float_t' 0 - x "
14159 "f - 'Float_t' 0 - y f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14160 G__memfunc_setup("SetPosition",1153,G__G__G3D_150_0_44, 121, -1, -1, 0, 3, 1, 1, 0,
14161 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14162 "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14163 G__memfunc_setup("SetPosition",1153,G__G__G3D_150_0_45, 121, -1, -1, 0, 3, 1, 1, 0,
14164 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
14165 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14166 G__memfunc_setup("UpdateMatrix",1240,G__G__G3D_150_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TNode' - 0 - node", (char*)NULL, (void*) NULL, 1);
14167 G__memfunc_setup("UpdateTempMatrix",1646,G__G__G3D_150_0_47, 121, -1, -1, 0, 4, 1, 1, 0,
14168 "d - 'Double_t' 0 '0' x d - 'Double_t' 0 '0' y "
14169 "d - 'Double_t' 0 '0' z U 'TRotMatrix' - 0 '0' matrix", (char*)NULL, (void*) NULL, 1);
14170 G__memfunc_setup("UpdateTempMatrix",1646,G__G__G3D_150_0_48, 121, -1, -1, 0, 5, 1, 1, 0,
14171 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14172 "d - 'Double_t' 0 - z D - 'Double_t' 0 - matrix "
14173 "g - 'Bool_t' 0 'kFALSE' isReflection", (char*)NULL, (void*) NULL, 1);
14174 G__memfunc_setup("Get",288,G__G__G3D_150_0_49, 85, G__get_linked_tagnum(&G__G__G3DLN_TObjArray), -1, 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (TObjArray* (*)(const char*))(&TGeometry::Get) ), 0);
14175 G__memfunc_setup("UpdateTempMatrix",1646,G__G__G3D_150_0_50, 121, -1, -1, 0, 8, 3, 1, 0,
14176 "D - 'Double_t' 0 - dx1 D - 'Double_t' 0 - rmat1 "
14177 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14178 "d - 'Double_t' 0 - z D - 'Double_t' 0 - matrix "
14179 "D - 'Double_t' 0 - dxnew D - 'Double_t' 0 - rmatnew", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t*, Double_t*, Double_t*))(&TGeometry::UpdateTempMatrix) ), 0);
14180 G__memfunc_setup("Class",502,G__G__G3D_150_0_51, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeometry::Class) ), 0);
14181 G__memfunc_setup("Class_Name",982,G__G__G3D_150_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeometry::Class_Name) ), 0);
14182 G__memfunc_setup("Class_Version",1339,G__G__G3D_150_0_53, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeometry::Class_Version) ), 0);
14183 G__memfunc_setup("Dictionary",1046,G__G__G3D_150_0_54, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeometry::Dictionary) ), 0);
14184 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14185 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14186 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14187 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_150_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14188 G__memfunc_setup("DeclFileName",1145,G__G__G3D_150_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeometry::DeclFileName) ), 0);
14189 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_150_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeometry::ImplFileLine) ), 0);
14190 G__memfunc_setup("ImplFileName",1171,G__G__G3D_150_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeometry::ImplFileName) ), 0);
14191 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_150_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeometry::DeclFileLine) ), 0);
14192
14193 G__memfunc_setup("~TGeometry", 1054, G__G__G3D_150_0_63, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14194 G__tag_memfunc_reset();
14195 }
14196
14197 static void G__setup_memfuncTGTRA(void) {
14198
14199 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TGTRA));
14200 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14201 G__memfunc_setup("TGTRA",386,G__G__G3D_151_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TGTRA), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14202 G__memfunc_setup("TGTRA",386,G__G__G3D_151_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TGTRA), -1, 0, 15, 1, 1, 0,
14203 "C - - 10 - name C - - 10 - title "
14204 "C - - 10 - material f - 'Float_t' 0 - dz "
14205 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi "
14206 "f - 'Float_t' 0 - twist f - 'Float_t' 0 - h1 "
14207 "f - 'Float_t' 0 - bl1 f - 'Float_t' 0 - tl1 "
14208 "f - 'Float_t' 0 - alpha1 f - 'Float_t' 0 - h2 "
14209 "f - 'Float_t' 0 - bl2 f - 'Float_t' 0 - tl2 "
14210 "f - 'Float_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
14211 G__memfunc_setup("GetTwist",827,G__G__G3D_151_0_4, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14212 G__memfunc_setup("GetH1",409,G__G__G3D_151_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14213 G__memfunc_setup("GetBl1",511,G__G__G3D_151_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14214 G__memfunc_setup("GetTl1",529,G__G__G3D_151_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14215 G__memfunc_setup("GetAlpha1",823,G__G__G3D_151_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14216 G__memfunc_setup("GetH2",410,G__G__G3D_151_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14217 G__memfunc_setup("GetBl2",512,G__G__G3D_151_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14218 G__memfunc_setup("GetTl2",530,G__G__G3D_151_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14219 G__memfunc_setup("GetAlpha2",824,G__G__G3D_151_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14220 G__memfunc_setup("Class",502,G__G__G3D_151_0_13, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGTRA::Class) ), 0);
14221 G__memfunc_setup("Class_Name",982,G__G__G3D_151_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTRA::Class_Name) ), 0);
14222 G__memfunc_setup("Class_Version",1339,G__G__G3D_151_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGTRA::Class_Version) ), 0);
14223 G__memfunc_setup("Dictionary",1046,G__G__G3D_151_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGTRA::Dictionary) ), 0);
14224 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14225 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14226 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14227 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_151_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14228 G__memfunc_setup("DeclFileName",1145,G__G__G3D_151_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTRA::DeclFileName) ), 0);
14229 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_151_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTRA::ImplFileLine) ), 0);
14230 G__memfunc_setup("ImplFileName",1171,G__G__G3D_151_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGTRA::ImplFileName) ), 0);
14231 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_151_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGTRA::DeclFileLine) ), 0);
14232
14233 G__memfunc_setup("TGTRA", 386, G__G__G3D_151_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TGTRA), -1, 0, 1, 1, 1, 0, "u 'TGTRA' - 11 - -", (char*) NULL, (void*) NULL, 0);
14234
14235 G__memfunc_setup("~TGTRA", 512, G__G__G3D_151_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14236
14237 G__memfunc_setup("operator=", 937, G__G__G3D_151_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TGTRA), -1, 1, 1, 1, 1, 0, "u 'TGTRA' - 11 - -", (char*) NULL, (void*) NULL, 0);
14238 G__tag_memfunc_reset();
14239 }
14240
14241 static void G__setup_memfuncTPolyLine3D(void) {
14242
14243 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D));
14244 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14245 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 2, 1, 1, 0,
14246 "i - 'Int_t' 0 - n C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14247 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 3, 1, 1, 0,
14248 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14249 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14250 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 3, 1, 1, 0,
14251 "i - 'Int_t' 0 - n D - 'Double_t' 0 - p "
14252 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14253 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 5, 1, 1, 0,
14254 "i - 'Int_t' 0 - n F - 'Float_t' 0 - x "
14255 "F - 'Float_t' 0 - y F - 'Float_t' 0 - z "
14256 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14257 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 5, 1, 1, 0,
14258 "i - 'Int_t' 0 - n D - 'Double_t' 0 - x "
14259 "D - 'Double_t' 0 - y D - 'Double_t' 0 - z "
14260 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14261 G__memfunc_setup("TPolyLine3D",1015,G__G__G3D_152_0_7, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 0, 1, 1, 1, 0, "u 'TPolyLine3D' - 11 - polylin", (char*)NULL, (void*) NULL, 0);
14262 G__memfunc_setup("operator=",937,G__G__G3D_152_0_8, 117, G__get_linked_tagnum(&G__G__G3DLN_TPolyLine3D), -1, 1, 1, 1, 1, 0, "u 'TPolyLine3D' - 11 - polylin", (char*)NULL, (void*) NULL, 0);
14263 G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - polyline", (char*)NULL, (void*) NULL, 1);
14264 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14265 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14266 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14267 G__memfunc_setup("DrawPolyLine",1210,G__G__G3D_152_0_12, 121, -1, -1, 0, 3, 1, 1, 0,
14268 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14269 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14270 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14271 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
14272 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14273 G__memfunc_setup("GetLastPoint",1214,G__G__G3D_152_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14274 G__memfunc_setup("GetN",366,G__G__G3D_152_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14275 G__memfunc_setup("GetP",368,G__G__G3D_152_0_16, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14276 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14277 G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14278 G__memfunc_setup("Merge",496,G__G__G3D_152_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
14279 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14280 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14281 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14282 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14283 G__memfunc_setup("SetNextPoint",1237,G__G__G3D_152_0_23, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
14284 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14285 "d - 'Double_t' 0 - z", "*MENU*", (void*) NULL, 1);
14286 G__memfunc_setup("SetOption",933,G__G__G3D_152_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14287 G__memfunc_setup("SetPoint",822,G__G__G3D_152_0_25, 121, -1, -1, 0, 4, 1, 1, 0,
14288 "i - 'Int_t' 0 - point d - 'Double_t' 0 - x "
14289 "d - 'Double_t' 0 - y d - 'Double_t' 0 - z", "*MENU*", (void*) NULL, 1);
14290 G__memfunc_setup("SetPolyLine",1112,G__G__G3D_152_0_26, 121, -1, -1, 0, 2, 1, 1, 0,
14291 "i - 'Int_t' 0 - n C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14292 G__memfunc_setup("SetPolyLine",1112,G__G__G3D_152_0_27, 121, -1, -1, 0, 3, 1, 1, 0,
14293 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14294 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14295 G__memfunc_setup("SetPolyLine",1112,G__G__G3D_152_0_28, 121, -1, -1, 0, 3, 1, 1, 0,
14296 "i - 'Int_t' 0 - n D - 'Double_t' 0 - p "
14297 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14298 G__memfunc_setup("Size",411,G__G__G3D_152_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14299 G__memfunc_setup("DrawOutlineCube",1517,G__G__G3D_152_0_30, 121, -1, -1, 0, 3, 3, 1, 0,
14300 "U 'TList' - 0 - outline D - 'Double_t' 0 - rmin "
14301 "D - 'Double_t' 0 - rmax", (char*)NULL, (void*) G__func2void( (void (*)(TList*, Double_t*, Double_t*))(&TPolyLine3D::DrawOutlineCube) ), 0);
14302 G__memfunc_setup("Class",502,G__G__G3D_152_0_31, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPolyLine3D::Class) ), 0);
14303 G__memfunc_setup("Class_Name",982,G__G__G3D_152_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLine3D::Class_Name) ), 0);
14304 G__memfunc_setup("Class_Version",1339,G__G__G3D_152_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPolyLine3D::Class_Version) ), 0);
14305 G__memfunc_setup("Dictionary",1046,G__G__G3D_152_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPolyLine3D::Dictionary) ), 0);
14306 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14307 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14308 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14309 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_152_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14310 G__memfunc_setup("DeclFileName",1145,G__G__G3D_152_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLine3D::DeclFileName) ), 0);
14311 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_152_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyLine3D::ImplFileLine) ), 0);
14312 G__memfunc_setup("ImplFileName",1171,G__G__G3D_152_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyLine3D::ImplFileName) ), 0);
14313 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_152_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyLine3D::DeclFileLine) ), 0);
14314
14315 G__memfunc_setup("~TPolyLine3D", 1141, G__G__G3D_152_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14316 G__tag_memfunc_reset();
14317 }
14318
14319 static void G__setup_memfuncTHelix(void) {
14320
14321 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_THelix));
14322 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_THelix), -1, 1, 1, 1, 2, 0, "u 'THelix' - 11 - -", (char*)NULL, (void*) NULL, 0);
14323 G__memfunc_setup("SetRotMatrix",1238,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Set rotation matrix", (void*) NULL, 0);
14324 G__memfunc_setup("FindClosestPhase",1615,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0,
14325 "d - 'Double_t' 0 - phi0 d - 'Double_t' 0 - cosine", (char*)NULL, (void*) NULL, 0);
14326 G__memfunc_setup("THelix",590,G__G__G3D_155_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_THelix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14327 G__memfunc_setup("THelix",590,G__G__G3D_155_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_THelix), -1, 0, 7, 1, 1, 0,
14328 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14329 "d - 'Double_t' 0 - z d - 'Double_t' 0 - vx "
14330 "d - 'Double_t' 0 - vy d - 'Double_t' 0 - vz "
14331 "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
14332 G__memfunc_setup("THelix",590,G__G__G3D_155_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_THelix), -1, 0, 6, 1, 1, 0,
14333 "D - 'Double_t' 0 - xyz D - 'Double_t' 0 - v "
14334 "d - 'Double_t' 0 - w D - 'Double_t' 0 '0' range "
14335 "i 'EHelixRangeType' - 0 'kHelixZ' rtype D - 'Double_t' 0 '0' axis", (char*)NULL, (void*) NULL, 0);
14336 G__memfunc_setup("THelix",590,G__G__G3D_155_0_7, 105, G__get_linked_tagnum(&G__G__G3DLN_THelix), -1, 0, 1, 1, 1, 0, "u 'THelix' - 11 - helix", (char*)NULL, (void*) NULL, 0);
14337 G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - helix", (char*)NULL, (void*) NULL, 1);
14338 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14339 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14340 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14341 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14342 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14343 G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14344 G__memfunc_setup("SetAxis",705,G__G__G3D_155_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - axis", "Define new axis", (void*) NULL, 1);
14345 G__memfunc_setup("SetAxis",705,G__G__G3D_155_0_15, 121, -1, -1, 0, 3, 1, 1, 0,
14346 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14347 "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14348 G__memfunc_setup("SetRange",793,G__G__G3D_155_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
14349 "D - 'Double_t' 0 - range i 'EHelixRangeType' - 0 'kHelixZ' rtype", (char*)NULL, (void*) NULL, 1);
14350 G__memfunc_setup("SetRange",793,G__G__G3D_155_0_17, 121, -1, -1, 0, 3, 1, 1, 0,
14351 "d - 'Double_t' 0 - r1 d - 'Double_t' 0 - r2 "
14352 "i 'EHelixRangeType' - 0 'kHelixZ' rtype", (char*)NULL, (void*) NULL, 1);
14353 G__memfunc_setup("SetHelix",806,G__G__G3D_155_0_18, 121, -1, -1, 0, 6, 1, 1, 0,
14354 "D - 'Double_t' 0 - xyz D - 'Double_t' 0 - v "
14355 "d - 'Double_t' 0 - w D - 'Double_t' 0 '0' range "
14356 "i 'EHelixRangeType' - 0 'kUnchanged' type D - 'Double_t' 0 '0' axis", (char*)NULL, (void*) NULL, 0);
14357 G__memfunc_setup("Class",502,G__G__G3D_155_0_19, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THelix::Class) ), 0);
14358 G__memfunc_setup("Class_Name",982,G__G__G3D_155_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THelix::Class_Name) ), 0);
14359 G__memfunc_setup("Class_Version",1339,G__G__G3D_155_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THelix::Class_Version) ), 0);
14360 G__memfunc_setup("Dictionary",1046,G__G__G3D_155_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THelix::Dictionary) ), 0);
14361 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14362 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14363 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14364 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_155_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14365 G__memfunc_setup("DeclFileName",1145,G__G__G3D_155_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THelix::DeclFileName) ), 0);
14366 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_155_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THelix::ImplFileLine) ), 0);
14367 G__memfunc_setup("ImplFileName",1171,G__G__G3D_155_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THelix::ImplFileName) ), 0);
14368 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_155_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THelix::DeclFileLine) ), 0);
14369
14370 G__memfunc_setup("~THelix", 716, G__G__G3D_155_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14371 G__tag_memfunc_reset();
14372 }
14373
14374 static void G__setup_memfuncTHYPE(void) {
14375
14376 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_THYPE));
14377 G__memfunc_setup("THYPE",394,G__G__G3D_156_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_THYPE), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14378 G__memfunc_setup("THYPE",394,G__G__G3D_156_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_THYPE), -1, 0, 7, 1, 1, 0,
14379 "C - - 10 - name C - - 10 - title "
14380 "C - - 10 - material f - 'Float_t' 0 - rmin "
14381 "f - 'Float_t' 0 - rmax f - 'Float_t' 0 - dz "
14382 "f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
14383 G__memfunc_setup("GetPhi",577,G__G__G3D_156_0_3, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14384 G__memfunc_setup("Class",502,G__G__G3D_156_0_4, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THYPE::Class) ), 0);
14385 G__memfunc_setup("Class_Name",982,G__G__G3D_156_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THYPE::Class_Name) ), 0);
14386 G__memfunc_setup("Class_Version",1339,G__G__G3D_156_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THYPE::Class_Version) ), 0);
14387 G__memfunc_setup("Dictionary",1046,G__G__G3D_156_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THYPE::Dictionary) ), 0);
14388 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14389 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14390 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14391 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_156_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14392 G__memfunc_setup("DeclFileName",1145,G__G__G3D_156_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THYPE::DeclFileName) ), 0);
14393 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_156_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THYPE::ImplFileLine) ), 0);
14394 G__memfunc_setup("ImplFileName",1171,G__G__G3D_156_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THYPE::ImplFileName) ), 0);
14395 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_156_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THYPE::DeclFileLine) ), 0);
14396
14397 G__memfunc_setup("THYPE", 394, G__G__G3D_156_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_THYPE), -1, 0, 1, 1, 1, 0, "u 'THYPE' - 11 - -", (char*) NULL, (void*) NULL, 0);
14398
14399 G__memfunc_setup("~THYPE", 520, G__G__G3D_156_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14400 G__tag_memfunc_reset();
14401 }
14402
14403 static void G__setup_memfuncTMarker3DBox(void) {
14404
14405 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox));
14406 G__memfunc_setup("TMarker3DBox",1110,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox), -1, 0, 1, 1, 2, 0, "u 'TMarker3DBox' - 11 - -", (char*)NULL, (void*) NULL, 0);
14407 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox), -1, 1, 1, 1, 2, 0, "u 'TMarker3DBox' - 11 - -", (char*)NULL, (void*) NULL, 0);
14408 G__memfunc_setup("TMarker3DBox",1110,G__G__G3D_158_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14409 G__memfunc_setup("TMarker3DBox",1110,G__G__G3D_158_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TMarker3DBox), -1, 0, 8, 1, 1, 0,
14410 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
14411 "f - 'Float_t' 0 - z f - 'Float_t' 0 - dx "
14412 "f - 'Float_t' 0 - dy f - 'Float_t' 0 - dz "
14413 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
14414 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14415 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14416 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14417 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
14418 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14419 G__memfunc_setup("GetRefObject",1172,G__G__G3D_158_0_7, 85, G__get_linked_tagnum(&G__G__G3DLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14420 G__memfunc_setup("GetDirection",1217,G__G__G3D_158_0_8, 121, -1, -1, 0, 2, 1, 1, 8,
14421 "f - 'Float_t' 1 - theta f - 'Float_t' 1 - phi", (char*)NULL, (void*) NULL, 1);
14422 G__memfunc_setup("GetPosition",1141,G__G__G3D_158_0_9, 121, -1, -1, 0, 3, 1, 1, 8,
14423 "f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
14424 "f - 'Float_t' 1 - z", (char*)NULL, (void*) NULL, 1);
14425 G__memfunc_setup("GetSize",699,G__G__G3D_158_0_10, 121, -1, -1, 0, 3, 1, 1, 8,
14426 "f - 'Float_t' 1 - dx f - 'Float_t' 1 - dy "
14427 "f - 'Float_t' 1 - dz", (char*)NULL, (void*) NULL, 1);
14428 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
14429 G__memfunc_setup("PaintH3",631,G__G__G3D_158_0_12, 121, -1, -1, 0, 2, 3, 1, 0,
14430 "U 'TH1' - 0 - h C - 'Option_t' 10 - option", (char*)NULL, (void*) G__func2void( (void (*)(TH1*, Option_t*))(&TMarker3DBox::PaintH3) ), 0);
14431 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14432 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14433 G__memfunc_setup("SetPoints",937,G__G__G3D_158_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - buff", (char*)NULL, (void*) NULL, 1);
14434 G__memfunc_setup("SetDirection",1229,G__G__G3D_158_0_15, 121, -1, -1, 0, 2, 1, 1, 0,
14435 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 1);
14436 G__memfunc_setup("SetPosition",1153,G__G__G3D_158_0_16, 121, -1, -1, 0, 3, 1, 1, 0,
14437 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
14438 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14439 G__memfunc_setup("SetSize",711,G__G__G3D_158_0_17, 121, -1, -1, 0, 3, 1, 1, 0,
14440 "f - 'Float_t' 0 - dx f - 'Float_t' 0 - dy "
14441 "f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 1);
14442 G__memfunc_setup("SetRefObject",1184,G__G__G3D_158_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 1);
14443 G__memfunc_setup("Class",502,G__G__G3D_158_0_19, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMarker3DBox::Class) ), 0);
14444 G__memfunc_setup("Class_Name",982,G__G__G3D_158_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMarker3DBox::Class_Name) ), 0);
14445 G__memfunc_setup("Class_Version",1339,G__G__G3D_158_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMarker3DBox::Class_Version) ), 0);
14446 G__memfunc_setup("Dictionary",1046,G__G__G3D_158_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMarker3DBox::Dictionary) ), 0);
14447 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14448 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14449 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14450 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_158_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14451 G__memfunc_setup("DeclFileName",1145,G__G__G3D_158_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMarker3DBox::DeclFileName) ), 0);
14452 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_158_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMarker3DBox::ImplFileLine) ), 0);
14453 G__memfunc_setup("ImplFileName",1171,G__G__G3D_158_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMarker3DBox::ImplFileName) ), 0);
14454 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_158_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMarker3DBox::DeclFileLine) ), 0);
14455
14456 G__memfunc_setup("~TMarker3DBox", 1236, G__G__G3D_158_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14457 G__tag_memfunc_reset();
14458 }
14459
14460 static void G__setup_memfuncTMixture(void) {
14461
14462 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TMixture));
14463 G__memfunc_setup("TMixture",834,G__G__G3D_160_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_TMixture), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14464 G__memfunc_setup("TMixture",834,G__G__G3D_160_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TMixture), -1, 0, 3, 1, 1, 0,
14465 "C - - 10 - name C - - 10 - title "
14466 "i - 'Int_t' 0 - nmixt", (char*)NULL, (void*) NULL, 0);
14467 G__memfunc_setup("DefineElement",1301,G__G__G3D_160_0_3, 121, -1, -1, 0, 4, 1, 1, 0,
14468 "i - 'Int_t' 0 - n f - 'Float_t' 0 - a "
14469 "f - 'Float_t' 0 - z f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 1);
14470 G__memfunc_setup("GetNmixt",816,G__G__G3D_160_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14471 G__memfunc_setup("GetAmixt",803,G__G__G3D_160_0_5, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14472 G__memfunc_setup("GetZmixt",828,G__G__G3D_160_0_6, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14473 G__memfunc_setup("GetWmixt",825,G__G__G3D_160_0_7, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14474 G__memfunc_setup("Class",502,G__G__G3D_160_0_8, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMixture::Class) ), 0);
14475 G__memfunc_setup("Class_Name",982,G__G__G3D_160_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMixture::Class_Name) ), 0);
14476 G__memfunc_setup("Class_Version",1339,G__G__G3D_160_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMixture::Class_Version) ), 0);
14477 G__memfunc_setup("Dictionary",1046,G__G__G3D_160_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMixture::Dictionary) ), 0);
14478 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14479 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14480 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14481 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_160_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14482 G__memfunc_setup("DeclFileName",1145,G__G__G3D_160_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMixture::DeclFileName) ), 0);
14483 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_160_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMixture::ImplFileLine) ), 0);
14484 G__memfunc_setup("ImplFileName",1171,G__G__G3D_160_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMixture::ImplFileName) ), 0);
14485 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_160_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMixture::DeclFileLine) ), 0);
14486
14487 G__memfunc_setup("TMixture", 834, G__G__G3D_160_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TMixture), -1, 0, 1, 1, 1, 0, "u 'TMixture' - 11 - -", (char*) NULL, (void*) NULL, 0);
14488
14489 G__memfunc_setup("~TMixture", 960, G__G__G3D_160_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14490
14491 G__memfunc_setup("operator=", 937, G__G__G3D_160_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TMixture), -1, 1, 1, 1, 1, 0, "u 'TMixture' - 11 - -", (char*) NULL, (void*) NULL, 0);
14492 G__tag_memfunc_reset();
14493 }
14494
14495 static void G__setup_memfuncTNodeDiv(void) {
14496
14497 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv));
14498 G__memfunc_setup("TNodeDiv",765,G__G__G3D_162_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14499 G__memfunc_setup("TNodeDiv",765,G__G__G3D_162_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv), -1, 0, 6, 1, 1, 0,
14500 "C - - 10 - name C - - 10 - title "
14501 "C - - 10 - shapename i - 'Int_t' 0 - ndiv "
14502 "i - 'Int_t' 0 - axis C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14503 G__memfunc_setup("TNodeDiv",765,G__G__G3D_162_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv), -1, 0, 6, 1, 1, 0,
14504 "C - - 10 - name C - - 10 - title "
14505 "U 'TShape' - 0 - shape i - 'Int_t' 0 - ndiv "
14506 "i - 'Int_t' 0 - axis C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14507 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14508 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14509 G__memfunc_setup("Class",502,G__G__G3D_162_0_6, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNodeDiv::Class) ), 0);
14510 G__memfunc_setup("Class_Name",982,G__G__G3D_162_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNodeDiv::Class_Name) ), 0);
14511 G__memfunc_setup("Class_Version",1339,G__G__G3D_162_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNodeDiv::Class_Version) ), 0);
14512 G__memfunc_setup("Dictionary",1046,G__G__G3D_162_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNodeDiv::Dictionary) ), 0);
14513 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14514 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14515 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14516 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_162_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14517 G__memfunc_setup("DeclFileName",1145,G__G__G3D_162_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNodeDiv::DeclFileName) ), 0);
14518 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_162_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNodeDiv::ImplFileLine) ), 0);
14519 G__memfunc_setup("ImplFileName",1171,G__G__G3D_162_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNodeDiv::ImplFileName) ), 0);
14520 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_162_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNodeDiv::DeclFileLine) ), 0);
14521
14522 G__memfunc_setup("TNodeDiv", 765, G__G__G3D_162_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TNodeDiv), -1, 0, 1, 1, 1, 0, "u 'TNodeDiv' - 11 - -", (char*) NULL, (void*) NULL, 0);
14523
14524 G__memfunc_setup("~TNodeDiv", 891, G__G__G3D_162_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14525 G__tag_memfunc_reset();
14526 }
14527
14528 static void G__setup_memfuncTPARA(void) {
14529
14530 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPARA));
14531 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14532 G__memfunc_setup("TPARA",376,G__G__G3D_163_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TPARA), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14533 G__memfunc_setup("TPARA",376,G__G__G3D_163_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TPARA), -1, 0, 9, 1, 1, 0,
14534 "C - - 10 - name C - - 10 - title "
14535 "C - - 10 - material f - 'Float_t' 0 - dx "
14536 "f - 'Float_t' 0 - dy f - 'Float_t' 0 - dz "
14537 "f - 'Float_t' 0 - alpha f - 'Float_t' 0 - theta "
14538 "f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
14539 G__memfunc_setup("GetAlpha",774,G__G__G3D_163_0_4, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14540 G__memfunc_setup("GetTheta",790,G__G__G3D_163_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14541 G__memfunc_setup("GetPhi",577,G__G__G3D_163_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14542 G__memfunc_setup("Class",502,G__G__G3D_163_0_7, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPARA::Class) ), 0);
14543 G__memfunc_setup("Class_Name",982,G__G__G3D_163_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPARA::Class_Name) ), 0);
14544 G__memfunc_setup("Class_Version",1339,G__G__G3D_163_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPARA::Class_Version) ), 0);
14545 G__memfunc_setup("Dictionary",1046,G__G__G3D_163_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPARA::Dictionary) ), 0);
14546 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14547 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14548 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14549 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_163_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14550 G__memfunc_setup("DeclFileName",1145,G__G__G3D_163_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPARA::DeclFileName) ), 0);
14551 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_163_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPARA::ImplFileLine) ), 0);
14552 G__memfunc_setup("ImplFileName",1171,G__G__G3D_163_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPARA::ImplFileName) ), 0);
14553 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_163_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPARA::DeclFileLine) ), 0);
14554
14555 G__memfunc_setup("TPARA", 376, G__G__G3D_163_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TPARA), -1, 0, 1, 1, 1, 0, "u 'TPARA' - 11 - -", (char*) NULL, (void*) NULL, 0);
14556
14557 G__memfunc_setup("~TPARA", 502, G__G__G3D_163_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14558
14559 G__memfunc_setup("operator=", 937, G__G__G3D_163_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TPARA), -1, 1, 1, 1, 1, 0, "u 'TPARA' - 11 - -", (char*) NULL, (void*) NULL, 0);
14560 G__tag_memfunc_reset();
14561 }
14562
14563 static void G__setup_memfuncTPCON(void) {
14564
14565 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPCON));
14566 G__memfunc_setup("TPCON",388,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__G3DLN_TPCON), -1, 0, 1, 1, 2, 0, "u 'TPCON' - 11 - -", (char*)NULL, (void*) NULL, 0);
14567 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TPCON), -1, 1, 1, 1, 2, 0, "u 'TPCON' - 11 - -", (char*)NULL, (void*) NULL, 0);
14568 G__memfunc_setup("MakeTableOfCoSin",1527,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", "Create the table of the fSiTab; fCoTab", (void*) NULL, 1);
14569 G__memfunc_setup("FillTableOfCoSin",1536,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8,
14570 "d - 'Double_t' 0 - phi d - 'Double_t' 0 - angstep "
14571 "i - 'Int_t' 0 - n", "Fill the table of cosin", (void*) NULL, 1);
14572 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14573 G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "u 'TBuffer3D' - 1 - buffer", (char*)NULL, (void*) NULL, 1);
14574 G__memfunc_setup("TPCON",388,G__G__G3D_164_0_7, 105, G__get_linked_tagnum(&G__G__G3DLN_TPCON), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14575 G__memfunc_setup("TPCON",388,G__G__G3D_164_0_8, 105, G__get_linked_tagnum(&G__G__G3DLN_TPCON), -1, 0, 6, 1, 1, 0,
14576 "C - - 10 - name C - - 10 - title "
14577 "C - - 10 - material f - 'Float_t' 0 - phi1 "
14578 "f - 'Float_t' 0 - dphi1 i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
14579 G__memfunc_setup("DefineSection",1312,G__G__G3D_164_0_9, 121, -1, -1, 0, 4, 1, 1, 0,
14580 "i - 'Int_t' 0 - secNum f - 'Float_t' 0 - z "
14581 "f - 'Float_t' 0 - rmin f - 'Float_t' 0 - rmax", (char*)NULL, (void*) NULL, 1);
14582 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14583 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14584 G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
14585 G__memfunc_setup("GetNumberOfDivisions",2038,G__G__G3D_164_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14586 G__memfunc_setup("GetPhi1",626,G__G__G3D_164_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14587 G__memfunc_setup("GetDhi1",614,G__G__G3D_164_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14588 G__memfunc_setup("GetNz",488,G__G__G3D_164_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14589 G__memfunc_setup("GetRmin",694,G__G__G3D_164_0_16, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14590 G__memfunc_setup("GetRmax",696,G__G__G3D_164_0_17, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14591 G__memfunc_setup("GetDz",478,G__G__G3D_164_0_18, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14592 G__memfunc_setup("GetNdiv",689,G__G__G3D_164_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14593 G__memfunc_setup("SetNumberOfDivisions",2050,G__G__G3D_164_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - p", (char*)NULL, (void*) NULL, 1);
14594 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14595 G__memfunc_setup("Class",502,G__G__G3D_164_0_22, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPCON::Class) ), 0);
14596 G__memfunc_setup("Class_Name",982,G__G__G3D_164_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPCON::Class_Name) ), 0);
14597 G__memfunc_setup("Class_Version",1339,G__G__G3D_164_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPCON::Class_Version) ), 0);
14598 G__memfunc_setup("Dictionary",1046,G__G__G3D_164_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPCON::Dictionary) ), 0);
14599 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14600 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14601 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14602 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_164_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14603 G__memfunc_setup("DeclFileName",1145,G__G__G3D_164_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPCON::DeclFileName) ), 0);
14604 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_164_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPCON::ImplFileLine) ), 0);
14605 G__memfunc_setup("ImplFileName",1171,G__G__G3D_164_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPCON::ImplFileName) ), 0);
14606 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_164_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPCON::DeclFileLine) ), 0);
14607
14608 G__memfunc_setup("~TPCON", 514, G__G__G3D_164_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14609 G__tag_memfunc_reset();
14610 }
14611
14612 static void G__setup_memfuncTPGON(void) {
14613
14614 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPGON));
14615 G__memfunc_setup("FillTableOfCoSin",1536,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8,
14616 "d - 'Double_t' 0 - phi d - 'Double_t' 0 - angstep "
14617 "i - 'Int_t' 0 - n", "Fill the table of cosin", (void*) NULL, 1);
14618 G__memfunc_setup("TPGON",392,G__G__G3D_165_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TPGON), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14619 G__memfunc_setup("TPGON",392,G__G__G3D_165_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TPGON), -1, 0, 7, 1, 1, 0,
14620 "C - - 10 - name C - - 10 - title "
14621 "C - - 10 - material f - 'Float_t' 0 - phi1 "
14622 "f - 'Float_t' 0 - dphi1 i - 'Int_t' 0 - npdv "
14623 "i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
14624 G__memfunc_setup("Class",502,G__G__G3D_165_0_4, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPGON::Class) ), 0);
14625 G__memfunc_setup("Class_Name",982,G__G__G3D_165_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPGON::Class_Name) ), 0);
14626 G__memfunc_setup("Class_Version",1339,G__G__G3D_165_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPGON::Class_Version) ), 0);
14627 G__memfunc_setup("Dictionary",1046,G__G__G3D_165_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPGON::Dictionary) ), 0);
14628 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14629 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14630 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14631 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_165_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14632 G__memfunc_setup("DeclFileName",1145,G__G__G3D_165_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPGON::DeclFileName) ), 0);
14633 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_165_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPGON::ImplFileLine) ), 0);
14634 G__memfunc_setup("ImplFileName",1171,G__G__G3D_165_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPGON::ImplFileName) ), 0);
14635 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_165_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPGON::DeclFileLine) ), 0);
14636
14637 G__memfunc_setup("TPGON", 392, G__G__G3D_165_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TPGON), -1, 0, 1, 1, 1, 0, "u 'TPGON' - 11 - -", (char*) NULL, (void*) NULL, 0);
14638
14639 G__memfunc_setup("~TPGON", 518, G__G__G3D_165_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14640 G__tag_memfunc_reset();
14641 }
14642
14643 static void G__setup_memfuncTPoints3DABC(void) {
14644
14645 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPoints3DABC));
14646 G__memfunc_setup("DistancetoLine",1430,G__G__G3D_166_0_2, 105, -1, G__defined_typename("Int_t"), 0, 7, 3, 1, 0,
14647 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py "
14648 "f - 'Float_t' 0 - x1 f - 'Float_t' 0 - y1 "
14649 "f - 'Float_t' 0 - x2 f - 'Float_t' 0 - y2 "
14650 "i - 'Int_t' 0 '1' lineWidth", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t, Int_t, Float_t, Float_t, Float_t, Float_t, Int_t))(&TPoints3DABC::DistancetoLine) ), 0);
14651 G__memfunc_setup("Add",265,G__G__G3D_166_0_3, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
14652 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
14653 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14654 G__memfunc_setup("AddLast",669,G__G__G3D_166_0_4, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
14655 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
14656 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14657 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14658 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
14659 G__memfunc_setup("GetLastPosition",1545,G__G__G3D_166_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
14660 G__memfunc_setup("GetN",366,G__G__G3D_166_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14661 G__memfunc_setup("GetP",368,G__G__G3D_166_0_8, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14662 G__memfunc_setup("GetX",376,G__G__G3D_166_0_9, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
14663 G__memfunc_setup("GetY",377,G__G__G3D_166_0_10, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
14664 G__memfunc_setup("GetZ",378,G__G__G3D_166_0_11, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
14665 G__memfunc_setup("GetXYZ",555,G__G__G3D_166_0_12, 70, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 8,
14666 "F - 'Float_t' 0 - xyz i - 'Int_t' 0 - idx "
14667 "i - 'Int_t' 0 '1' num", (char*)NULL, (void*) NULL, 1);
14668 G__memfunc_setup("GetXYZ",555,G__G__G3D_166_0_13, 70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 1, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
14669 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
14670 G__memfunc_setup("PaintPoints",1145,G__G__G3D_166_0_15, 121, -1, -1, 0, 3, 1, 1, 0,
14671 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14672 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
14673 G__memfunc_setup("SetLastPosition",1557,G__G__G3D_166_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
14674 G__memfunc_setup("SetNextPoint",1237,G__G__G3D_166_0_17, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
14675 "f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
14676 "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
14677 G__memfunc_setup("SetOption",933,G__G__G3D_166_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
14678 G__memfunc_setup("SetPoint",822,G__G__G3D_166_0_19, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0,
14679 "i - 'Int_t' 0 - point f - 'Float_t' 0 - x "
14680 "f - 'Float_t' 0 - y f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 3);
14681 G__memfunc_setup("SetPoints",937,G__G__G3D_166_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
14682 "i - 'Int_t' 0 - n F - 'Float_t' 0 '0' p "
14683 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
14684 G__memfunc_setup("Size",411,G__G__G3D_166_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
14685 G__memfunc_setup("Class",502,G__G__G3D_166_0_22, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPoints3DABC::Class) ), 0);
14686 G__memfunc_setup("Class_Name",982,G__G__G3D_166_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints3DABC::Class_Name) ), 0);
14687 G__memfunc_setup("Class_Version",1339,G__G__G3D_166_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPoints3DABC::Class_Version) ), 0);
14688 G__memfunc_setup("Dictionary",1046,G__G__G3D_166_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPoints3DABC::Dictionary) ), 0);
14689 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14690 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14691 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14692 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_166_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14693 G__memfunc_setup("DeclFileName",1145,G__G__G3D_166_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints3DABC::DeclFileName) ), 0);
14694 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_166_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPoints3DABC::ImplFileLine) ), 0);
14695 G__memfunc_setup("ImplFileName",1171,G__G__G3D_166_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPoints3DABC::ImplFileName) ), 0);
14696 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_166_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPoints3DABC::DeclFileLine) ), 0);
14697
14698 G__memfunc_setup("~TPoints3DABC", 1164, G__G__G3D_166_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14699
14700 G__memfunc_setup("operator=", 937, G__G__G3D_166_0_35, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TPoints3DABC), -1, 1, 1, 1, 1, 0, "u 'TPoints3DABC' - 11 - -", (char*) NULL, (void*) NULL, 0);
14701 G__tag_memfunc_reset();
14702 }
14703
14704 static void G__setup_memfuncTPolyMarker3D(void) {
14705
14706 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D));
14707 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D), -1, 1, 1, 1, 2, 0, "u 'TPolyMarker3D' - 11 - -", (char*)NULL, (void*) NULL, 0);
14708 G__memfunc_setup("TPolyMarker3D",1233,G__G__G3D_169_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14709 G__memfunc_setup("TPolyMarker3D",1233,G__G__G3D_169_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D), -1, 0, 3, 1, 1, 0,
14710 "i - 'Int_t' 0 - n s - 'Marker_t' 0 '1' marker "
14711 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14712 G__memfunc_setup("TPolyMarker3D",1233,G__G__G3D_169_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D), -1, 0, 4, 1, 1, 0,
14713 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14714 "s - 'Marker_t' 0 '1' marker C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14715 G__memfunc_setup("TPolyMarker3D",1233,G__G__G3D_169_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D), -1, 0, 4, 1, 1, 0,
14716 "i - 'Int_t' 0 - n D - 'Double_t' 0 - p "
14717 "s - 'Marker_t' 0 '1' marker C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
14718 G__memfunc_setup("TPolyMarker3D",1233,G__G__G3D_169_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_TPolyMarker3D), -1, 0, 1, 1, 1, 0, "u 'TPolyMarker3D' - 11 - p", (char*)NULL, (void*) NULL, 0);
14719 G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - polymarker", (char*)NULL, (void*) NULL, 1);
14720 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14721 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14722 G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14723 G__memfunc_setup("DrawPolyMarker",1428,G__G__G3D_169_0_10, 121, -1, -1, 0, 4, 1, 1, 0,
14724 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14725 "s - 'Marker_t' 0 - marker C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14726 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
14727 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
14728 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14729 G__memfunc_setup("GetLastPoint",1214,G__G__G3D_169_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14730 G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
14731 G__memfunc_setup("GetN",366,G__G__G3D_169_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14732 G__memfunc_setup("GetP",368,G__G__G3D_169_0_15, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14733 G__memfunc_setup("GetPoint",810,G__G__G3D_169_0_16, 121, -1, -1, 0, 4, 1, 1, 8,
14734 "i - 'Int_t' 0 - n f - 'Float_t' 1 - x "
14735 "f - 'Float_t' 1 - y f - 'Float_t' 1 - z", (char*)NULL, (void*) NULL, 1);
14736 G__memfunc_setup("GetPoint",810,G__G__G3D_169_0_17, 121, -1, -1, 0, 4, 1, 1, 8,
14737 "i - 'Int_t' 0 - n d - 'Double_t' 1 - x "
14738 "d - 'Double_t' 1 - y d - 'Double_t' 1 - z", (char*)NULL, (void*) NULL, 1);
14739 G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14740 G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14741 G__memfunc_setup("Merge",496,G__G__G3D_169_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
14742 G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14743 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14744 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14745 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14746 G__memfunc_setup("SetName",685,G__G__G3D_169_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
14747 G__memfunc_setup("SetPoint",822,G__G__G3D_169_0_25, 121, -1, -1, 0, 4, 1, 1, 0,
14748 "i - 'Int_t' 0 - n d - 'Double_t' 0 - x "
14749 "d - 'Double_t' 0 - y d - 'Double_t' 0 - z", "*MENU*", (void*) NULL, 0);
14750 G__memfunc_setup("SetPolyMarker",1330,G__G__G3D_169_0_26, 121, -1, -1, 0, 4, 1, 1, 0,
14751 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14752 "s - 'Marker_t' 0 - marker C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14753 G__memfunc_setup("SetPolyMarker",1330,G__G__G3D_169_0_27, 121, -1, -1, 0, 4, 1, 1, 0,
14754 "i - 'Int_t' 0 - n D - 'Double_t' 0 - p "
14755 "s - 'Marker_t' 0 - marker C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14756 G__memfunc_setup("SetNextPoint",1237,G__G__G3D_169_0_28, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0,
14757 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
14758 "d - 'Double_t' 0 - z", "*MENU*", (void*) NULL, 1);
14759 G__memfunc_setup("Size",411,G__G__G3D_169_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14760 G__memfunc_setup("PaintH3",631,G__G__G3D_169_0_30, 121, -1, -1, 0, 2, 3, 1, 0,
14761 "U 'TH1' - 0 - h C - 'Option_t' 10 - option", (char*)NULL, (void*) G__func2void( (void (*)(TH1*, Option_t*))(&TPolyMarker3D::PaintH3) ), 0);
14762 G__memfunc_setup("Class",502,G__G__G3D_169_0_31, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPolyMarker3D::Class) ), 0);
14763 G__memfunc_setup("Class_Name",982,G__G__G3D_169_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyMarker3D::Class_Name) ), 0);
14764 G__memfunc_setup("Class_Version",1339,G__G__G3D_169_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPolyMarker3D::Class_Version) ), 0);
14765 G__memfunc_setup("Dictionary",1046,G__G__G3D_169_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPolyMarker3D::Dictionary) ), 0);
14766 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14767 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14768 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14769 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_169_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14770 G__memfunc_setup("DeclFileName",1145,G__G__G3D_169_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyMarker3D::DeclFileName) ), 0);
14771 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_169_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyMarker3D::ImplFileLine) ), 0);
14772 G__memfunc_setup("ImplFileName",1171,G__G__G3D_169_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPolyMarker3D::ImplFileName) ), 0);
14773 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_169_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPolyMarker3D::DeclFileLine) ), 0);
14774
14775 G__memfunc_setup("~TPolyMarker3D", 1359, G__G__G3D_169_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14776 G__tag_memfunc_reset();
14777 }
14778
14779 static void G__setup_memfuncTPointSet3D(void) {
14780
14781 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D));
14782 G__memfunc_setup("CopyIds",699,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TPointSet3D' - 11 - t", (char*)NULL, (void*) NULL, 0);
14783 G__memfunc_setup("TPointSet3D",1025,G__G__G3D_176_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14784 G__memfunc_setup("TPointSet3D",1025,G__G__G3D_176_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D), -1, 0, 3, 1, 1, 0,
14785 "i - 'Int_t' 0 - n s - 'Marker_t' 0 '1' m "
14786 "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
14787 G__memfunc_setup("TPointSet3D",1025,G__G__G3D_176_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D), -1, 0, 4, 1, 1, 0,
14788 "i - 'Int_t' 0 - n F - 'Float_t' 0 - p "
14789 "s - 'Marker_t' 0 '1' m C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
14790 G__memfunc_setup("TPointSet3D",1025,G__G__G3D_176_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D), -1, 0, 4, 1, 1, 0,
14791 "i - 'Int_t' 0 - n D - 'Double_t' 0 - p "
14792 "s - 'Marker_t' 0 '1' m C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
14793 G__memfunc_setup("TPointSet3D",1025,G__G__G3D_176_0_6, 105, G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D), -1, 0, 1, 1, 1, 0, "u 'TPointSet3D' - 11 - t", (char*)NULL, (void*) NULL, 0);
14794 G__memfunc_setup("operator=",937,G__G__G3D_176_0_7, 117, G__get_linked_tagnum(&G__G__G3DLN_TPointSet3D), -1, 1, 1, 1, 1, 0, "u 'TPointSet3D' - 11 - t", (char*)NULL, (void*) NULL, 0);
14795 G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14796 G__memfunc_setup("SetPointId",995,G__G__G3D_176_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
14797 G__memfunc_setup("SetPointId",995,G__G__G3D_176_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
14798 "i - 'Int_t' 0 - n U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
14799 G__memfunc_setup("GetPointId",983,G__G__G3D_176_0_11, 85, G__get_linked_tagnum(&G__G__G3DLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
14800 G__memfunc_setup("ClearIds",775,G__G__G3D_176_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14801 G__memfunc_setup("GetOwnIds",884,G__G__G3D_176_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14802 G__memfunc_setup("SetOwnIds",896,G__G__G3D_176_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - o", (char*)NULL, (void*) NULL, 0);
14803 G__memfunc_setup("PointSelected",1331,G__G__G3D_176_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
14804 G__memfunc_setup("Class",502,G__G__G3D_176_0_16, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPointSet3D::Class) ), 0);
14805 G__memfunc_setup("Class_Name",982,G__G__G3D_176_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointSet3D::Class_Name) ), 0);
14806 G__memfunc_setup("Class_Version",1339,G__G__G3D_176_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPointSet3D::Class_Version) ), 0);
14807 G__memfunc_setup("Dictionary",1046,G__G__G3D_176_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPointSet3D::Dictionary) ), 0);
14808 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14809 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14810 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14811 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_176_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14812 G__memfunc_setup("DeclFileName",1145,G__G__G3D_176_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointSet3D::DeclFileName) ), 0);
14813 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_176_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPointSet3D::ImplFileLine) ), 0);
14814 G__memfunc_setup("ImplFileName",1171,G__G__G3D_176_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPointSet3D::ImplFileName) ), 0);
14815 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_176_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPointSet3D::DeclFileLine) ), 0);
14816
14817 G__memfunc_setup("~TPointSet3D", 1151, G__G__G3D_176_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14818 G__tag_memfunc_reset();
14819 }
14820
14821 static void G__setup_memfuncTSPHE(void) {
14822
14823 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TSPHE));
14824 G__memfunc_setup("MakeTableOfCoSin",1527,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", "Create the table of the fSiTab; fCoTab", (void*) NULL, 1);
14825 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14826 G__memfunc_setup("TSPHE",388,G__G__G3D_177_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TSPHE), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14827 G__memfunc_setup("TSPHE",388,G__G__G3D_177_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TSPHE), -1, 0, 9, 1, 1, 0,
14828 "C - - 10 - name C - - 10 - title "
14829 "C - - 10 - material f - 'Float_t' 0 - rmin "
14830 "f - 'Float_t' 0 - rmax f - 'Float_t' 0 - themin "
14831 "f - 'Float_t' 0 - themax f - 'Float_t' 0 - phimin "
14832 "f - 'Float_t' 0 - phimax", (char*)NULL, (void*) NULL, 0);
14833 G__memfunc_setup("TSPHE",388,G__G__G3D_177_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TSPHE), -1, 0, 4, 1, 1, 0,
14834 "C - - 10 - name C - - 10 - title "
14835 "C - - 10 - material f - 'Float_t' 0 - rmax", (char*)NULL, (void*) NULL, 0);
14836 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
14837 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
14838 G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - reqSections", (char*)NULL, (void*) NULL, 1);
14839 G__memfunc_setup("GetRmin",694,G__G__G3D_177_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14840 G__memfunc_setup("GetRmax",696,G__G__G3D_177_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14841 G__memfunc_setup("GetThemin",901,G__G__G3D_177_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14842 G__memfunc_setup("GetThemax",903,G__G__G3D_177_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14843 G__memfunc_setup("GetPhimin",901,G__G__G3D_177_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14844 G__memfunc_setup("GetPhimax",903,G__G__G3D_177_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14845 G__memfunc_setup("GetAspectRatio",1407,G__G__G3D_177_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14846 G__memfunc_setup("GetNumberOfDivisions",2038,G__G__G3D_177_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14847 G__memfunc_setup("SetAspectRatio",1419,G__G__G3D_177_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '1.0' factor", (char*)NULL, (void*) NULL, 1);
14848 G__memfunc_setup("SetEllipse",1018,G__G__G3D_177_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - factors", (char*)NULL, (void*) NULL, 1);
14849 G__memfunc_setup("SetNumberOfDivisions",2050,G__G__G3D_177_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - p", (char*)NULL, (void*) NULL, 1);
14850 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14851 G__memfunc_setup("Class",502,G__G__G3D_177_0_20, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSPHE::Class) ), 0);
14852 G__memfunc_setup("Class_Name",982,G__G__G3D_177_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSPHE::Class_Name) ), 0);
14853 G__memfunc_setup("Class_Version",1339,G__G__G3D_177_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSPHE::Class_Version) ), 0);
14854 G__memfunc_setup("Dictionary",1046,G__G__G3D_177_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSPHE::Dictionary) ), 0);
14855 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14856 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14857 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14858 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_177_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14859 G__memfunc_setup("DeclFileName",1145,G__G__G3D_177_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSPHE::DeclFileName) ), 0);
14860 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_177_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSPHE::ImplFileLine) ), 0);
14861 G__memfunc_setup("ImplFileName",1171,G__G__G3D_177_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSPHE::ImplFileName) ), 0);
14862 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_177_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSPHE::DeclFileLine) ), 0);
14863
14864 G__memfunc_setup("TSPHE", 388, G__G__G3D_177_0_32, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TSPHE), -1, 0, 1, 1, 1, 0, "u 'TSPHE' - 11 - -", (char*) NULL, (void*) NULL, 0);
14865
14866 G__memfunc_setup("~TSPHE", 514, G__G__G3D_177_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14867
14868 G__memfunc_setup("operator=", 937, G__G__G3D_177_0_34, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TSPHE), -1, 1, 1, 1, 1, 0, "u 'TSPHE' - 11 - -", (char*) NULL, (void*) NULL, 0);
14869 G__tag_memfunc_reset();
14870 }
14871
14872 static void G__setup_memfuncTTRAP(void) {
14873
14874 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRAP));
14875 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14876 G__memfunc_setup("TTRAP",395,G__G__G3D_178_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TTRAP), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14877 G__memfunc_setup("TTRAP",395,G__G__G3D_178_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TTRAP), -1, 0, 14, 1, 1, 0,
14878 "C - - 10 - name C - - 10 - title "
14879 "C - - 10 - material f - 'Float_t' 0 - dz "
14880 "f - 'Float_t' 0 - theta f - 'Float_t' 0 - phi "
14881 "f - 'Float_t' 0 - h1 f - 'Float_t' 0 - bl1 "
14882 "f - 'Float_t' 0 - tl1 f - 'Float_t' 0 - alpha1 "
14883 "f - 'Float_t' 0 - h2 f - 'Float_t' 0 - bl2 "
14884 "f - 'Float_t' 0 - tl2 f - 'Float_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
14885 G__memfunc_setup("GetH1",409,G__G__G3D_178_0_4, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14886 G__memfunc_setup("GetBl1",511,G__G__G3D_178_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14887 G__memfunc_setup("GetTl1",529,G__G__G3D_178_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14888 G__memfunc_setup("GetAlpha1",823,G__G__G3D_178_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14889 G__memfunc_setup("GetH2",410,G__G__G3D_178_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14890 G__memfunc_setup("GetBl2",512,G__G__G3D_178_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14891 G__memfunc_setup("GetTl2",530,G__G__G3D_178_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14892 G__memfunc_setup("GetAlpha2",824,G__G__G3D_178_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14893 G__memfunc_setup("Class",502,G__G__G3D_178_0_12, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTRAP::Class) ), 0);
14894 G__memfunc_setup("Class_Name",982,G__G__G3D_178_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRAP::Class_Name) ), 0);
14895 G__memfunc_setup("Class_Version",1339,G__G__G3D_178_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTRAP::Class_Version) ), 0);
14896 G__memfunc_setup("Dictionary",1046,G__G__G3D_178_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTRAP::Dictionary) ), 0);
14897 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14898 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14899 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14900 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_178_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14901 G__memfunc_setup("DeclFileName",1145,G__G__G3D_178_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRAP::DeclFileName) ), 0);
14902 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_178_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTRAP::ImplFileLine) ), 0);
14903 G__memfunc_setup("ImplFileName",1171,G__G__G3D_178_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRAP::ImplFileName) ), 0);
14904 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_178_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTRAP::DeclFileLine) ), 0);
14905
14906 G__memfunc_setup("TTRAP", 395, G__G__G3D_178_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TTRAP), -1, 0, 1, 1, 1, 0, "u 'TTRAP' - 11 - -", (char*) NULL, (void*) NULL, 0);
14907
14908 G__memfunc_setup("~TTRAP", 521, G__G__G3D_178_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14909
14910 G__memfunc_setup("operator=", 937, G__G__G3D_178_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TTRAP), -1, 1, 1, 1, 1, 0, "u 'TTRAP' - 11 - -", (char*) NULL, (void*) NULL, 0);
14911 G__tag_memfunc_reset();
14912 }
14913
14914 static void G__setup_memfuncTTRD1(void) {
14915
14916 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD1));
14917 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14918 G__memfunc_setup("TTRD1",367,G__G__G3D_179_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TTRD1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14919 G__memfunc_setup("TTRD1",367,G__G__G3D_179_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TTRD1), -1, 0, 7, 1, 1, 0,
14920 "C - - 10 - name C - - 10 - title "
14921 "C - - 10 - material f - 'Float_t' 0 - dx1 "
14922 "f - 'Float_t' 0 - dx2 f - 'Float_t' 0 - dy "
14923 "f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
14924 G__memfunc_setup("GetDx2",526,G__G__G3D_179_0_4, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14925 G__memfunc_setup("Class",502,G__G__G3D_179_0_5, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTRD1::Class) ), 0);
14926 G__memfunc_setup("Class_Name",982,G__G__G3D_179_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRD1::Class_Name) ), 0);
14927 G__memfunc_setup("Class_Version",1339,G__G__G3D_179_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTRD1::Class_Version) ), 0);
14928 G__memfunc_setup("Dictionary",1046,G__G__G3D_179_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTRD1::Dictionary) ), 0);
14929 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14930 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14931 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14932 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_179_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14933 G__memfunc_setup("DeclFileName",1145,G__G__G3D_179_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRD1::DeclFileName) ), 0);
14934 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_179_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTRD1::ImplFileLine) ), 0);
14935 G__memfunc_setup("ImplFileName",1171,G__G__G3D_179_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRD1::ImplFileName) ), 0);
14936 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_179_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTRD1::DeclFileLine) ), 0);
14937
14938 G__memfunc_setup("TTRD1", 367, G__G__G3D_179_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TTRD1), -1, 0, 1, 1, 1, 0, "u 'TTRD1' - 11 - -", (char*) NULL, (void*) NULL, 0);
14939
14940 G__memfunc_setup("~TTRD1", 493, G__G__G3D_179_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14941
14942 G__memfunc_setup("operator=", 937, G__G__G3D_179_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TTRD1), -1, 1, 1, 1, 1, 0, "u 'TTRD1' - 11 - -", (char*) NULL, (void*) NULL, 0);
14943 G__tag_memfunc_reset();
14944 }
14945
14946 static void G__setup_memfuncTTRD2(void) {
14947
14948 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TTRD2));
14949 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
14950 G__memfunc_setup("TTRD2",368,G__G__G3D_180_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TTRD2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14951 G__memfunc_setup("TTRD2",368,G__G__G3D_180_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TTRD2), -1, 0, 8, 1, 1, 0,
14952 "C - - 10 - name C - - 10 - title "
14953 "C - - 10 - material f - 'Float_t' 0 - dx1 "
14954 "f - 'Float_t' 0 - dx2 f - 'Float_t' 0 - dy1 "
14955 "f - 'Float_t' 0 - dy2 f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
14956 G__memfunc_setup("GetDx2",526,G__G__G3D_180_0_4, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14957 G__memfunc_setup("GetDy2",527,G__G__G3D_180_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14958 G__memfunc_setup("Class",502,G__G__G3D_180_0_6, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTRD2::Class) ), 0);
14959 G__memfunc_setup("Class_Name",982,G__G__G3D_180_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRD2::Class_Name) ), 0);
14960 G__memfunc_setup("Class_Version",1339,G__G__G3D_180_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTRD2::Class_Version) ), 0);
14961 G__memfunc_setup("Dictionary",1046,G__G__G3D_180_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTRD2::Dictionary) ), 0);
14962 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14963 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14964 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14965 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_180_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14966 G__memfunc_setup("DeclFileName",1145,G__G__G3D_180_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRD2::DeclFileName) ), 0);
14967 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_180_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTRD2::ImplFileLine) ), 0);
14968 G__memfunc_setup("ImplFileName",1171,G__G__G3D_180_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTRD2::ImplFileName) ), 0);
14969 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_180_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTRD2::DeclFileLine) ), 0);
14970
14971 G__memfunc_setup("TTRD2", 368, G__G__G3D_180_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__G3DLN_TTRD2), -1, 0, 1, 1, 1, 0, "u 'TTRD2' - 11 - -", (char*) NULL, (void*) NULL, 0);
14972
14973 G__memfunc_setup("~TTRD2", 494, G__G__G3D_180_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14974
14975 G__memfunc_setup("operator=", 937, G__G__G3D_180_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__G3DLN_TTRD2), -1, 1, 1, 1, 1, 0, "u 'TTRD2' - 11 - -", (char*) NULL, (void*) NULL, 0);
14976 G__tag_memfunc_reset();
14977 }
14978
14979 static void G__setup_memfuncTView3D(void) {
14980
14981 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TView3D));
14982 G__memfunc_setup("TView3D",614,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__G3DLN_TView3D), -1, 0, 1, 1, 2, 0, "u 'TView3D' - 11 - -", "Not implemented", (void*) NULL, 0);
14983 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__G3DLN_TView3D), -1, 1, 1, 1, 2, 0, "u 'TView3D' - 11 - -", "Not implemented", (void*) NULL, 0);
14984 G__memfunc_setup("ResetView",926,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0,
14985 "d - 'Double_t' 0 - longitude d - 'Double_t' 0 - latitude "
14986 "d - 'Double_t' 0 - psi i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 0);
14987 G__memfunc_setup("TView3D",614,G__G__G3D_181_0_4, 105, G__get_linked_tagnum(&G__G__G3DLN_TView3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14988 G__memfunc_setup("TView3D",614,G__G__G3D_181_0_5, 105, G__get_linked_tagnum(&G__G__G3DLN_TView3D), -1, 0, 3, 1, 1, 0,
14989 "i - 'Int_t' 0 - system D - 'Double_t' 10 - rmin "
14990 "D - 'Double_t' 10 - rmax", (char*)NULL, (void*) NULL, 0);
14991 G__memfunc_setup("AxisVertex",1043,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0,
14992 "d - 'Double_t' 0 - ang D - 'Double_t' 0 - av "
14993 "i - 'Int_t' 1 - ix1 i - 'Int_t' 1 - ix2 "
14994 "i - 'Int_t' 1 - iy1 i - 'Int_t' 1 - iy2 "
14995 "i - 'Int_t' 1 - iz1 i - 'Int_t' 1 - iz2", (char*)NULL, (void*) NULL, 1);
14996 G__memfunc_setup("DefinePerspectiveView",2160,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14997 G__memfunc_setup("DefineViewDirection",1927,(G__InterfaceMethod) NULL,121, -1, -1, 0, 10, 1, 1, 0,
14998 "D - 'Double_t' 10 - s D - 'Double_t' 10 - c "
14999 "d - 'Double_t' 0 - cosphi d - 'Double_t' 0 - sinphi "
15000 "d - 'Double_t' 0 - costhe d - 'Double_t' 0 - sinthe "
15001 "d - 'Double_t' 0 - cospsi d - 'Double_t' 0 - sinpsi "
15002 "D - 'Double_t' 0 - tnorm D - 'Double_t' 0 - tback", (char*)NULL, (void*) NULL, 1);
15003 G__memfunc_setup("DrawOutlineCube",1517,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15004 "U 'TList' - 0 - outline D - 'Double_t' 0 - rmin "
15005 "D - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 1);
15006 G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15007 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15008 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15009 G__memfunc_setup("ExecuteRotateView",1757,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15010 "i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
15011 "i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15012 G__memfunc_setup("FindScope",891,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15013 "D - 'Double_t' 0 - scale D - 'Double_t' 0 - center "
15014 "i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 1);
15015 G__memfunc_setup("GetDistancetoAxis",1731,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0,
15016 "i - 'Int_t' 0 - axis i - 'Int_t' 0 - px "
15017 "i - 'Int_t' 0 - py d - 'Double_t' 1 - ratio", (char*)NULL, (void*) NULL, 1);
15018 G__memfunc_setup("GetDview",799,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15019 G__memfunc_setup("GetDproj",799,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15020 G__memfunc_setup("GetExtent",920,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15021 G__memfunc_setup("GetAutoRange",1190,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15022 G__memfunc_setup("GetLatitude",1116,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15023 G__memfunc_setup("GetLongitude",1227,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15024 G__memfunc_setup("GetPsi",588,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15025 G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15026 "F - 'Float_t' 0 - min F - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 1);
15027 G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15028 "D - 'Double_t' 0 - min D - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 1);
15029 G__memfunc_setup("GetRmax",696,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15030 G__memfunc_setup("GetRmin",694,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15031 G__memfunc_setup("GetOutline",1024,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TSeqCollection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15032 G__memfunc_setup("GetTback",773,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15033 G__memfunc_setup("GetTN",450,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15034 G__memfunc_setup("GetTnorm",816,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15035 G__memfunc_setup("GetSystem",933,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15036 G__memfunc_setup("GetWindow",920,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8,
15037 "d - 'Double_t' 1 - u0 d - 'Double_t' 1 - v0 "
15038 "d - 'Double_t' 1 - du d - 'Double_t' 1 - dv", (char*)NULL, (void*) NULL, 1);
15039 G__memfunc_setup("GetWindowWidth",1432,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15040 G__memfunc_setup("GetWindowHeight",1521,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15041 G__memfunc_setup("FindNormal",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15042 "d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
15043 "d - 'Double_t' 0 - z d - 'Double_t' 1 - zn", (char*)NULL, (void*) NULL, 1);
15044 G__memfunc_setup("FindPhiSectors",1413,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0,
15045 "i - 'Int_t' 0 - iopt i - 'Int_t' 1 - kphi "
15046 "D - 'Double_t' 0 - aphi i - 'Int_t' 1 - iphi1 "
15047 "i - 'Int_t' 1 - iphi2", (char*)NULL, (void*) NULL, 1);
15048 G__memfunc_setup("FindThetaSectors",1626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0,
15049 "i - 'Int_t' 0 - iopt d - 'Double_t' 0 - phi "
15050 "i - 'Int_t' 1 - kth D - 'Double_t' 0 - ath "
15051 "i - 'Int_t' 1 - ith1 i - 'Int_t' 1 - ith2", (char*)NULL, (void*) NULL, 1);
15052 G__memfunc_setup("IsClippedNDC",1106,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 1);
15053 G__memfunc_setup("IsPerspective",1350,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15054 G__memfunc_setup("IsViewChanged",1281,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15055 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15056 "F - 'Float_t' 10 - pn F - 'Float_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15057 G__memfunc_setup("NDCtoWC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15058 "D - 'Double_t' 10 - pn D - 'Double_t' 0 - pw", (char*)NULL, (void*) NULL, 1);
15059 G__memfunc_setup("NormalWCtoNDC",1211,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15060 "F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15061 G__memfunc_setup("NormalWCtoNDC",1211,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15062 "D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15063 G__memfunc_setup("PadRange",770,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rback", (char*)NULL, (void*) NULL, 1);
15064 G__memfunc_setup("ResizePad",903,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15065 G__memfunc_setup("SetAutoRange",1202,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autorange", (char*)NULL, (void*) NULL, 1);
15066 G__memfunc_setup("SetAxisNDC",918,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0,
15067 "D - 'Double_t' 10 - x1 D - 'Double_t' 10 - x2 "
15068 "D - 'Double_t' 10 - y1 D - 'Double_t' 10 - y2 "
15069 "D - 'Double_t' 10 - z1 D - 'Double_t' 10 - z2", (char*)NULL, (void*) NULL, 1);
15070 G__memfunc_setup("SetDefaultWindow",1641,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15071 G__memfunc_setup("SetDview",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dview", (char*)NULL, (void*) NULL, 1);
15072 G__memfunc_setup("SetDproj",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dproj", (char*)NULL, (void*) NULL, 1);
15073 G__memfunc_setup("SetLatitude",1128,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - latitude", (char*)NULL, (void*) NULL, 1);
15074 G__memfunc_setup("SetLongitude",1239,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - longitude", (char*)NULL, (void*) NULL, 1);
15075 G__memfunc_setup("SetPsi",600,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - psi", (char*)NULL, (void*) NULL, 1);
15076 G__memfunc_setup("SetOutlineToCube",1614,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15077 G__memfunc_setup("SetParallel",1113,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15078 G__memfunc_setup("SetPerspective",1462,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15079 G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15080 "D - 'Double_t' 10 - min D - 'Double_t' 10 - max", (char*)NULL, (void*) NULL, 1);
15081 G__memfunc_setup("SetRange",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0,
15082 "d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
15083 "d - 'Double_t' 0 - z0 d - 'Double_t' 0 - x1 "
15084 "d - 'Double_t' 0 - y1 d - 'Double_t' 0 - z1 "
15085 "i - 'Int_t' 0 '0' flag", (char*)NULL, (void*) NULL, 1);
15086 G__memfunc_setup("SetSystem",945,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - system", (char*)NULL, (void*) NULL, 1);
15087 G__memfunc_setup("SetView",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15088 "d - 'Double_t' 0 - longitude d - 'Double_t' 0 - latitude "
15089 "d - 'Double_t' 0 - psi i - 'Int_t' 1 - irep", (char*)NULL, (void*) NULL, 1);
15090 G__memfunc_setup("SetViewChanged",1393,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
15091 G__memfunc_setup("SetWindow",932,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0,
15092 "d - 'Double_t' 0 - u0 d - 'Double_t' 0 - v0 "
15093 "d - 'Double_t' 0 - du d - 'Double_t' 0 - dv", (char*)NULL, (void*) NULL, 1);
15094 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15095 "F - 'Float_t' 10 - pw F - 'Float_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15096 G__memfunc_setup("WCtoNDC",594,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15097 "D - 'Double_t' 10 - pw D - 'Double_t' 0 - pn", (char*)NULL, (void*) NULL, 1);
15098 G__memfunc_setup("MoveFocus",919,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0,
15099 "D - 'Double_t' 0 - center d - 'Double_t' 0 - dx "
15100 "d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
15101 "i - 'Int_t' 0 '10' nsteps d - 'Double_t' 0 '0' dlong "
15102 "d - 'Double_t' 0 '0' dlat d - 'Double_t' 0 '0' dpsi", (char*)NULL, (void*) NULL, 1);
15103 G__memfunc_setup("MoveViewCommand",1521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15104 "c - 'Char_t' 0 - chCode i - 'Int_t' 0 '1' count", (char*)NULL, (void*) NULL, 1);
15105 G__memfunc_setup("MoveWindow",1039,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - option", (char*)NULL, (void*) NULL, 1);
15106 G__memfunc_setup("AdjustScales",1222,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", "*MENU*", (void*) NULL, 1);
15107 G__memfunc_setup("Centered3DImages",1527,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15108 G__memfunc_setup("Centered",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15109 G__memfunc_setup("FrontView",932,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15110 G__memfunc_setup("Front",521,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15111 G__memfunc_setup("ZoomIn",604,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15112 G__memfunc_setup("ZoomOut",733,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15113 G__memfunc_setup("ZoomView",832,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15114 "U 'TVirtualPad' - 0 '0' pad d - 'Double_t' 0 '1.25' zoomFactor", (char*)NULL, (void*) NULL, 1);
15115 G__memfunc_setup("UnzoomView",1059,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15116 "U 'TVirtualPad' - 0 '0' pad d - 'Double_t' 0 '1.25' unZoomFactor", (char*)NULL, (void*) NULL, 1);
15117 G__memfunc_setup("RotateView",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0,
15118 "d - 'Double_t' 0 - phi d - 'Double_t' 0 - theta "
15119 "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15120 G__memfunc_setup("SideView",800,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15121 G__memfunc_setup("Side",389,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15122 G__memfunc_setup("TopView",718,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15123 G__memfunc_setup("Top",307,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15124 G__memfunc_setup("ToggleRulers",1247,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15125 G__memfunc_setup("ShowAxis",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15126 G__memfunc_setup("ToggleZoom",1031,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) NULL, 1);
15127 G__memfunc_setup("ZoomMove",828,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15128 G__memfunc_setup("Zoom",421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15129 G__memfunc_setup("UnZoom",616,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
15130 G__memfunc_setup("AdjustPad",896,G__G__G3D_181_0_87, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualPad' - 0 '0' pad", (char*)NULL, (void*) G__func2void( (void (*)(TVirtualPad*))(&TView3D::AdjustPad) ), 0);
15131 G__memfunc_setup("Class",502,G__G__G3D_181_0_88, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TView3D::Class) ), 0);
15132 G__memfunc_setup("Class_Name",982,G__G__G3D_181_0_89, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TView3D::Class_Name) ), 0);
15133 G__memfunc_setup("Class_Version",1339,G__G__G3D_181_0_90, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TView3D::Class_Version) ), 0);
15134 G__memfunc_setup("Dictionary",1046,G__G__G3D_181_0_91, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TView3D::Dictionary) ), 0);
15135 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15136 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15137 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15138 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_181_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15139 G__memfunc_setup("DeclFileName",1145,G__G__G3D_181_0_96, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TView3D::DeclFileName) ), 0);
15140 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_181_0_97, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TView3D::ImplFileLine) ), 0);
15141 G__memfunc_setup("ImplFileName",1171,G__G__G3D_181_0_98, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TView3D::ImplFileName) ), 0);
15142 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_181_0_99, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TView3D::DeclFileLine) ), 0);
15143
15144 G__memfunc_setup("~TView3D", 740, G__G__G3D_181_0_100, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15145 G__tag_memfunc_reset();
15146 }
15147
15148 static void G__setup_memfuncTXTRU(void) {
15149
15150 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__G3DLN_TXTRU));
15151 G__memfunc_setup("TXTRU",423,G__G__G3D_183_0_1, 105, G__get_linked_tagnum(&G__G__G3DLN_TXTRU), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15152 G__memfunc_setup("TXTRU",423,G__G__G3D_183_0_2, 105, G__get_linked_tagnum(&G__G__G3DLN_TXTRU), -1, 0, 5, 1, 1, 0,
15153 "C - - 10 - name C - - 10 - title "
15154 "C - - 10 - material i - 'Int_t' 0 - nyx "
15155 "i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
15156 G__memfunc_setup("TXTRU",423,G__G__G3D_183_0_3, 105, G__get_linked_tagnum(&G__G__G3DLN_TXTRU), -1, 0, 1, 1, 1, 0, "u 'TXTRU' - 11 - xtru", (char*)NULL, (void*) NULL, 0);
15157 G__memfunc_setup("operator=",937,G__G__G3D_183_0_4, 117, G__get_linked_tagnum(&G__G__G3DLN_TXTRU), -1, 1, 1, 1, 1, 0, "u 'TXTRU' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
15158 G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TObject' - 1 - xtru", (char*)NULL, (void*) NULL, 1);
15159 G__memfunc_setup("DefineSection",1312,G__G__G3D_183_0_6, 121, -1, -1, 0, 5, 1, 1, 0,
15160 "i - 'Int_t' 0 - secNum f - 'Float_t' 0 - z "
15161 "f - 'Float_t' 0 '1.' scale f - 'Float_t' 0 '0.' x0 "
15162 "f - 'Float_t' 0 '0.' y0", (char*)NULL, (void*) NULL, 1);
15163 G__memfunc_setup("DefineVertex",1225,G__G__G3D_183_0_7, 121, -1, -1, 0, 3, 1, 1, 0,
15164 "i - 'Int_t' 0 - pointNum f - 'Float_t' 0 - x "
15165 "f - 'Float_t' 0 - y", (char*)NULL, (void*) NULL, 1);
15166 G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0,
15167 "i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
15168 G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__G3DLN_TBuffer3D), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
15169 G__memfunc_setup("GetNxy",607,G__G__G3D_183_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15170 G__memfunc_setup("GetNz",488,G__G__G3D_183_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15171 G__memfunc_setup("GetOutlinePointX",1634,G__G__G3D_183_0_12, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - pointNum", (char*)NULL, (void*) NULL, 1);
15172 G__memfunc_setup("GetOutlinePointY",1635,G__G__G3D_183_0_13, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - pointNum", (char*)NULL, (void*) NULL, 1);
15173 G__memfunc_setup("GetSectionX0",1149,G__G__G3D_183_0_14, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - secNum", (char*)NULL, (void*) NULL, 1);
15174 G__memfunc_setup("GetSectionY0",1150,G__G__G3D_183_0_15, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - secNum", (char*)NULL, (void*) NULL, 1);
15175 G__memfunc_setup("GetSectionScale",1501,G__G__G3D_183_0_16, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - secNum", (char*)NULL, (void*) NULL, 1);
15176 G__memfunc_setup("GetSectionZ",1103,G__G__G3D_183_0_17, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - secNum", (char*)NULL, (void*) NULL, 1);
15177 G__memfunc_setup("GetXvtx",730,G__G__G3D_183_0_18, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15178 G__memfunc_setup("GetYvtx",731,G__G__G3D_183_0_19, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15179 G__memfunc_setup("GetZ",378,G__G__G3D_183_0_20, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15180 G__memfunc_setup("GetScale",776,G__G__G3D_183_0_21, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15181 G__memfunc_setup("GetX0",424,G__G__G3D_183_0_22, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15182 G__memfunc_setup("GetY0",425,G__G__G3D_183_0_23, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15183 G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
15184 G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15185 G__memfunc_setup("SplitConcavePolygon",1971,G__G__G3D_183_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' split", (char*)NULL, (void*) NULL, 0);
15186 G__memfunc_setup("TruncateNxy",1157,G__G__G3D_183_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npts", (char*)NULL, (void*) NULL, 1);
15187 G__memfunc_setup("TruncateNz",1038,G__G__G3D_183_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npts", (char*)NULL, (void*) NULL, 1);
15188 G__memfunc_setup("CheckOrdering",1304,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15189 G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
15190 G__memfunc_setup("DumpPoints",1043,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8,
15191 "i - - 0 - npoints F - - 0 - pointbuff", (char*)NULL, (void*) NULL, 0);
15192 G__memfunc_setup("DumpSegments",1244,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8,
15193 "i - - 0 - nsegments I - - 0 - segbuff", (char*)NULL, (void*) NULL, 0);
15194 G__memfunc_setup("DumpPolygons",1265,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8,
15195 "i - - 0 - npolygons I - - 0 - polybuff "
15196 "i - - 0 - buffsize", (char*)NULL, (void*) NULL, 0);
15197 G__memfunc_setup("Class",502,G__G__G3D_183_0_34, 85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TXTRU::Class) ), 0);
15198 G__memfunc_setup("Class_Name",982,G__G__G3D_183_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TXTRU::Class_Name) ), 0);
15199 G__memfunc_setup("Class_Version",1339,G__G__G3D_183_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TXTRU::Class_Version) ), 0);
15200 G__memfunc_setup("Dictionary",1046,G__G__G3D_183_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TXTRU::Dictionary) ), 0);
15201 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__G3DLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15202 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15203 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15204 G__memfunc_setup("StreamerNVirtual",1656,G__G__G3D_183_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15205 G__memfunc_setup("DeclFileName",1145,G__G__G3D_183_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TXTRU::DeclFileName) ), 0);
15206 G__memfunc_setup("ImplFileLine",1178,G__G__G3D_183_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TXTRU::ImplFileLine) ), 0);
15207 G__memfunc_setup("ImplFileName",1171,G__G__G3D_183_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TXTRU::ImplFileName) ), 0);
15208 G__memfunc_setup("DeclFileLine",1152,G__G__G3D_183_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TXTRU::DeclFileLine) ), 0);
15209
15210 G__memfunc_setup("~TXTRU", 549, G__G__G3D_183_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15211 G__tag_memfunc_reset();
15212 }
15213
15214
15215
15216
15217
15218 extern "C" void G__cpp_setup_memfuncG__G3D() {
15219 }
15220
15221
15222
15223
15224 static void G__cpp_setup_global0() {
15225
15226
15227 G__resetplocal();
15228
15229 }
15230
15231 static void G__cpp_setup_global1() {
15232 }
15233
15234 static void G__cpp_setup_global2() {
15235 G__memvar_setup((void*)(&gGeometry),85,0,0,G__get_linked_tagnum(&G__G__G3DLN_TGeometry),-1,-1,1,"gGeometry=",0,(char*)NULL);
15236 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kHelixT=0",0,(char*)NULL);
15237 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kHelixX=1",0,(char*)NULL);
15238 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kHelixY=2",0,(char*)NULL);
15239 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kHelixZ=3",0,(char*)NULL);
15240 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kLabX=4",0,(char*)NULL);
15241 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kLabY=5",0,(char*)NULL);
15242 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kLabZ=6",0,(char*)NULL);
15243 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__G3DLN_EHelixRangeType),-1,-1,1,"kUnchanged=7",0,(char*)NULL);
15244
15245 G__resetglobalenv();
15246 }
15247 extern "C" void G__cpp_setup_globalG__G3D() {
15248 G__cpp_setup_global0();
15249 G__cpp_setup_global1();
15250 G__cpp_setup_global2();
15251 }
15252
15253
15254
15255
15256 static void G__cpp_setup_func0() {
15257 G__lastifuncposition();
15258
15259 }
15260
15261 static void G__cpp_setup_func1() {
15262 }
15263
15264 static void G__cpp_setup_func2() {
15265 }
15266
15267 static void G__cpp_setup_func3() {
15268
15269 G__resetifuncposition();
15270 }
15271
15272 extern "C" void G__cpp_setup_funcG__G3D() {
15273 G__cpp_setup_func0();
15274 G__cpp_setup_func1();
15275 G__cpp_setup_func2();
15276 G__cpp_setup_func3();
15277 }
15278
15279
15280
15281
15282
15283 G__linked_taginfo G__G__G3DLN_TClass = { "TClass" , 99 , -1 };
15284 G__linked_taginfo G__G__G3DLN_TBuffer = { "TBuffer" , 99 , -1 };
15285 G__linked_taginfo G__G__G3DLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
15286 G__linked_taginfo G__G__G3DLN_TObject = { "TObject" , 99 , -1 };
15287 G__linked_taginfo G__G__G3DLN_TNamed = { "TNamed" , 99 , -1 };
15288 G__linked_taginfo G__G__G3DLN_TString = { "TString" , 99 , -1 };
15289 G__linked_taginfo G__G__G3DLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
15290 G__linked_taginfo G__G__G3DLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
15291 G__linked_taginfo G__G__G3DLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
15292 G__linked_taginfo G__G__G3DLN_TList = { "TList" , 99 , -1 };
15293 G__linked_taginfo G__G__G3DLN_TBrowser = { "TBrowser" , 99 , -1 };
15294 G__linked_taginfo G__G__G3DLN_TObjArray = { "TObjArray" , 99 , -1 };
15295 G__linked_taginfo G__G__G3DLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
15296 G__linked_taginfo G__G__G3DLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
15297 G__linked_taginfo G__G__G3DLN_THashList = { "THashList" , 99 , -1 };
15298 G__linked_taginfo G__G__G3DLN_TAxis = { "TAxis" , 99 , -1 };
15299 G__linked_taginfo G__G__G3DLN_TGaxis = { "TGaxis" , 99 , -1 };
15300 G__linked_taginfo G__G__G3DLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
15301 G__linked_taginfo G__G__G3DLN_TView = { "TView" , 99 , -1 };
15302 G__linked_taginfo G__G__G3DLN_TAxis3D = { "TAxis3D" , 99 , -1 };
15303 G__linked_taginfo G__G__G3DLN_TAttFill = { "TAttFill" , 99 , -1 };
15304 G__linked_taginfo G__G__G3DLN_TMaterial = { "TMaterial" , 99 , -1 };
15305 G__linked_taginfo G__G__G3DLN_TAttLine = { "TAttLine" , 99 , -1 };
15306 G__linked_taginfo G__G__G3DLN_TAtt3D = { "TAtt3D" , 99 , -1 };
15307 G__linked_taginfo G__G__G3DLN_TBuffer3D = { "TBuffer3D" , 99 , -1 };
15308 G__linked_taginfo G__G__G3DLN_TNode = { "TNode" , 99 , -1 };
15309 G__linked_taginfo G__G__G3DLN_TShape = { "TShape" , 99 , -1 };
15310 G__linked_taginfo G__G__G3DLN_TBRIK = { "TBRIK" , 99 , -1 };
15311 G__linked_taginfo G__G__G3DLN_TTUBE = { "TTUBE" , 99 , -1 };
15312 G__linked_taginfo G__G__G3DLN_TCONE = { "TCONE" , 99 , -1 };
15313 G__linked_taginfo G__G__G3DLN_TTUBS = { "TTUBS" , 99 , -1 };
15314 G__linked_taginfo G__G__G3DLN_TCONS = { "TCONS" , 99 , -1 };
15315 G__linked_taginfo G__G__G3DLN_TCTUB = { "TCTUB" , 99 , -1 };
15316 G__linked_taginfo G__G__G3DLN_TELTU = { "TELTU" , 99 , -1 };
15317 G__linked_taginfo G__G__G3DLN_TCollection = { "TCollection" , 99 , -1 };
15318 G__linked_taginfo G__G__G3DLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
15319 G__linked_taginfo G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
15320 G__linked_taginfo G__G__G3DLN_TRotMatrix = { "TRotMatrix" , 99 , -1 };
15321 G__linked_taginfo G__G__G3DLN_TGeometry = { "TGeometry" , 99 , -1 };
15322 G__linked_taginfo G__G__G3DLN_TGTRA = { "TGTRA" , 99 , -1 };
15323 G__linked_taginfo G__G__G3DLN_TPolyLine3D = { "TPolyLine3D" , 99 , -1 };
15324 G__linked_taginfo G__G__G3DLN_TRotMatrixcLcLdA = { "TRotMatrix::$" , 101 , -1 };
15325 G__linked_taginfo G__G__G3DLN_EHelixRangeType = { "EHelixRangeType" , 101 , -1 };
15326 G__linked_taginfo G__G__G3DLN_THelix = { "THelix" , 99 , -1 };
15327 G__linked_taginfo G__G__G3DLN_THYPE = { "THYPE" , 99 , -1 };
15328 G__linked_taginfo G__G__G3DLN_TH1 = { "TH1" , 99 , -1 };
15329 G__linked_taginfo G__G__G3DLN_TMarker3DBox = { "TMarker3DBox" , 99 , -1 };
15330 G__linked_taginfo G__G__G3DLN_TMarker3DBoxcLcLdA = { "TMarker3DBox::$" , 101 , -1 };
15331 G__linked_taginfo G__G__G3DLN_TMixture = { "TMixture" , 99 , -1 };
15332 G__linked_taginfo G__G__G3DLN_TNodecLcLdA = { "TNode::$" , 101 , -1 };
15333 G__linked_taginfo G__G__G3DLN_TNodeDiv = { "TNodeDiv" , 99 , -1 };
15334 G__linked_taginfo G__G__G3DLN_TPARA = { "TPARA" , 99 , -1 };
15335 G__linked_taginfo G__G__G3DLN_TPCON = { "TPCON" , 99 , -1 };
15336 G__linked_taginfo G__G__G3DLN_TPGON = { "TPGON" , 99 , -1 };
15337 G__linked_taginfo G__G__G3DLN_TPoints3DABC = { "TPoints3DABC" , 99 , -1 };
15338 G__linked_taginfo G__G__G3DLN_TAttMarker = { "TAttMarker" , 99 , -1 };
15339 G__linked_taginfo G__G__G3DLN_TPolyMarker3D = { "TPolyMarker3D" , 99 , -1 };
15340 G__linked_taginfo G__G__G3DLN_TAttBBox = { "TAttBBox" , 99 , -1 };
15341 G__linked_taginfo G__G__G3DLN_TRefArray = { "TRefArray" , 99 , -1 };
15342 G__linked_taginfo G__G__G3DLN_TPointSet3D = { "TPointSet3D" , 99 , -1 };
15343 G__linked_taginfo G__G__G3DLN_TSPHE = { "TSPHE" , 99 , -1 };
15344 G__linked_taginfo G__G__G3DLN_TTRAP = { "TTRAP" , 99 , -1 };
15345 G__linked_taginfo G__G__G3DLN_TTRD1 = { "TTRD1" , 99 , -1 };
15346 G__linked_taginfo G__G__G3DLN_TTRD2 = { "TTRD2" , 99 , -1 };
15347 G__linked_taginfo G__G__G3DLN_TView3D = { "TView3D" , 99 , -1 };
15348 G__linked_taginfo G__G__G3DLN_TView3DcLcLdA = { "TView3D::$" , 101 , -1 };
15349 G__linked_taginfo G__G__G3DLN_TXTRU = { "TXTRU" , 99 , -1 };
15350 G__linked_taginfo G__G__G3DLN_TXTRUcLcLEXYChecked = { "TXTRU::EXYChecked" , 101 , -1 };
15351 G__linked_taginfo G__G__G3DLN_TXTRUcLcLEZChecked = { "TXTRU::EZChecked" , 101 , -1 };
15352
15353
15354 extern "C" void G__cpp_reset_tagtableG__G3D() {
15355 G__G__G3DLN_TClass.tagnum = -1 ;
15356 G__G__G3DLN_TBuffer.tagnum = -1 ;
15357 G__G__G3DLN_TMemberInspector.tagnum = -1 ;
15358 G__G__G3DLN_TObject.tagnum = -1 ;
15359 G__G__G3DLN_TNamed.tagnum = -1 ;
15360 G__G__G3DLN_TString.tagnum = -1 ;
15361 G__G__G3DLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
15362 G__G__G3DLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
15363 G__G__G3DLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
15364 G__G__G3DLN_TList.tagnum = -1 ;
15365 G__G__G3DLN_TBrowser.tagnum = -1 ;
15366 G__G__G3DLN_TObjArray.tagnum = -1 ;
15367 G__G__G3DLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
15368 G__G__G3DLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
15369 G__G__G3DLN_THashList.tagnum = -1 ;
15370 G__G__G3DLN_TAxis.tagnum = -1 ;
15371 G__G__G3DLN_TGaxis.tagnum = -1 ;
15372 G__G__G3DLN_TVirtualPad.tagnum = -1 ;
15373 G__G__G3DLN_TView.tagnum = -1 ;
15374 G__G__G3DLN_TAxis3D.tagnum = -1 ;
15375 G__G__G3DLN_TAttFill.tagnum = -1 ;
15376 G__G__G3DLN_TMaterial.tagnum = -1 ;
15377 G__G__G3DLN_TAttLine.tagnum = -1 ;
15378 G__G__G3DLN_TAtt3D.tagnum = -1 ;
15379 G__G__G3DLN_TBuffer3D.tagnum = -1 ;
15380 G__G__G3DLN_TNode.tagnum = -1 ;
15381 G__G__G3DLN_TShape.tagnum = -1 ;
15382 G__G__G3DLN_TBRIK.tagnum = -1 ;
15383 G__G__G3DLN_TTUBE.tagnum = -1 ;
15384 G__G__G3DLN_TCONE.tagnum = -1 ;
15385 G__G__G3DLN_TTUBS.tagnum = -1 ;
15386 G__G__G3DLN_TCONS.tagnum = -1 ;
15387 G__G__G3DLN_TCTUB.tagnum = -1 ;
15388 G__G__G3DLN_TELTU.tagnum = -1 ;
15389 G__G__G3DLN_TCollection.tagnum = -1 ;
15390 G__G__G3DLN_TSeqCollection.tagnum = -1 ;
15391 G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
15392 G__G__G3DLN_TRotMatrix.tagnum = -1 ;
15393 G__G__G3DLN_TGeometry.tagnum = -1 ;
15394 G__G__G3DLN_TGTRA.tagnum = -1 ;
15395 G__G__G3DLN_TPolyLine3D.tagnum = -1 ;
15396 G__G__G3DLN_TRotMatrixcLcLdA.tagnum = -1 ;
15397 G__G__G3DLN_EHelixRangeType.tagnum = -1 ;
15398 G__G__G3DLN_THelix.tagnum = -1 ;
15399 G__G__G3DLN_THYPE.tagnum = -1 ;
15400 G__G__G3DLN_TH1.tagnum = -1 ;
15401 G__G__G3DLN_TMarker3DBox.tagnum = -1 ;
15402 G__G__G3DLN_TMarker3DBoxcLcLdA.tagnum = -1 ;
15403 G__G__G3DLN_TMixture.tagnum = -1 ;
15404 G__G__G3DLN_TNodecLcLdA.tagnum = -1 ;
15405 G__G__G3DLN_TNodeDiv.tagnum = -1 ;
15406 G__G__G3DLN_TPARA.tagnum = -1 ;
15407 G__G__G3DLN_TPCON.tagnum = -1 ;
15408 G__G__G3DLN_TPGON.tagnum = -1 ;
15409 G__G__G3DLN_TPoints3DABC.tagnum = -1 ;
15410 G__G__G3DLN_TAttMarker.tagnum = -1 ;
15411 G__G__G3DLN_TPolyMarker3D.tagnum = -1 ;
15412 G__G__G3DLN_TAttBBox.tagnum = -1 ;
15413 G__G__G3DLN_TRefArray.tagnum = -1 ;
15414 G__G__G3DLN_TPointSet3D.tagnum = -1 ;
15415 G__G__G3DLN_TSPHE.tagnum = -1 ;
15416 G__G__G3DLN_TTRAP.tagnum = -1 ;
15417 G__G__G3DLN_TTRD1.tagnum = -1 ;
15418 G__G__G3DLN_TTRD2.tagnum = -1 ;
15419 G__G__G3DLN_TView3D.tagnum = -1 ;
15420 G__G__G3DLN_TView3DcLcLdA.tagnum = -1 ;
15421 G__G__G3DLN_TXTRU.tagnum = -1 ;
15422 G__G__G3DLN_TXTRUcLcLEXYChecked.tagnum = -1 ;
15423 G__G__G3DLN_TXTRUcLcLEZChecked.tagnum = -1 ;
15424 }
15425
15426
15427 extern "C" void G__cpp_setup_tagtableG__G3D() {
15428
15429
15430 G__get_linked_tagnum_fwd(&G__G__G3DLN_TClass);
15431 G__get_linked_tagnum_fwd(&G__G__G3DLN_TBuffer);
15432 G__get_linked_tagnum_fwd(&G__G__G3DLN_TMemberInspector);
15433 G__get_linked_tagnum_fwd(&G__G__G3DLN_TObject);
15434 G__get_linked_tagnum_fwd(&G__G__G3DLN_TNamed);
15435 G__get_linked_tagnum_fwd(&G__G__G3DLN_TString);
15436 G__get_linked_tagnum_fwd(&G__G__G3DLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
15437 G__get_linked_tagnum_fwd(&G__G__G3DLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
15438 G__get_linked_tagnum_fwd(&G__G__G3DLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
15439 G__get_linked_tagnum_fwd(&G__G__G3DLN_TList);
15440 G__get_linked_tagnum_fwd(&G__G__G3DLN_TBrowser);
15441 G__get_linked_tagnum_fwd(&G__G__G3DLN_TObjArray);
15442 G__get_linked_tagnum_fwd(&G__G__G3DLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
15443 G__get_linked_tagnum_fwd(&G__G__G3DLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
15444 G__get_linked_tagnum_fwd(&G__G__G3DLN_THashList);
15445 G__get_linked_tagnum_fwd(&G__G__G3DLN_TAxis);
15446 G__get_linked_tagnum_fwd(&G__G__G3DLN_TGaxis);
15447 G__get_linked_tagnum_fwd(&G__G__G3DLN_TVirtualPad);
15448 G__get_linked_tagnum_fwd(&G__G__G3DLN_TView);
15449 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TAxis3D),sizeof(TAxis3D),-1,325376,"3-D ruler painting class",G__setup_memvarTAxis3D,G__setup_memfuncTAxis3D);
15450 G__get_linked_tagnum_fwd(&G__G__G3DLN_TAttFill);
15451 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TMaterial),sizeof(TMaterial),-1,128256,"Materials used in the Geometry Shapes",G__setup_memvarTMaterial,G__setup_memfuncTMaterial);
15452 G__get_linked_tagnum_fwd(&G__G__G3DLN_TAttLine);
15453 G__get_linked_tagnum_fwd(&G__G__G3DLN_TAtt3D);
15454 G__get_linked_tagnum_fwd(&G__G__G3DLN_TBuffer3D);
15455 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TNode),sizeof(TNode),-1,130816,"Description of parameters to position a 3-D geometry object",G__setup_memvarTNode,G__setup_memfuncTNode);
15456 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TShape),sizeof(TShape),-1,130816,"Basic shape",G__setup_memvarTShape,G__setup_memfuncTShape);
15457 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TBRIK),sizeof(TBRIK),-1,324864,"TBRIK shape",G__setup_memvarTBRIK,G__setup_memfuncTBRIK);
15458 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TTUBE),sizeof(TTUBE),-1,130816,"TUBE shape",G__setup_memvarTTUBE,G__setup_memfuncTTUBE);
15459 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TCONE),sizeof(TCONE),-1,324864,"CONE shape",G__setup_memvarTCONE,G__setup_memfuncTCONE);
15460 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TTUBS),sizeof(TTUBS),-1,324864,"TUBS shape",G__setup_memvarTTUBS,G__setup_memfuncTTUBS);
15461 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TCONS),sizeof(TCONS),-1,324864,"CONS shape",G__setup_memvarTCONS,G__setup_memfuncTCONS);
15462 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TCTUB),sizeof(TCTUB),-1,128256,"The Cut Tube shape",G__setup_memvarTCTUB,G__setup_memfuncTCTUB);
15463 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TELTU),sizeof(TELTU),-1,324864,"ELTU shape",G__setup_memvarTELTU,G__setup_memfuncTELTU);
15464 G__get_linked_tagnum_fwd(&G__G__G3DLN_TCollection);
15465 G__get_linked_tagnum_fwd(&G__G__G3DLN_TSeqCollection);
15466 G__get_linked_tagnum_fwd(&G__G__G3DLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
15467 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TRotMatrix),sizeof(TRotMatrix),-1,128256,"Rotation Matrix for 3-D geometry objects",G__setup_memvarTRotMatrix,G__setup_memfuncTRotMatrix);
15468 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TGeometry),sizeof(TGeometry),-1,130816,"Structure for Matrices, Shapes and Nodes",G__setup_memvarTGeometry,G__setup_memfuncTGeometry);
15469 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TGTRA),sizeof(TGTRA),-1,324864,"GTRA shape",G__setup_memvarTGTRA,G__setup_memfuncTGTRA);
15470 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPolyLine3D),sizeof(TPolyLine3D),-1,130816,"A 3-D polyline",G__setup_memvarTPolyLine3D,G__setup_memfuncTPolyLine3D);
15471 G__get_linked_tagnum_fwd(&G__G__G3DLN_TRotMatrixcLcLdA);
15472 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_EHelixRangeType),sizeof(int),-1,0,(char*)NULL,NULL,NULL);
15473 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_THelix),sizeof(THelix),-1,130816,"A Helix drawn as a PolyLine3D",G__setup_memvarTHelix,G__setup_memfuncTHelix);
15474 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_THYPE),sizeof(THYPE),-1,324864,"HYPE shape",G__setup_memvarTHYPE,G__setup_memfuncTHYPE);
15475 G__get_linked_tagnum_fwd(&G__G__G3DLN_TH1);
15476 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TMarker3DBox),sizeof(TMarker3DBox),-1,130816,"A special 3-D marker designed for event display",G__setup_memvarTMarker3DBox,G__setup_memfuncTMarker3DBox);
15477 G__get_linked_tagnum_fwd(&G__G__G3DLN_TMarker3DBoxcLcLdA);
15478 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TMixture),sizeof(TMixture),-1,128256,"Mixtures used in the Geometry Shapes",G__setup_memvarTMixture,G__setup_memfuncTMixture);
15479 G__get_linked_tagnum_fwd(&G__G__G3DLN_TNodecLcLdA);
15480 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TNodeDiv),sizeof(TNodeDiv),-1,324864,"Description of parameters to divide a 3-D geometry object",G__setup_memvarTNodeDiv,G__setup_memfuncTNodeDiv);
15481 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPARA),sizeof(TPARA),-1,324864,"PARA shape",G__setup_memvarTPARA,G__setup_memfuncTPARA);
15482 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPCON),sizeof(TPCON),-1,130816,"PCON shape",G__setup_memvarTPCON,G__setup_memfuncTPCON);
15483 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPGON),sizeof(TPGON),-1,324864,"PGON shape",G__setup_memvarTPGON,G__setup_memfuncTPGON);
15484 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPoints3DABC),sizeof(TPoints3DABC),-1,29965,"A 3-D Points",G__setup_memvarTPoints3DABC,G__setup_memfuncTPoints3DABC);
15485 G__get_linked_tagnum_fwd(&G__G__G3DLN_TAttMarker);
15486 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPolyMarker3D),sizeof(TPolyMarker3D),-1,130816,"An array of 3-D points with the same marker",G__setup_memvarTPolyMarker3D,G__setup_memfuncTPolyMarker3D);
15487 G__get_linked_tagnum_fwd(&G__G__G3DLN_TAttBBox);
15488 G__get_linked_tagnum_fwd(&G__G__G3DLN_TRefArray);
15489 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TPointSet3D),sizeof(TPointSet3D),-1,130816,"TPolyMarker3D with direct OpenGL rendering.",G__setup_memvarTPointSet3D,G__setup_memfuncTPointSet3D);
15490 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TSPHE),sizeof(TSPHE),-1,128256,"SPHE shape",G__setup_memvarTSPHE,G__setup_memfuncTSPHE);
15491 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TTRAP),sizeof(TTRAP),-1,324864,"TRAP shape",G__setup_memvarTTRAP,G__setup_memfuncTTRAP);
15492 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TTRD1),sizeof(TTRD1),-1,324864,"TRD1 shape",G__setup_memvarTTRD1,G__setup_memfuncTTRD1);
15493 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TTRD2),sizeof(TTRD2),-1,324864,"TRD2 shape",G__setup_memvarTTRD2,G__setup_memfuncTTRD2);
15494 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TView3D),sizeof(TView3D),-1,130816,"3-D View",G__setup_memvarTView3D,G__setup_memfuncTView3D);
15495 G__get_linked_tagnum_fwd(&G__G__G3DLN_TView3DcLcLdA);
15496 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__G3DLN_TXTRU),sizeof(TXTRU),-1,327424,"TXTRU shape",G__setup_memvarTXTRU,G__setup_memfuncTXTRU);
15497 G__get_linked_tagnum_fwd(&G__G__G3DLN_TXTRUcLcLEXYChecked);
15498 G__get_linked_tagnum_fwd(&G__G__G3DLN_TXTRUcLcLEZChecked);
15499 }
15500 extern "C" void G__cpp_setupG__G3D(void) {
15501 G__check_setup_version(30051515,"G__cpp_setupG__G3D()");
15502 G__set_cpp_environmentG__G3D();
15503 G__cpp_setup_tagtableG__G3D();
15504
15505 G__cpp_setup_inheritanceG__G3D();
15506
15507 G__cpp_setup_typetableG__G3D();
15508
15509 G__cpp_setup_memvarG__G3D();
15510
15511 G__cpp_setup_memfuncG__G3D();
15512 G__cpp_setup_globalG__G3D();
15513 G__cpp_setup_funcG__G3D();
15514
15515 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__G3D();
15516 return;
15517 }
15518 class G__cpp_setup_initG__G3D {
15519 public:
15520 G__cpp_setup_initG__G3D() { G__add_setup_func("G__G3D",(G__incsetup)(&G__cpp_setupG__G3D)); G__call_setup_funcs(); }
15521 ~G__cpp_setup_initG__G3D() { G__remove_setup_func("G__G3D"); }
15522 };
15523 G__cpp_setup_initG__G3D G__cpp_setup_initializerG__G3D;
15524
