BOSS 7.0.4
BESIII Offline Software System
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx
Go to the documentation of this file.
1//
2// File generated by /cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/SLC6/ExternalLib/external/ROOT/5.34.09/x86_64-slc6-gcc46-opt/root/bin/rootcint at Wed Jul 25 18:53:57 2018
3
4// Do NOT change. Changes will be lost next time file is generated
5//
6
7#define R__DICTIONARY_FILENAME dOdOdIRootEventDatadIRootEventData_rootcint
8#include "RConfig.h" //rootcint 4834
9#if !defined(R__ACCESS_IN_SYMBOL)
10//Break the privacy of classes -- Disabled for the moment
11#define private public
12#define protected public
13#endif
14
15// Since CINT ignores the std namespace, we need to do so in this file.
16namespace std {} using namespace std;
17#include "RootEventData_rootcint.h"
18
19#include "TCollectionProxyInfo.h"
20#include "TClass.h"
21#include "TBuffer.h"
22#include "TMemberInspector.h"
23#include "TError.h"
24
25#ifndef G__ROOT
26#define G__ROOT
27#endif
28
29#include "RtypesImp.h"
30#include "TIsAProxy.h"
31#include "TFileMergeInfo.h"
32
33// START OF SHADOWS
34
35namespace ROOT {
36 namespace Shadow {
37 } // of namespace Shadow
38} // of namespace ROOT
39// END OF SHADOWS
40
41namespace ROOT {
42 void TJobInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
43 static void *new_TJobInfo(void *p = 0);
44 static void *newArray_TJobInfo(Long_t size, void *p);
45 static void delete_TJobInfo(void *p);
46 static void deleteArray_TJobInfo(void *p);
47 static void destruct_TJobInfo(void *p);
48
49 // Function generating the singleton type initializer
50 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TJobInfo*)
51 {
52 ::TJobInfo *ptr = 0;
53 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TJobInfo >(0);
54 static ::ROOT::TGenericClassInfo
55 instance("TJobInfo", ::TJobInfo::Class_Version(), "./../RootEventData/TJobInfo.h", 9,
56 typeid(::TJobInfo), DefineBehavior(ptr, ptr),
57 &::TJobInfo::Dictionary, isa_proxy, 4,
58 sizeof(::TJobInfo) );
59 instance.SetNew(&new_TJobInfo);
60 instance.SetNewArray(&newArray_TJobInfo);
61 instance.SetDelete(&delete_TJobInfo);
62 instance.SetDeleteArray(&deleteArray_TJobInfo);
63 instance.SetDestructor(&destruct_TJobInfo);
64 return &instance;
65 }
66 TGenericClassInfo *GenerateInitInstance(const ::TJobInfo*)
67 {
68 return GenerateInitInstanceLocal((::TJobInfo*)0);
69 }
70 // Static variable to force the class initialization
71 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TJobInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
72} // end of namespace ROOT
73
74namespace ROOT {
75 void TRawData_ShowMembers(void *obj, TMemberInspector &R__insp);
76 static void *new_TRawData(void *p = 0);
77 static void *newArray_TRawData(Long_t size, void *p);
78 static void delete_TRawData(void *p);
79 static void deleteArray_TRawData(void *p);
80 static void destruct_TRawData(void *p);
81
82 // Function generating the singleton type initializer
83 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRawData*)
84 {
85 ::TRawData *ptr = 0;
86 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRawData >(0);
87 static ::ROOT::TGenericClassInfo
88 instance("TRawData", ::TRawData::Class_Version(), "./../RootEventData/TRawData.h", 7,
89 typeid(::TRawData), DefineBehavior(ptr, ptr),
90 &::TRawData::Dictionary, isa_proxy, 4,
91 sizeof(::TRawData) );
92 instance.SetNew(&new_TRawData);
93 instance.SetNewArray(&newArray_TRawData);
94 instance.SetDelete(&delete_TRawData);
95 instance.SetDeleteArray(&deleteArray_TRawData);
96 instance.SetDestructor(&destruct_TRawData);
97 return &instance;
98 }
99 TGenericClassInfo *GenerateInitInstance(const ::TRawData*)
100 {
101 return GenerateInitInstanceLocal((::TRawData*)0);
102 }
103 // Static variable to force the class initialization
104 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRawData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
105} // end of namespace ROOT
106
107namespace ROOT {
108 void TMdcDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
109 static void *new_TMdcDigi(void *p = 0);
110 static void *newArray_TMdcDigi(Long_t size, void *p);
111 static void delete_TMdcDigi(void *p);
112 static void deleteArray_TMdcDigi(void *p);
113 static void destruct_TMdcDigi(void *p);
114
115 // Function generating the singleton type initializer
116 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcDigi*)
117 {
118 ::TMdcDigi *ptr = 0;
119 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDigi >(0);
120 static ::ROOT::TGenericClassInfo
121 instance("TMdcDigi", ::TMdcDigi::Class_Version(), "./../RootEventData/TMdcDigi.h", 7,
122 typeid(::TMdcDigi), DefineBehavior(ptr, ptr),
123 &::TMdcDigi::Dictionary, isa_proxy, 4,
124 sizeof(::TMdcDigi) );
125 instance.SetNew(&new_TMdcDigi);
126 instance.SetNewArray(&newArray_TMdcDigi);
127 instance.SetDelete(&delete_TMdcDigi);
128 instance.SetDeleteArray(&deleteArray_TMdcDigi);
129 instance.SetDestructor(&destruct_TMdcDigi);
130 return &instance;
131 }
132 TGenericClassInfo *GenerateInitInstance(const ::TMdcDigi*)
133 {
134 return GenerateInitInstanceLocal((::TMdcDigi*)0);
135 }
136 // Static variable to force the class initialization
137 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
138} // end of namespace ROOT
139
140namespace ROOT {
141 void TEmcDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
142 static void *new_TEmcDigi(void *p = 0);
143 static void *newArray_TEmcDigi(Long_t size, void *p);
144 static void delete_TEmcDigi(void *p);
145 static void deleteArray_TEmcDigi(void *p);
146 static void destruct_TEmcDigi(void *p);
147
148 // Function generating the singleton type initializer
149 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcDigi*)
150 {
151 ::TEmcDigi *ptr = 0;
152 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcDigi >(0);
153 static ::ROOT::TGenericClassInfo
154 instance("TEmcDigi", ::TEmcDigi::Class_Version(), "./../RootEventData/TEmcDigi.h", 6,
155 typeid(::TEmcDigi), DefineBehavior(ptr, ptr),
156 &::TEmcDigi::Dictionary, isa_proxy, 4,
157 sizeof(::TEmcDigi) );
158 instance.SetNew(&new_TEmcDigi);
159 instance.SetNewArray(&newArray_TEmcDigi);
160 instance.SetDelete(&delete_TEmcDigi);
161 instance.SetDeleteArray(&deleteArray_TEmcDigi);
162 instance.SetDestructor(&destruct_TEmcDigi);
163 return &instance;
164 }
165 TGenericClassInfo *GenerateInitInstance(const ::TEmcDigi*)
166 {
167 return GenerateInitInstanceLocal((::TEmcDigi*)0);
168 }
169 // Static variable to force the class initialization
170 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmcDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
171} // end of namespace ROOT
172
173namespace ROOT {
174 void TTofDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
175 static void *new_TTofDigi(void *p = 0);
176 static void *newArray_TTofDigi(Long_t size, void *p);
177 static void delete_TTofDigi(void *p);
178 static void deleteArray_TTofDigi(void *p);
179 static void destruct_TTofDigi(void *p);
180
181 // Function generating the singleton type initializer
182 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofDigi*)
183 {
184 ::TTofDigi *ptr = 0;
185 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofDigi >(0);
186 static ::ROOT::TGenericClassInfo
187 instance("TTofDigi", ::TTofDigi::Class_Version(), "./../RootEventData/TTofDigi.h", 7,
188 typeid(::TTofDigi), DefineBehavior(ptr, ptr),
189 &::TTofDigi::Dictionary, isa_proxy, 4,
190 sizeof(::TTofDigi) );
191 instance.SetNew(&new_TTofDigi);
192 instance.SetNewArray(&newArray_TTofDigi);
193 instance.SetDelete(&delete_TTofDigi);
194 instance.SetDeleteArray(&deleteArray_TTofDigi);
195 instance.SetDestructor(&destruct_TTofDigi);
196 return &instance;
197 }
198 TGenericClassInfo *GenerateInitInstance(const ::TTofDigi*)
199 {
200 return GenerateInitInstanceLocal((::TTofDigi*)0);
201 }
202 // Static variable to force the class initialization
203 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTofDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
204} // end of namespace ROOT
205
206namespace ROOT {
207 void TMucDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
208 static void *new_TMucDigi(void *p = 0);
209 static void *newArray_TMucDigi(Long_t size, void *p);
210 static void delete_TMucDigi(void *p);
211 static void deleteArray_TMucDigi(void *p);
212 static void destruct_TMucDigi(void *p);
213
214 // Function generating the singleton type initializer
215 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucDigi*)
216 {
217 ::TMucDigi *ptr = 0;
218 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucDigi >(0);
219 static ::ROOT::TGenericClassInfo
220 instance("TMucDigi", ::TMucDigi::Class_Version(), "./../RootEventData/TMucDigi.h", 7,
221 typeid(::TMucDigi), DefineBehavior(ptr, ptr),
222 &::TMucDigi::Dictionary, isa_proxy, 4,
223 sizeof(::TMucDigi) );
224 instance.SetNew(&new_TMucDigi);
225 instance.SetNewArray(&newArray_TMucDigi);
226 instance.SetDelete(&delete_TMucDigi);
227 instance.SetDeleteArray(&deleteArray_TMucDigi);
228 instance.SetDestructor(&destruct_TMucDigi);
229 return &instance;
230 }
231 TGenericClassInfo *GenerateInitInstance(const ::TMucDigi*)
232 {
233 return GenerateInitInstanceLocal((::TMucDigi*)0);
234 }
235 // Static variable to force the class initialization
236 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMucDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
237} // end of namespace ROOT
238
239namespace ROOT {
240 void TLumiDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
241 static void *new_TLumiDigi(void *p = 0);
242 static void *newArray_TLumiDigi(Long_t size, void *p);
243 static void delete_TLumiDigi(void *p);
244 static void deleteArray_TLumiDigi(void *p);
245 static void destruct_TLumiDigi(void *p);
246
247 // Function generating the singleton type initializer
248 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLumiDigi*)
249 {
250 ::TLumiDigi *ptr = 0;
251 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLumiDigi >(0);
252 static ::ROOT::TGenericClassInfo
253 instance("TLumiDigi", ::TLumiDigi::Class_Version(), "./../RootEventData/TLumiDigi.h", 6,
254 typeid(::TLumiDigi), DefineBehavior(ptr, ptr),
255 &::TLumiDigi::Dictionary, isa_proxy, 4,
256 sizeof(::TLumiDigi) );
257 instance.SetNew(&new_TLumiDigi);
258 instance.SetNewArray(&newArray_TLumiDigi);
259 instance.SetDelete(&delete_TLumiDigi);
260 instance.SetDeleteArray(&deleteArray_TLumiDigi);
261 instance.SetDestructor(&destruct_TLumiDigi);
262 return &instance;
263 }
264 TGenericClassInfo *GenerateInitInstance(const ::TLumiDigi*)
265 {
266 return GenerateInitInstanceLocal((::TLumiDigi*)0);
267 }
268 // Static variable to force the class initialization
269 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLumiDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
270} // end of namespace ROOT
271
272namespace ROOT {
273 void TDigiEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
274 static void *new_TDigiEvent(void *p = 0);
275 static void *newArray_TDigiEvent(Long_t size, void *p);
276 static void delete_TDigiEvent(void *p);
277 static void deleteArray_TDigiEvent(void *p);
278 static void destruct_TDigiEvent(void *p);
279
280 // Function generating the singleton type initializer
281 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDigiEvent*)
282 {
283 ::TDigiEvent *ptr = 0;
284 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDigiEvent >(0);
285 static ::ROOT::TGenericClassInfo
286 instance("TDigiEvent", ::TDigiEvent::Class_Version(), "./../RootEventData/TDigiEvent.h", 14,
287 typeid(::TDigiEvent), DefineBehavior(ptr, ptr),
288 &::TDigiEvent::Dictionary, isa_proxy, 4,
289 sizeof(::TDigiEvent) );
290 instance.SetNew(&new_TDigiEvent);
291 instance.SetNewArray(&newArray_TDigiEvent);
292 instance.SetDelete(&delete_TDigiEvent);
293 instance.SetDeleteArray(&deleteArray_TDigiEvent);
294 instance.SetDestructor(&destruct_TDigiEvent);
295 return &instance;
296 }
297 TGenericClassInfo *GenerateInitInstance(const ::TDigiEvent*)
298 {
299 return GenerateInitInstanceLocal((::TDigiEvent*)0);
300 }
301 // Static variable to force the class initialization
302 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDigiEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
303} // end of namespace ROOT
304
305namespace ROOT {
306 void TRecMdcTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
307 static void *new_TRecMdcTrack(void *p = 0);
308 static void *newArray_TRecMdcTrack(Long_t size, void *p);
309 static void delete_TRecMdcTrack(void *p);
310 static void deleteArray_TRecMdcTrack(void *p);
311 static void destruct_TRecMdcTrack(void *p);
312
313 // Function generating the singleton type initializer
314 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcTrack*)
315 {
316 ::TRecMdcTrack *ptr = 0;
317 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcTrack >(0);
318 static ::ROOT::TGenericClassInfo
319 instance("TRecMdcTrack", ::TRecMdcTrack::Class_Version(), "./../RootEventData/TRecMdcTrack.h", 9,
320 typeid(::TRecMdcTrack), DefineBehavior(ptr, ptr),
321 &::TRecMdcTrack::Dictionary, isa_proxy, 4,
322 sizeof(::TRecMdcTrack) );
323 instance.SetNew(&new_TRecMdcTrack);
324 instance.SetNewArray(&newArray_TRecMdcTrack);
325 instance.SetDelete(&delete_TRecMdcTrack);
326 instance.SetDeleteArray(&deleteArray_TRecMdcTrack);
327 instance.SetDestructor(&destruct_TRecMdcTrack);
328 return &instance;
329 }
330 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcTrack*)
331 {
332 return GenerateInitInstanceLocal((::TRecMdcTrack*)0);
333 }
334 // Static variable to force the class initialization
335 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
336} // end of namespace ROOT
337
338namespace ROOT {
339 void TRecMdcKalTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
340 static void *new_TRecMdcKalTrack(void *p = 0);
341 static void *newArray_TRecMdcKalTrack(Long_t size, void *p);
342 static void delete_TRecMdcKalTrack(void *p);
343 static void deleteArray_TRecMdcKalTrack(void *p);
344 static void destruct_TRecMdcKalTrack(void *p);
345
346 // Function generating the singleton type initializer
347 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcKalTrack*)
348 {
349 ::TRecMdcKalTrack *ptr = 0;
350 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalTrack >(0);
351 static ::ROOT::TGenericClassInfo
352 instance("TRecMdcKalTrack", ::TRecMdcKalTrack::Class_Version(), "./../RootEventData/TRecMdcKalTrack.h", 7,
353 typeid(::TRecMdcKalTrack), DefineBehavior(ptr, ptr),
354 &::TRecMdcKalTrack::Dictionary, isa_proxy, 4,
355 sizeof(::TRecMdcKalTrack) );
356 instance.SetNew(&new_TRecMdcKalTrack);
357 instance.SetNewArray(&newArray_TRecMdcKalTrack);
358 instance.SetDelete(&delete_TRecMdcKalTrack);
359 instance.SetDeleteArray(&deleteArray_TRecMdcKalTrack);
360 instance.SetDestructor(&destruct_TRecMdcKalTrack);
361 return &instance;
362 }
363 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcKalTrack*)
364 {
365 return GenerateInitInstanceLocal((::TRecMdcKalTrack*)0);
366 }
367 // Static variable to force the class initialization
368 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
369} // end of namespace ROOT
370
371namespace ROOT {
372 void TRecMdcHit_ShowMembers(void *obj, TMemberInspector &R__insp);
373 static void *new_TRecMdcHit(void *p = 0);
374 static void *newArray_TRecMdcHit(Long_t size, void *p);
375 static void delete_TRecMdcHit(void *p);
376 static void deleteArray_TRecMdcHit(void *p);
377 static void destruct_TRecMdcHit(void *p);
378
379 // Function generating the singleton type initializer
380 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcHit*)
381 {
382 ::TRecMdcHit *ptr = 0;
383 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcHit >(0);
384 static ::ROOT::TGenericClassInfo
385 instance("TRecMdcHit", ::TRecMdcHit::Class_Version(), "./../RootEventData/TRecMdcHit.h", 9,
386 typeid(::TRecMdcHit), DefineBehavior(ptr, ptr),
387 &::TRecMdcHit::Dictionary, isa_proxy, 4,
388 sizeof(::TRecMdcHit) );
389 instance.SetNew(&new_TRecMdcHit);
390 instance.SetNewArray(&newArray_TRecMdcHit);
391 instance.SetDelete(&delete_TRecMdcHit);
392 instance.SetDeleteArray(&deleteArray_TRecMdcHit);
393 instance.SetDestructor(&destruct_TRecMdcHit);
394 return &instance;
395 }
396 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcHit*)
397 {
398 return GenerateInitInstanceLocal((::TRecMdcHit*)0);
399 }
400 // Static variable to force the class initialization
401 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
402} // end of namespace ROOT
403
404namespace ROOT {
405 void TTofTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
406 static void *new_TTofTrack(void *p = 0);
407 static void *newArray_TTofTrack(Long_t size, void *p);
408 static void delete_TTofTrack(void *p);
409 static void deleteArray_TTofTrack(void *p);
410 static void destruct_TTofTrack(void *p);
411
412 // Function generating the singleton type initializer
413 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofTrack*)
414 {
415 ::TTofTrack *ptr = 0;
416 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofTrack >(0);
417 static ::ROOT::TGenericClassInfo
418 instance("TTofTrack", ::TTofTrack::Class_Version(), "./../RootEventData/TTofTrack.h", 10,
419 typeid(::TTofTrack), DefineBehavior(ptr, ptr),
420 &::TTofTrack::Dictionary, isa_proxy, 4,
421 sizeof(::TTofTrack) );
422 instance.SetNew(&new_TTofTrack);
423 instance.SetNewArray(&newArray_TTofTrack);
424 instance.SetDelete(&delete_TTofTrack);
425 instance.SetDeleteArray(&deleteArray_TTofTrack);
426 instance.SetDestructor(&destruct_TTofTrack);
427 return &instance;
428 }
429 TGenericClassInfo *GenerateInitInstance(const ::TTofTrack*)
430 {
431 return GenerateInitInstanceLocal((::TTofTrack*)0);
432 }
433 // Static variable to force the class initialization
434 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTofTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
435} // end of namespace ROOT
436
437namespace ROOT {
438 void TRecTofTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
439 static void *new_TRecTofTrack(void *p = 0);
440 static void *newArray_TRecTofTrack(Long_t size, void *p);
441 static void delete_TRecTofTrack(void *p);
442 static void deleteArray_TRecTofTrack(void *p);
443 static void destruct_TRecTofTrack(void *p);
444
445 // Function generating the singleton type initializer
446 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecTofTrack*)
447 {
448 ::TRecTofTrack *ptr = 0;
449 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTofTrack >(0);
450 static ::ROOT::TGenericClassInfo
451 instance("TRecTofTrack", ::TRecTofTrack::Class_Version(), "./../RootEventData/TRecTofTrack.h", 9,
452 typeid(::TRecTofTrack), DefineBehavior(ptr, ptr),
453 &::TRecTofTrack::Dictionary, isa_proxy, 4,
454 sizeof(::TRecTofTrack) );
455 instance.SetNew(&new_TRecTofTrack);
456 instance.SetNewArray(&newArray_TRecTofTrack);
457 instance.SetDelete(&delete_TRecTofTrack);
458 instance.SetDeleteArray(&deleteArray_TRecTofTrack);
459 instance.SetDestructor(&destruct_TRecTofTrack);
460 return &instance;
461 }
462 TGenericClassInfo *GenerateInitInstance(const ::TRecTofTrack*)
463 {
464 return GenerateInitInstanceLocal((::TRecTofTrack*)0);
465 }
466 // Static variable to force the class initialization
467 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
468} // end of namespace ROOT
469
470namespace ROOT {
471 void TRecEmcHit_ShowMembers(void *obj, TMemberInspector &R__insp);
472 static void *new_TRecEmcHit(void *p = 0);
473 static void *newArray_TRecEmcHit(Long_t size, void *p);
474 static void delete_TRecEmcHit(void *p);
475 static void deleteArray_TRecEmcHit(void *p);
476 static void destruct_TRecEmcHit(void *p);
477
478 // Function generating the singleton type initializer
479 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcHit*)
480 {
481 ::TRecEmcHit *ptr = 0;
482 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcHit >(0);
483 static ::ROOT::TGenericClassInfo
484 instance("TRecEmcHit", ::TRecEmcHit::Class_Version(), "./../RootEventData/TRecEmcHit.h", 9,
485 typeid(::TRecEmcHit), DefineBehavior(ptr, ptr),
486 &::TRecEmcHit::Dictionary, isa_proxy, 4,
487 sizeof(::TRecEmcHit) );
488 instance.SetNew(&new_TRecEmcHit);
489 instance.SetNewArray(&newArray_TRecEmcHit);
490 instance.SetDelete(&delete_TRecEmcHit);
491 instance.SetDeleteArray(&deleteArray_TRecEmcHit);
492 instance.SetDestructor(&destruct_TRecEmcHit);
493 return &instance;
494 }
495 TGenericClassInfo *GenerateInitInstance(const ::TRecEmcHit*)
496 {
497 return GenerateInitInstanceLocal((::TRecEmcHit*)0);
498 }
499 // Static variable to force the class initialization
500 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
501} // end of namespace ROOT
502
503namespace ROOT {
504 void TRecEmcCluster_ShowMembers(void *obj, TMemberInspector &R__insp);
505 static void *new_TRecEmcCluster(void *p = 0);
506 static void *newArray_TRecEmcCluster(Long_t size, void *p);
507 static void delete_TRecEmcCluster(void *p);
508 static void deleteArray_TRecEmcCluster(void *p);
509 static void destruct_TRecEmcCluster(void *p);
510
511 // Function generating the singleton type initializer
512 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcCluster*)
513 {
514 ::TRecEmcCluster *ptr = 0;
515 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcCluster >(0);
516 static ::ROOT::TGenericClassInfo
517 instance("TRecEmcCluster", ::TRecEmcCluster::Class_Version(), "./../RootEventData/TRecEmcCluster.h", 9,
518 typeid(::TRecEmcCluster), DefineBehavior(ptr, ptr),
519 &::TRecEmcCluster::Dictionary, isa_proxy, 4,
520 sizeof(::TRecEmcCluster) );
521 instance.SetNew(&new_TRecEmcCluster);
522 instance.SetNewArray(&newArray_TRecEmcCluster);
523 instance.SetDelete(&delete_TRecEmcCluster);
524 instance.SetDeleteArray(&deleteArray_TRecEmcCluster);
525 instance.SetDestructor(&destruct_TRecEmcCluster);
526 return &instance;
527 }
528 TGenericClassInfo *GenerateInitInstance(const ::TRecEmcCluster*)
529 {
530 return GenerateInitInstanceLocal((::TRecEmcCluster*)0);
531 }
532 // Static variable to force the class initialization
533 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0); R__UseDummy(_R__UNIQUE_(Init));
534} // end of namespace ROOT
535
536namespace ROOT {
537 void TRecEmcShower_ShowMembers(void *obj, TMemberInspector &R__insp);
538 static void *new_TRecEmcShower(void *p = 0);
539 static void *newArray_TRecEmcShower(Long_t size, void *p);
540 static void delete_TRecEmcShower(void *p);
541 static void deleteArray_TRecEmcShower(void *p);
542 static void destruct_TRecEmcShower(void *p);
543
544 // Function generating the singleton type initializer
545 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcShower*)
546 {
547 ::TRecEmcShower *ptr = 0;
548 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcShower >(0);
549 static ::ROOT::TGenericClassInfo
550 instance("TRecEmcShower", ::TRecEmcShower::Class_Version(), "./../RootEventData/TRecEmcShower.h", 11,
551 typeid(::TRecEmcShower), DefineBehavior(ptr, ptr),
552 &::TRecEmcShower::Dictionary, isa_proxy, 4,
553 sizeof(::TRecEmcShower) );
554 instance.SetNew(&new_TRecEmcShower);
555 instance.SetNewArray(&newArray_TRecEmcShower);
556 instance.SetDelete(&delete_TRecEmcShower);
557 instance.SetDeleteArray(&deleteArray_TRecEmcShower);
558 instance.SetDestructor(&destruct_TRecEmcShower);
559 return &instance;
560 }
561 TGenericClassInfo *GenerateInitInstance(const ::TRecEmcShower*)
562 {
563 return GenerateInitInstanceLocal((::TRecEmcShower*)0);
564 }
565 // Static variable to force the class initialization
566 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0); R__UseDummy(_R__UNIQUE_(Init));
567} // end of namespace ROOT
568
569namespace ROOT {
570 void TRecMucTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
571 static void *new_TRecMucTrack(void *p = 0);
572 static void *newArray_TRecMucTrack(Long_t size, void *p);
573 static void delete_TRecMucTrack(void *p);
574 static void deleteArray_TRecMucTrack(void *p);
575 static void destruct_TRecMucTrack(void *p);
576
577 // Function generating the singleton type initializer
578 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMucTrack*)
579 {
580 ::TRecMucTrack *ptr = 0;
581 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMucTrack >(0);
582 static ::ROOT::TGenericClassInfo
583 instance("TRecMucTrack", ::TRecMucTrack::Class_Version(), "./../RootEventData/TRecMucTrack.h", 9,
584 typeid(::TRecMucTrack), DefineBehavior(ptr, ptr),
585 &::TRecMucTrack::Dictionary, isa_proxy, 4,
586 sizeof(::TRecMucTrack) );
587 instance.SetNew(&new_TRecMucTrack);
588 instance.SetNewArray(&newArray_TRecMucTrack);
589 instance.SetDelete(&delete_TRecMucTrack);
590 instance.SetDeleteArray(&deleteArray_TRecMucTrack);
591 instance.SetDestructor(&destruct_TRecMucTrack);
592 return &instance;
593 }
594 TGenericClassInfo *GenerateInitInstance(const ::TRecMucTrack*)
595 {
596 return GenerateInitInstanceLocal((::TRecMucTrack*)0);
597 }
598 // Static variable to force the class initialization
599 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
600} // end of namespace ROOT
601
602namespace ROOT {
603 void TRecMdcDedx_ShowMembers(void *obj, TMemberInspector &R__insp);
604 static void *new_TRecMdcDedx(void *p = 0);
605 static void *newArray_TRecMdcDedx(Long_t size, void *p);
606 static void delete_TRecMdcDedx(void *p);
607 static void deleteArray_TRecMdcDedx(void *p);
608 static void destruct_TRecMdcDedx(void *p);
609
610 // Function generating the singleton type initializer
611 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcDedx*)
612 {
613 ::TRecMdcDedx *ptr = 0;
614 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedx >(0);
615 static ::ROOT::TGenericClassInfo
616 instance("TRecMdcDedx", ::TRecMdcDedx::Class_Version(), "./../RootEventData/TRecMdcDedx.h", 6,
617 typeid(::TRecMdcDedx), DefineBehavior(ptr, ptr),
618 &::TRecMdcDedx::Dictionary, isa_proxy, 4,
619 sizeof(::TRecMdcDedx) );
620 instance.SetNew(&new_TRecMdcDedx);
621 instance.SetNewArray(&newArray_TRecMdcDedx);
622 instance.SetDelete(&delete_TRecMdcDedx);
623 instance.SetDeleteArray(&deleteArray_TRecMdcDedx);
624 instance.SetDestructor(&destruct_TRecMdcDedx);
625 return &instance;
626 }
627 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcDedx*)
628 {
629 return GenerateInitInstanceLocal((::TRecMdcDedx*)0);
630 }
631 // Static variable to force the class initialization
632 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0); R__UseDummy(_R__UNIQUE_(Init));
633} // end of namespace ROOT
634
635namespace ROOT {
636 void TRecMdcDedxHit_ShowMembers(void *obj, TMemberInspector &R__insp);
637 static void *new_TRecMdcDedxHit(void *p = 0);
638 static void *newArray_TRecMdcDedxHit(Long_t size, void *p);
639 static void delete_TRecMdcDedxHit(void *p);
640 static void deleteArray_TRecMdcDedxHit(void *p);
641 static void destruct_TRecMdcDedxHit(void *p);
642
643 // Function generating the singleton type initializer
644 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcDedxHit*)
645 {
646 ::TRecMdcDedxHit *ptr = 0;
647 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedxHit >(0);
648 static ::ROOT::TGenericClassInfo
649 instance("TRecMdcDedxHit", ::TRecMdcDedxHit::Class_Version(), "./../RootEventData/TRecMdcDedxHit.h", 7,
650 typeid(::TRecMdcDedxHit), DefineBehavior(ptr, ptr),
651 &::TRecMdcDedxHit::Dictionary, isa_proxy, 4,
652 sizeof(::TRecMdcDedxHit) );
653 instance.SetNew(&new_TRecMdcDedxHit);
654 instance.SetNewArray(&newArray_TRecMdcDedxHit);
655 instance.SetDelete(&delete_TRecMdcDedxHit);
656 instance.SetDeleteArray(&deleteArray_TRecMdcDedxHit);
657 instance.SetDestructor(&destruct_TRecMdcDedxHit);
658 return &instance;
659 }
660 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcDedxHit*)
661 {
662 return GenerateInitInstanceLocal((::TRecMdcDedxHit*)0);
663 }
664 // Static variable to force the class initialization
665 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
666} // end of namespace ROOT
667
668namespace ROOT {
669 void TRecExtTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
670 static void *new_TRecExtTrack(void *p = 0);
671 static void *newArray_TRecExtTrack(Long_t size, void *p);
672 static void delete_TRecExtTrack(void *p);
673 static void deleteArray_TRecExtTrack(void *p);
674 static void destruct_TRecExtTrack(void *p);
675
676 // Function generating the singleton type initializer
677 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecExtTrack*)
678 {
679 ::TRecExtTrack *ptr = 0;
680 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecExtTrack >(0);
681 static ::ROOT::TGenericClassInfo
682 instance("TRecExtTrack", ::TRecExtTrack::Class_Version(), "./../RootEventData/TRecExtTrack.h", 8,
683 typeid(::TRecExtTrack), DefineBehavior(ptr, ptr),
684 &::TRecExtTrack::Dictionary, isa_proxy, 4,
685 sizeof(::TRecExtTrack) );
686 instance.SetNew(&new_TRecExtTrack);
687 instance.SetNewArray(&newArray_TRecExtTrack);
688 instance.SetDelete(&delete_TRecExtTrack);
689 instance.SetDeleteArray(&deleteArray_TRecExtTrack);
690 instance.SetDestructor(&destruct_TRecExtTrack);
691 return &instance;
692 }
693 TGenericClassInfo *GenerateInitInstance(const ::TRecExtTrack*)
694 {
695 return GenerateInitInstanceLocal((::TRecExtTrack*)0);
696 }
697 // Static variable to force the class initialization
698 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
699} // end of namespace ROOT
700
701namespace ROOT {
702 void TRecEvTime_ShowMembers(void *obj, TMemberInspector &R__insp);
703 static void *new_TRecEvTime(void *p = 0);
704 static void *newArray_TRecEvTime(Long_t size, void *p);
705 static void delete_TRecEvTime(void *p);
706 static void deleteArray_TRecEvTime(void *p);
707 static void destruct_TRecEvTime(void *p);
708
709 // Function generating the singleton type initializer
710 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEvTime*)
711 {
712 ::TRecEvTime *ptr = 0;
713 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEvTime >(0);
714 static ::ROOT::TGenericClassInfo
715 instance("TRecEvTime", ::TRecEvTime::Class_Version(), "./../RootEventData/TRecEvTime.h", 10,
716 typeid(::TRecEvTime), DefineBehavior(ptr, ptr),
717 &::TRecEvTime::Dictionary, isa_proxy, 4,
718 sizeof(::TRecEvTime) );
719 instance.SetNew(&new_TRecEvTime);
720 instance.SetNewArray(&newArray_TRecEvTime);
721 instance.SetDelete(&delete_TRecEvTime);
722 instance.SetDeleteArray(&deleteArray_TRecEvTime);
723 instance.SetDestructor(&destruct_TRecEvTime);
724 return &instance;
725 }
726 TGenericClassInfo *GenerateInitInstance(const ::TRecEvTime*)
727 {
728 return GenerateInitInstanceLocal((::TRecEvTime*)0);
729 }
730 // Static variable to force the class initialization
731 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEvTime*)0x0); R__UseDummy(_R__UNIQUE_(Init));
732} // end of namespace ROOT
733
734namespace ROOT {
735 void TRecMdcKalHelixSeg_ShowMembers(void *obj, TMemberInspector &R__insp);
736 static void *new_TRecMdcKalHelixSeg(void *p = 0);
737 static void *newArray_TRecMdcKalHelixSeg(Long_t size, void *p);
738 static void delete_TRecMdcKalHelixSeg(void *p);
739 static void deleteArray_TRecMdcKalHelixSeg(void *p);
740 static void destruct_TRecMdcKalHelixSeg(void *p);
741
742 // Function generating the singleton type initializer
743 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcKalHelixSeg*)
744 {
745 ::TRecMdcKalHelixSeg *ptr = 0;
746 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalHelixSeg >(0);
747 static ::ROOT::TGenericClassInfo
748 instance("TRecMdcKalHelixSeg", ::TRecMdcKalHelixSeg::Class_Version(), "./../RootEventData/TRecMdcKalHelixSeg.h", 9,
749 typeid(::TRecMdcKalHelixSeg), DefineBehavior(ptr, ptr),
750 &::TRecMdcKalHelixSeg::Dictionary, isa_proxy, 4,
751 sizeof(::TRecMdcKalHelixSeg) );
752 instance.SetNew(&new_TRecMdcKalHelixSeg);
753 instance.SetNewArray(&newArray_TRecMdcKalHelixSeg);
754 instance.SetDelete(&delete_TRecMdcKalHelixSeg);
755 instance.SetDeleteArray(&deleteArray_TRecMdcKalHelixSeg);
756 instance.SetDestructor(&destruct_TRecMdcKalHelixSeg);
757 return &instance;
758 }
759 TGenericClassInfo *GenerateInitInstance(const ::TRecMdcKalHelixSeg*)
760 {
761 return GenerateInitInstanceLocal((::TRecMdcKalHelixSeg*)0);
762 }
763 // Static variable to force the class initialization
764 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0); R__UseDummy(_R__UNIQUE_(Init));
765} // end of namespace ROOT
766
767namespace ROOT {
768 void TRecZddChannel_ShowMembers(void *obj, TMemberInspector &R__insp);
769 static void *new_TRecZddChannel(void *p = 0);
770 static void *newArray_TRecZddChannel(Long_t size, void *p);
771 static void delete_TRecZddChannel(void *p);
772 static void deleteArray_TRecZddChannel(void *p);
773 static void destruct_TRecZddChannel(void *p);
774
775 // Function generating the singleton type initializer
776 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecZddChannel*)
777 {
778 ::TRecZddChannel *ptr = 0;
779 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecZddChannel >(0);
780 static ::ROOT::TGenericClassInfo
781 instance("TRecZddChannel", ::TRecZddChannel::Class_Version(), "./../RootEventData/TRecZddChannel.h", 9,
782 typeid(::TRecZddChannel), DefineBehavior(ptr, ptr),
783 &::TRecZddChannel::Dictionary, isa_proxy, 4,
784 sizeof(::TRecZddChannel) );
785 instance.SetNew(&new_TRecZddChannel);
786 instance.SetNewArray(&newArray_TRecZddChannel);
787 instance.SetDelete(&delete_TRecZddChannel);
788 instance.SetDeleteArray(&deleteArray_TRecZddChannel);
789 instance.SetDestructor(&destruct_TRecZddChannel);
790 return &instance;
791 }
792 TGenericClassInfo *GenerateInitInstance(const ::TRecZddChannel*)
793 {
794 return GenerateInitInstanceLocal((::TRecZddChannel*)0);
795 }
796 // Static variable to force the class initialization
797 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
798} // end of namespace ROOT
799
800namespace ROOT {
801 void TRecTrackEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
802 static void *new_TRecTrackEvent(void *p = 0);
803 static void *newArray_TRecTrackEvent(Long_t size, void *p);
804 static void delete_TRecTrackEvent(void *p);
805 static void deleteArray_TRecTrackEvent(void *p);
806 static void destruct_TRecTrackEvent(void *p);
807
808 // Function generating the singleton type initializer
809 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecTrackEvent*)
810 {
811 ::TRecTrackEvent *ptr = 0;
812 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTrackEvent >(0);
813 static ::ROOT::TGenericClassInfo
814 instance("TRecTrackEvent", ::TRecTrackEvent::Class_Version(), "./../RootEventData/TRecTrackEvent.h", 24,
815 typeid(::TRecTrackEvent), DefineBehavior(ptr, ptr),
816 &::TRecTrackEvent::Dictionary, isa_proxy, 4,
817 sizeof(::TRecTrackEvent) );
818 instance.SetNew(&new_TRecTrackEvent);
819 instance.SetNewArray(&newArray_TRecTrackEvent);
820 instance.SetDelete(&delete_TRecTrackEvent);
821 instance.SetDeleteArray(&deleteArray_TRecTrackEvent);
822 instance.SetDestructor(&destruct_TRecTrackEvent);
823 return &instance;
824 }
825 TGenericClassInfo *GenerateInitInstance(const ::TRecTrackEvent*)
826 {
827 return GenerateInitInstanceLocal((::TRecTrackEvent*)0);
828 }
829 // Static variable to force the class initialization
830 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
831} // end of namespace ROOT
832
833namespace ROOT {
834 void TMdcTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
835 static void *new_TMdcTrack(void *p = 0);
836 static void *newArray_TMdcTrack(Long_t size, void *p);
837 static void delete_TMdcTrack(void *p);
838 static void deleteArray_TMdcTrack(void *p);
839 static void destruct_TMdcTrack(void *p);
840
841 // Function generating the singleton type initializer
842 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcTrack*)
843 {
844 ::TMdcTrack *ptr = 0;
845 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcTrack >(0);
846 static ::ROOT::TGenericClassInfo
847 instance("TMdcTrack", ::TMdcTrack::Class_Version(), "./../RootEventData/TMdcTrack.h", 6,
848 typeid(::TMdcTrack), DefineBehavior(ptr, ptr),
849 &::TMdcTrack::Dictionary, isa_proxy, 4,
850 sizeof(::TMdcTrack) );
851 instance.SetNew(&new_TMdcTrack);
852 instance.SetNewArray(&newArray_TMdcTrack);
853 instance.SetDelete(&delete_TMdcTrack);
854 instance.SetDeleteArray(&deleteArray_TMdcTrack);
855 instance.SetDestructor(&destruct_TMdcTrack);
856 return &instance;
857 }
858 TGenericClassInfo *GenerateInitInstance(const ::TMdcTrack*)
859 {
860 return GenerateInitInstanceLocal((::TMdcTrack*)0);
861 }
862 // Static variable to force the class initialization
863 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
864} // end of namespace ROOT
865
866namespace ROOT {
867 void TEmcTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
868 static void *new_TEmcTrack(void *p = 0);
869 static void *newArray_TEmcTrack(Long_t size, void *p);
870 static void delete_TEmcTrack(void *p);
871 static void deleteArray_TEmcTrack(void *p);
872 static void destruct_TEmcTrack(void *p);
873
874 // Function generating the singleton type initializer
875 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcTrack*)
876 {
877 ::TEmcTrack *ptr = 0;
878 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcTrack >(0);
879 static ::ROOT::TGenericClassInfo
880 instance("TEmcTrack", ::TEmcTrack::Class_Version(), "./../RootEventData/TEmcTrack.h", 7,
881 typeid(::TEmcTrack), DefineBehavior(ptr, ptr),
882 &::TEmcTrack::Dictionary, isa_proxy, 4,
883 sizeof(::TEmcTrack) );
884 instance.SetNew(&new_TEmcTrack);
885 instance.SetNewArray(&newArray_TEmcTrack);
886 instance.SetDelete(&delete_TEmcTrack);
887 instance.SetDeleteArray(&deleteArray_TEmcTrack);
888 instance.SetDestructor(&destruct_TEmcTrack);
889 return &instance;
890 }
891 TGenericClassInfo *GenerateInitInstance(const ::TEmcTrack*)
892 {
893 return GenerateInitInstanceLocal((::TEmcTrack*)0);
894 }
895 // Static variable to force the class initialization
896 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmcTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
897} // end of namespace ROOT
898
899namespace ROOT {
900 void TMucTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
901 static void *new_TMucTrack(void *p = 0);
902 static void *newArray_TMucTrack(Long_t size, void *p);
903 static void delete_TMucTrack(void *p);
904 static void deleteArray_TMucTrack(void *p);
905 static void destruct_TMucTrack(void *p);
906
907 // Function generating the singleton type initializer
908 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucTrack*)
909 {
910 ::TMucTrack *ptr = 0;
911 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucTrack >(0);
912 static ::ROOT::TGenericClassInfo
913 instance("TMucTrack", ::TMucTrack::Class_Version(), "./../RootEventData/TMucTrack.h", 9,
914 typeid(::TMucTrack), DefineBehavior(ptr, ptr),
915 &::TMucTrack::Dictionary, isa_proxy, 4,
916 sizeof(::TMucTrack) );
917 instance.SetNew(&new_TMucTrack);
918 instance.SetNewArray(&newArray_TMucTrack);
919 instance.SetDelete(&delete_TMucTrack);
920 instance.SetDeleteArray(&deleteArray_TMucTrack);
921 instance.SetDestructor(&destruct_TMucTrack);
922 return &instance;
923 }
924 TGenericClassInfo *GenerateInitInstance(const ::TMucTrack*)
925 {
926 return GenerateInitInstanceLocal((::TMucTrack*)0);
927 }
928 // Static variable to force the class initialization
929 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMucTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
930} // end of namespace ROOT
931
932namespace ROOT {
933 void TMdcDedx_ShowMembers(void *obj, TMemberInspector &R__insp);
934 static void *new_TMdcDedx(void *p = 0);
935 static void *newArray_TMdcDedx(Long_t size, void *p);
936 static void delete_TMdcDedx(void *p);
937 static void deleteArray_TMdcDedx(void *p);
938 static void destruct_TMdcDedx(void *p);
939
940 // Function generating the singleton type initializer
941 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcDedx*)
942 {
943 ::TMdcDedx *ptr = 0;
944 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDedx >(0);
945 static ::ROOT::TGenericClassInfo
946 instance("TMdcDedx", ::TMdcDedx::Class_Version(), "./../RootEventData/TMdcDedx.h", 6,
947 typeid(::TMdcDedx), DefineBehavior(ptr, ptr),
948 &::TMdcDedx::Dictionary, isa_proxy, 4,
949 sizeof(::TMdcDedx) );
950 instance.SetNew(&new_TMdcDedx);
951 instance.SetNewArray(&newArray_TMdcDedx);
952 instance.SetDelete(&delete_TMdcDedx);
953 instance.SetDeleteArray(&deleteArray_TMdcDedx);
954 instance.SetDestructor(&destruct_TMdcDedx);
955 return &instance;
956 }
957 TGenericClassInfo *GenerateInitInstance(const ::TMdcDedx*)
958 {
959 return GenerateInitInstanceLocal((::TMdcDedx*)0);
960 }
961 // Static variable to force the class initialization
962 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcDedx*)0x0); R__UseDummy(_R__UNIQUE_(Init));
963} // end of namespace ROOT
964
965namespace ROOT {
966 void TExtTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
967 static void *new_TExtTrack(void *p = 0);
968 static void *newArray_TExtTrack(Long_t size, void *p);
969 static void delete_TExtTrack(void *p);
970 static void deleteArray_TExtTrack(void *p);
971 static void destruct_TExtTrack(void *p);
972
973 // Function generating the singleton type initializer
974 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TExtTrack*)
975 {
976 ::TExtTrack *ptr = 0;
977 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExtTrack >(0);
978 static ::ROOT::TGenericClassInfo
979 instance("TExtTrack", ::TExtTrack::Class_Version(), "./../RootEventData/TExtTrack.h", 9,
980 typeid(::TExtTrack), DefineBehavior(ptr, ptr),
981 &::TExtTrack::Dictionary, isa_proxy, 4,
982 sizeof(::TExtTrack) );
983 instance.SetNew(&new_TExtTrack);
984 instance.SetNewArray(&newArray_TExtTrack);
985 instance.SetDelete(&delete_TExtTrack);
986 instance.SetDeleteArray(&deleteArray_TExtTrack);
987 instance.SetDestructor(&destruct_TExtTrack);
988 return &instance;
989 }
990 TGenericClassInfo *GenerateInitInstance(const ::TExtTrack*)
991 {
992 return GenerateInitInstanceLocal((::TExtTrack*)0);
993 }
994 // Static variable to force the class initialization
995 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TExtTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
996} // end of namespace ROOT
997
998namespace ROOT {
999 void TMdcKalTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
1000 static void *new_TMdcKalTrack(void *p = 0);
1001 static void *newArray_TMdcKalTrack(Long_t size, void *p);
1002 static void delete_TMdcKalTrack(void *p);
1003 static void deleteArray_TMdcKalTrack(void *p);
1004 static void destruct_TMdcKalTrack(void *p);
1005
1006 // Function generating the singleton type initializer
1007 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcKalTrack*)
1008 {
1009 ::TMdcKalTrack *ptr = 0;
1010 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcKalTrack >(0);
1011 static ::ROOT::TGenericClassInfo
1012 instance("TMdcKalTrack", ::TMdcKalTrack::Class_Version(), "./../RootEventData/TMdcKalTrack.h", 8,
1013 typeid(::TMdcKalTrack), DefineBehavior(ptr, ptr),
1014 &::TMdcKalTrack::Dictionary, isa_proxy, 4,
1015 sizeof(::TMdcKalTrack) );
1016 instance.SetNew(&new_TMdcKalTrack);
1017 instance.SetNewArray(&newArray_TMdcKalTrack);
1018 instance.SetDelete(&delete_TMdcKalTrack);
1019 instance.SetDeleteArray(&deleteArray_TMdcKalTrack);
1020 instance.SetDestructor(&destruct_TMdcKalTrack);
1021 return &instance;
1022 }
1023 TGenericClassInfo *GenerateInitInstance(const ::TMdcKalTrack*)
1024 {
1025 return GenerateInitInstanceLocal((::TMdcKalTrack*)0);
1026 }
1027 // Static variable to force the class initialization
1028 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1029} // end of namespace ROOT
1030
1031namespace ROOT {
1032 void TDstEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1033 static void *new_TDstEvent(void *p = 0);
1034 static void *newArray_TDstEvent(Long_t size, void *p);
1035 static void delete_TDstEvent(void *p);
1036 static void deleteArray_TDstEvent(void *p);
1037 static void destruct_TDstEvent(void *p);
1038
1039 // Function generating the singleton type initializer
1040 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDstEvent*)
1041 {
1042 ::TDstEvent *ptr = 0;
1043 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstEvent >(0);
1044 static ::ROOT::TGenericClassInfo
1045 instance("TDstEvent", ::TDstEvent::Class_Version(), "./../RootEventData/TDstEvent.h", 16,
1046 typeid(::TDstEvent), DefineBehavior(ptr, ptr),
1047 &::TDstEvent::Dictionary, isa_proxy, 4,
1048 sizeof(::TDstEvent) );
1049 instance.SetNew(&new_TDstEvent);
1050 instance.SetNewArray(&newArray_TDstEvent);
1051 instance.SetDelete(&delete_TDstEvent);
1052 instance.SetDeleteArray(&deleteArray_TDstEvent);
1053 instance.SetDestructor(&destruct_TDstEvent);
1054 return &instance;
1055 }
1056 TGenericClassInfo *GenerateInitInstance(const ::TDstEvent*)
1057 {
1058 return GenerateInitInstanceLocal((::TDstEvent*)0);
1059 }
1060 // Static variable to force the class initialization
1061 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDstEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1062} // end of namespace ROOT
1063
1064namespace ROOT {
1065 void TMdcMc_ShowMembers(void *obj, TMemberInspector &R__insp);
1066 static void *new_TMdcMc(void *p = 0);
1067 static void *newArray_TMdcMc(Long_t size, void *p);
1068 static void delete_TMdcMc(void *p);
1069 static void deleteArray_TMdcMc(void *p);
1070 static void destruct_TMdcMc(void *p);
1071
1072 // Function generating the singleton type initializer
1073 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcMc*)
1074 {
1075 ::TMdcMc *ptr = 0;
1076 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcMc >(0);
1077 static ::ROOT::TGenericClassInfo
1078 instance("TMdcMc", ::TMdcMc::Class_Version(), "./../RootEventData/TMdcMc.h", 8,
1079 typeid(::TMdcMc), DefineBehavior(ptr, ptr),
1080 &::TMdcMc::Dictionary, isa_proxy, 4,
1081 sizeof(::TMdcMc) );
1082 instance.SetNew(&new_TMdcMc);
1083 instance.SetNewArray(&newArray_TMdcMc);
1084 instance.SetDelete(&delete_TMdcMc);
1085 instance.SetDeleteArray(&deleteArray_TMdcMc);
1086 instance.SetDestructor(&destruct_TMdcMc);
1087 return &instance;
1088 }
1089 TGenericClassInfo *GenerateInitInstance(const ::TMdcMc*)
1090 {
1091 return GenerateInitInstanceLocal((::TMdcMc*)0);
1092 }
1093 // Static variable to force the class initialization
1094 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1095} // end of namespace ROOT
1096
1097namespace ROOT {
1098 void TEmcMc_ShowMembers(void *obj, TMemberInspector &R__insp);
1099 static void *new_TEmcMc(void *p = 0);
1100 static void *newArray_TEmcMc(Long_t size, void *p);
1101 static void delete_TEmcMc(void *p);
1102 static void deleteArray_TEmcMc(void *p);
1103 static void destruct_TEmcMc(void *p);
1104
1105 // Function generating the singleton type initializer
1106 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcMc*)
1107 {
1108 ::TEmcMc *ptr = 0;
1109 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcMc >(0);
1110 static ::ROOT::TGenericClassInfo
1111 instance("TEmcMc", ::TEmcMc::Class_Version(), "./../RootEventData/TEmcMc.h", 10,
1112 typeid(::TEmcMc), DefineBehavior(ptr, ptr),
1113 &::TEmcMc::Dictionary, isa_proxy, 4,
1114 sizeof(::TEmcMc) );
1115 instance.SetNew(&new_TEmcMc);
1116 instance.SetNewArray(&newArray_TEmcMc);
1117 instance.SetDelete(&delete_TEmcMc);
1118 instance.SetDeleteArray(&deleteArray_TEmcMc);
1119 instance.SetDestructor(&destruct_TEmcMc);
1120 return &instance;
1121 }
1122 TGenericClassInfo *GenerateInitInstance(const ::TEmcMc*)
1123 {
1124 return GenerateInitInstanceLocal((::TEmcMc*)0);
1125 }
1126 // Static variable to force the class initialization
1127 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmcMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1128} // end of namespace ROOT
1129
1130namespace ROOT {
1131 void TTofMc_ShowMembers(void *obj, TMemberInspector &R__insp);
1132 static void *new_TTofMc(void *p = 0);
1133 static void *newArray_TTofMc(Long_t size, void *p);
1134 static void delete_TTofMc(void *p);
1135 static void deleteArray_TTofMc(void *p);
1136 static void destruct_TTofMc(void *p);
1137
1138 // Function generating the singleton type initializer
1139 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofMc*)
1140 {
1141 ::TTofMc *ptr = 0;
1142 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofMc >(0);
1143 static ::ROOT::TGenericClassInfo
1144 instance("TTofMc", ::TTofMc::Class_Version(), "./../RootEventData/TTofMc.h", 8,
1145 typeid(::TTofMc), DefineBehavior(ptr, ptr),
1146 &::TTofMc::Dictionary, isa_proxy, 4,
1147 sizeof(::TTofMc) );
1148 instance.SetNew(&new_TTofMc);
1149 instance.SetNewArray(&newArray_TTofMc);
1150 instance.SetDelete(&delete_TTofMc);
1151 instance.SetDeleteArray(&deleteArray_TTofMc);
1152 instance.SetDestructor(&destruct_TTofMc);
1153 return &instance;
1154 }
1155 TGenericClassInfo *GenerateInitInstance(const ::TTofMc*)
1156 {
1157 return GenerateInitInstanceLocal((::TTofMc*)0);
1158 }
1159 // Static variable to force the class initialization
1160 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTofMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1161} // end of namespace ROOT
1162
1163namespace ROOT {
1164 void TMucMc_ShowMembers(void *obj, TMemberInspector &R__insp);
1165 static void *new_TMucMc(void *p = 0);
1166 static void *newArray_TMucMc(Long_t size, void *p);
1167 static void delete_TMucMc(void *p);
1168 static void deleteArray_TMucMc(void *p);
1169 static void destruct_TMucMc(void *p);
1170
1171 // Function generating the singleton type initializer
1172 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucMc*)
1173 {
1174 ::TMucMc *ptr = 0;
1175 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucMc >(0);
1176 static ::ROOT::TGenericClassInfo
1177 instance("TMucMc", ::TMucMc::Class_Version(), "./../RootEventData/TMucMc.h", 8,
1178 typeid(::TMucMc), DefineBehavior(ptr, ptr),
1179 &::TMucMc::Dictionary, isa_proxy, 4,
1180 sizeof(::TMucMc) );
1181 instance.SetNew(&new_TMucMc);
1182 instance.SetNewArray(&newArray_TMucMc);
1183 instance.SetDelete(&delete_TMucMc);
1184 instance.SetDeleteArray(&deleteArray_TMucMc);
1185 instance.SetDestructor(&destruct_TMucMc);
1186 return &instance;
1187 }
1188 TGenericClassInfo *GenerateInitInstance(const ::TMucMc*)
1189 {
1190 return GenerateInitInstanceLocal((::TMucMc*)0);
1191 }
1192 // Static variable to force the class initialization
1193 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMucMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1194} // end of namespace ROOT
1195
1196namespace ROOT {
1197 void TMcParticle_ShowMembers(void *obj, TMemberInspector &R__insp);
1198 static void *new_TMcParticle(void *p = 0);
1199 static void *newArray_TMcParticle(Long_t size, void *p);
1200 static void delete_TMcParticle(void *p);
1201 static void deleteArray_TMcParticle(void *p);
1202 static void destruct_TMcParticle(void *p);
1203
1204 // Function generating the singleton type initializer
1205 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcParticle*)
1206 {
1207 ::TMcParticle *ptr = 0;
1208 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcParticle >(0);
1209 static ::ROOT::TGenericClassInfo
1210 instance("TMcParticle", ::TMcParticle::Class_Version(), "./../RootEventData/TMcParticle.h", 9,
1211 typeid(::TMcParticle), DefineBehavior(ptr, ptr),
1212 &::TMcParticle::Dictionary, isa_proxy, 4,
1213 sizeof(::TMcParticle) );
1214 instance.SetNew(&new_TMcParticle);
1215 instance.SetNewArray(&newArray_TMcParticle);
1216 instance.SetDelete(&delete_TMcParticle);
1217 instance.SetDeleteArray(&deleteArray_TMcParticle);
1218 instance.SetDestructor(&destruct_TMcParticle);
1219 return &instance;
1220 }
1221 TGenericClassInfo *GenerateInitInstance(const ::TMcParticle*)
1222 {
1223 return GenerateInitInstanceLocal((::TMcParticle*)0);
1224 }
1225 // Static variable to force the class initialization
1226 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcParticle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1227} // end of namespace ROOT
1228
1229namespace ROOT {
1230 void TMcEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1231 static void *new_TMcEvent(void *p = 0);
1232 static void *newArray_TMcEvent(Long_t size, void *p);
1233 static void delete_TMcEvent(void *p);
1234 static void deleteArray_TMcEvent(void *p);
1235 static void destruct_TMcEvent(void *p);
1236
1237 // Function generating the singleton type initializer
1238 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcEvent*)
1239 {
1240 ::TMcEvent *ptr = 0;
1241 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcEvent >(0);
1242 static ::ROOT::TGenericClassInfo
1243 instance("TMcEvent", ::TMcEvent::Class_Version(), "./../RootEventData/TMcEvent.h", 16,
1244 typeid(::TMcEvent), DefineBehavior(ptr, ptr),
1245 &::TMcEvent::Dictionary, isa_proxy, 4,
1246 sizeof(::TMcEvent) );
1247 instance.SetNew(&new_TMcEvent);
1248 instance.SetNewArray(&newArray_TMcEvent);
1249 instance.SetDelete(&delete_TMcEvent);
1250 instance.SetDeleteArray(&deleteArray_TMcEvent);
1251 instance.SetDestructor(&destruct_TMcEvent);
1252 return &instance;
1253 }
1254 TGenericClassInfo *GenerateInitInstance(const ::TMcEvent*)
1255 {
1256 return GenerateInitInstanceLocal((::TMcEvent*)0);
1257 }
1258 // Static variable to force the class initialization
1259 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1260} // end of namespace ROOT
1261
1262namespace ROOT {
1263 void TEvtHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
1264 static void *new_TEvtHeader(void *p = 0);
1265 static void *newArray_TEvtHeader(Long_t size, void *p);
1266 static void delete_TEvtHeader(void *p);
1267 static void deleteArray_TEvtHeader(void *p);
1268 static void destruct_TEvtHeader(void *p);
1269
1270 // Function generating the singleton type initializer
1271 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtHeader*)
1272 {
1273 ::TEvtHeader *ptr = 0;
1274 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtHeader >(0);
1275 static ::ROOT::TGenericClassInfo
1276 instance("TEvtHeader", ::TEvtHeader::Class_Version(), "./../RootEventData/TEvtHeader.h", 8,
1277 typeid(::TEvtHeader), DefineBehavior(ptr, ptr),
1278 &::TEvtHeader::Dictionary, isa_proxy, 4,
1279 sizeof(::TEvtHeader) );
1280 instance.SetNew(&new_TEvtHeader);
1281 instance.SetNewArray(&newArray_TEvtHeader);
1282 instance.SetDelete(&delete_TEvtHeader);
1283 instance.SetDeleteArray(&deleteArray_TEvtHeader);
1284 instance.SetDestructor(&destruct_TEvtHeader);
1285 return &instance;
1286 }
1287 TGenericClassInfo *GenerateInitInstance(const ::TEvtHeader*)
1288 {
1289 return GenerateInitInstanceLocal((::TEvtHeader*)0);
1290 }
1291 // Static variable to force the class initialization
1292 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1293} // end of namespace ROOT
1294
1295namespace ROOT {
1296 void TEvtNavigator_ShowMembers(void *obj, TMemberInspector &R__insp);
1297 static void *new_TEvtNavigator(void *p = 0);
1298 static void *newArray_TEvtNavigator(Long_t size, void *p);
1299 static void delete_TEvtNavigator(void *p);
1300 static void deleteArray_TEvtNavigator(void *p);
1301 static void destruct_TEvtNavigator(void *p);
1302
1303 // Function generating the singleton type initializer
1304 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtNavigator*)
1305 {
1306 ::TEvtNavigator *ptr = 0;
1307 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtNavigator >(0);
1308 static ::ROOT::TGenericClassInfo
1309 instance("TEvtNavigator", ::TEvtNavigator::Class_Version(), "./../RootEventData/TEvtNavigator.h", 11,
1310 typeid(::TEvtNavigator), DefineBehavior(ptr, ptr),
1311 &::TEvtNavigator::Dictionary, isa_proxy, 4,
1312 sizeof(::TEvtNavigator) );
1313 instance.SetNew(&new_TEvtNavigator);
1314 instance.SetNewArray(&newArray_TEvtNavigator);
1315 instance.SetDelete(&delete_TEvtNavigator);
1316 instance.SetDeleteArray(&deleteArray_TEvtNavigator);
1317 instance.SetDestructor(&destruct_TEvtNavigator);
1318 return &instance;
1319 }
1320 TGenericClassInfo *GenerateInitInstance(const ::TEvtNavigator*)
1321 {
1322 return GenerateInitInstanceLocal((::TEvtNavigator*)0);
1323 }
1324 // Static variable to force the class initialization
1325 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1326} // end of namespace ROOT
1327
1328namespace ROOT {
1329 void TTrigData_ShowMembers(void *obj, TMemberInspector &R__insp);
1330 static void *new_TTrigData(void *p = 0);
1331 static void *newArray_TTrigData(Long_t size, void *p);
1332 static void delete_TTrigData(void *p);
1333 static void deleteArray_TTrigData(void *p);
1334 static void destruct_TTrigData(void *p);
1335
1336 // Function generating the singleton type initializer
1337 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTrigData*)
1338 {
1339 ::TTrigData *ptr = 0;
1340 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigData >(0);
1341 static ::ROOT::TGenericClassInfo
1342 instance("TTrigData", ::TTrigData::Class_Version(), "./../RootEventData/TTrigData.h", 8,
1343 typeid(::TTrigData), DefineBehavior(ptr, ptr),
1344 &::TTrigData::Dictionary, isa_proxy, 4,
1345 sizeof(::TTrigData) );
1346 instance.SetNew(&new_TTrigData);
1347 instance.SetNewArray(&newArray_TTrigData);
1348 instance.SetDelete(&delete_TTrigData);
1349 instance.SetDeleteArray(&deleteArray_TTrigData);
1350 instance.SetDestructor(&destruct_TTrigData);
1351 return &instance;
1352 }
1353 TGenericClassInfo *GenerateInitInstance(const ::TTrigData*)
1354 {
1355 return GenerateInitInstanceLocal((::TTrigData*)0);
1356 }
1357 // Static variable to force the class initialization
1358 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTrigData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1359} // end of namespace ROOT
1360
1361namespace ROOT {
1362 void TTrigEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1363 static void *new_TTrigEvent(void *p = 0);
1364 static void *newArray_TTrigEvent(Long_t size, void *p);
1365 static void delete_TTrigEvent(void *p);
1366 static void deleteArray_TTrigEvent(void *p);
1367 static void destruct_TTrigEvent(void *p);
1368
1369 // Function generating the singleton type initializer
1370 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTrigEvent*)
1371 {
1372 ::TTrigEvent *ptr = 0;
1373 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigEvent >(0);
1374 static ::ROOT::TGenericClassInfo
1375 instance("TTrigEvent", ::TTrigEvent::Class_Version(), "./../RootEventData/TTrigEvent.h", 10,
1376 typeid(::TTrigEvent), DefineBehavior(ptr, ptr),
1377 &::TTrigEvent::Dictionary, isa_proxy, 4,
1378 sizeof(::TTrigEvent) );
1379 instance.SetNew(&new_TTrigEvent);
1380 instance.SetNewArray(&newArray_TTrigEvent);
1381 instance.SetDelete(&delete_TTrigEvent);
1382 instance.SetDeleteArray(&deleteArray_TTrigEvent);
1383 instance.SetDestructor(&destruct_TTrigEvent);
1384 return &instance;
1385 }
1386 TGenericClassInfo *GenerateInitInstance(const ::TTrigEvent*)
1387 {
1388 return GenerateInitInstanceLocal((::TTrigEvent*)0);
1389 }
1390 // Static variable to force the class initialization
1391 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTrigEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1392} // end of namespace ROOT
1393
1394namespace ROOT {
1395 void THltRaw_ShowMembers(void *obj, TMemberInspector &R__insp);
1396 static void *new_THltRaw(void *p = 0);
1397 static void *newArray_THltRaw(Long_t size, void *p);
1398 static void delete_THltRaw(void *p);
1399 static void deleteArray_THltRaw(void *p);
1400 static void destruct_THltRaw(void *p);
1401
1402 // Function generating the singleton type initializer
1403 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltRaw*)
1404 {
1405 ::THltRaw *ptr = 0;
1406 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltRaw >(0);
1407 static ::ROOT::TGenericClassInfo
1408 instance("THltRaw", ::THltRaw::Class_Version(), "./../RootEventData/THltRaw.h", 7,
1409 typeid(::THltRaw), DefineBehavior(ptr, ptr),
1410 &::THltRaw::Dictionary, isa_proxy, 4,
1411 sizeof(::THltRaw) );
1412 instance.SetNew(&new_THltRaw);
1413 instance.SetNewArray(&newArray_THltRaw);
1414 instance.SetDelete(&delete_THltRaw);
1415 instance.SetDeleteArray(&deleteArray_THltRaw);
1416 instance.SetDestructor(&destruct_THltRaw);
1417 return &instance;
1418 }
1419 TGenericClassInfo *GenerateInitInstance(const ::THltRaw*)
1420 {
1421 return GenerateInitInstanceLocal((::THltRaw*)0);
1422 }
1423 // Static variable to force the class initialization
1424 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THltRaw*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1425} // end of namespace ROOT
1426
1427namespace ROOT {
1428 void THltInf_ShowMembers(void *obj, TMemberInspector &R__insp);
1429 static void *new_THltInf(void *p = 0);
1430 static void *newArray_THltInf(Long_t size, void *p);
1431 static void delete_THltInf(void *p);
1432 static void deleteArray_THltInf(void *p);
1433 static void destruct_THltInf(void *p);
1434
1435 // Function generating the singleton type initializer
1436 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltInf*)
1437 {
1438 ::THltInf *ptr = 0;
1439 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltInf >(0);
1440 static ::ROOT::TGenericClassInfo
1441 instance("THltInf", ::THltInf::Class_Version(), "./../RootEventData/THltInf.h", 9,
1442 typeid(::THltInf), DefineBehavior(ptr, ptr),
1443 &::THltInf::Dictionary, isa_proxy, 4,
1444 sizeof(::THltInf) );
1445 instance.SetNew(&new_THltInf);
1446 instance.SetNewArray(&newArray_THltInf);
1447 instance.SetDelete(&delete_THltInf);
1448 instance.SetDeleteArray(&deleteArray_THltInf);
1449 instance.SetDestructor(&destruct_THltInf);
1450 return &instance;
1451 }
1452 TGenericClassInfo *GenerateInitInstance(const ::THltInf*)
1453 {
1454 return GenerateInitInstanceLocal((::THltInf*)0);
1455 }
1456 // Static variable to force the class initialization
1457 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THltInf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1458} // end of namespace ROOT
1459
1460namespace ROOT {
1461 void TDstHltInf_ShowMembers(void *obj, TMemberInspector &R__insp);
1462 static void *new_TDstHltInf(void *p = 0);
1463 static void *newArray_TDstHltInf(Long_t size, void *p);
1464 static void delete_TDstHltInf(void *p);
1465 static void deleteArray_TDstHltInf(void *p);
1466 static void destruct_TDstHltInf(void *p);
1467
1468 // Function generating the singleton type initializer
1469 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDstHltInf*)
1470 {
1471 ::TDstHltInf *ptr = 0;
1472 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstHltInf >(0);
1473 static ::ROOT::TGenericClassInfo
1474 instance("TDstHltInf", ::TDstHltInf::Class_Version(), "./../RootEventData/TDstHltInf.h", 9,
1475 typeid(::TDstHltInf), DefineBehavior(ptr, ptr),
1476 &::TDstHltInf::Dictionary, isa_proxy, 4,
1477 sizeof(::TDstHltInf) );
1478 instance.SetNew(&new_TDstHltInf);
1479 instance.SetNewArray(&newArray_TDstHltInf);
1480 instance.SetDelete(&delete_TDstHltInf);
1481 instance.SetDeleteArray(&deleteArray_TDstHltInf);
1482 instance.SetDestructor(&destruct_TDstHltInf);
1483 return &instance;
1484 }
1485 TGenericClassInfo *GenerateInitInstance(const ::TDstHltInf*)
1486 {
1487 return GenerateInitInstanceLocal((::TDstHltInf*)0);
1488 }
1489 // Static variable to force the class initialization
1490 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDstHltInf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1491} // end of namespace ROOT
1492
1493namespace ROOT {
1494 void THltEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1495 static void *new_THltEvent(void *p = 0);
1496 static void *newArray_THltEvent(Long_t size, void *p);
1497 static void delete_THltEvent(void *p);
1498 static void deleteArray_THltEvent(void *p);
1499 static void destruct_THltEvent(void *p);
1500
1501 // Function generating the singleton type initializer
1502 static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltEvent*)
1503 {
1504 ::THltEvent *ptr = 0;
1505 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltEvent >(0);
1506 static ::ROOT::TGenericClassInfo
1507 instance("THltEvent", ::THltEvent::Class_Version(), "./../RootEventData/THltEvent.h", 12,
1508 typeid(::THltEvent), DefineBehavior(ptr, ptr),
1509 &::THltEvent::Dictionary, isa_proxy, 4,
1510 sizeof(::THltEvent) );
1511 instance.SetNew(&new_THltEvent);
1512 instance.SetNewArray(&newArray_THltEvent);
1513 instance.SetDelete(&delete_THltEvent);
1514 instance.SetDeleteArray(&deleteArray_THltEvent);
1515 instance.SetDestructor(&destruct_THltEvent);
1516 return &instance;
1517 }
1518 TGenericClassInfo *GenerateInitInstance(const ::THltEvent*)
1519 {
1520 return GenerateInitInstanceLocal((::THltEvent*)0);
1521 }
1522 // Static variable to force the class initialization
1523 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THltEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1524} // end of namespace ROOT
1525
1526namespace ROOT {
1527 void TDisTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
1528 static void *new_TDisTrack(void *p = 0);
1529 static void *newArray_TDisTrack(Long_t size, void *p);
1530 static void delete_TDisTrack(void *p);
1531 static void deleteArray_TDisTrack(void *p);
1532 static void destruct_TDisTrack(void *p);
1533 static void streamer_TDisTrack(TBuffer &buf, void *obj);
1534
1535 // Function generating the singleton type initializer
1536 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDisTrack*)
1537 {
1538 ::TDisTrack *ptr = 0;
1539 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDisTrack >(0);
1540 static ::ROOT::TGenericClassInfo
1541 instance("TDisTrack", ::TDisTrack::Class_Version(), "./../RootEventData/TDisTrack.h", 12,
1542 typeid(::TDisTrack), DefineBehavior(ptr, ptr),
1543 &::TDisTrack::Dictionary, isa_proxy, 0,
1544 sizeof(::TDisTrack) );
1545 instance.SetNew(&new_TDisTrack);
1546 instance.SetNewArray(&newArray_TDisTrack);
1547 instance.SetDelete(&delete_TDisTrack);
1548 instance.SetDeleteArray(&deleteArray_TDisTrack);
1549 instance.SetDestructor(&destruct_TDisTrack);
1550 instance.SetStreamerFunc(&streamer_TDisTrack);
1551 return &instance;
1552 }
1553 TGenericClassInfo *GenerateInitInstance(const ::TDisTrack*)
1554 {
1555 return GenerateInitInstanceLocal((::TDisTrack*)0);
1556 }
1557 // Static variable to force the class initialization
1558 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDisTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1559} // end of namespace ROOT
1560
1561namespace ROOT {
1562 void TEvtRecEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1563 static void *new_TEvtRecEvent(void *p = 0);
1564 static void *newArray_TEvtRecEvent(Long_t size, void *p);
1565 static void delete_TEvtRecEvent(void *p);
1566 static void deleteArray_TEvtRecEvent(void *p);
1567 static void destruct_TEvtRecEvent(void *p);
1568
1569 // Function generating the singleton type initializer
1570 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecEvent*)
1571 {
1572 ::TEvtRecEvent *ptr = 0;
1573 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEvent >(0);
1574 static ::ROOT::TGenericClassInfo
1575 instance("TEvtRecEvent", ::TEvtRecEvent::Class_Version(), "./../RootEventData/TEvtRecEvent.h", 7,
1576 typeid(::TEvtRecEvent), DefineBehavior(ptr, ptr),
1577 &::TEvtRecEvent::Dictionary, isa_proxy, 4,
1578 sizeof(::TEvtRecEvent) );
1579 instance.SetNew(&new_TEvtRecEvent);
1580 instance.SetNewArray(&newArray_TEvtRecEvent);
1581 instance.SetDelete(&delete_TEvtRecEvent);
1582 instance.SetDeleteArray(&deleteArray_TEvtRecEvent);
1583 instance.SetDestructor(&destruct_TEvtRecEvent);
1584 return &instance;
1585 }
1586 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecEvent*)
1587 {
1588 return GenerateInitInstanceLocal((::TEvtRecEvent*)0);
1589 }
1590 // Static variable to force the class initialization
1591 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1592} // end of namespace ROOT
1593
1594namespace ROOT {
1595 void TEvtRecTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
1596 static void *new_TEvtRecTrack(void *p = 0);
1597 static void *newArray_TEvtRecTrack(Long_t size, void *p);
1598 static void delete_TEvtRecTrack(void *p);
1599 static void deleteArray_TEvtRecTrack(void *p);
1600 static void destruct_TEvtRecTrack(void *p);
1601
1602 // Function generating the singleton type initializer
1603 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecTrack*)
1604 {
1605 ::TEvtRecTrack *ptr = 0;
1606 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecTrack >(0);
1607 static ::ROOT::TGenericClassInfo
1608 instance("TEvtRecTrack", ::TEvtRecTrack::Class_Version(), "./../RootEventData/TEvtRecTrack.h", 7,
1609 typeid(::TEvtRecTrack), DefineBehavior(ptr, ptr),
1610 &::TEvtRecTrack::Dictionary, isa_proxy, 4,
1611 sizeof(::TEvtRecTrack) );
1612 instance.SetNew(&new_TEvtRecTrack);
1613 instance.SetNewArray(&newArray_TEvtRecTrack);
1614 instance.SetDelete(&delete_TEvtRecTrack);
1615 instance.SetDeleteArray(&deleteArray_TEvtRecTrack);
1616 instance.SetDestructor(&destruct_TEvtRecTrack);
1617 return &instance;
1618 }
1619 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecTrack*)
1620 {
1621 return GenerateInitInstanceLocal((::TEvtRecTrack*)0);
1622 }
1623 // Static variable to force the class initialization
1624 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1625} // end of namespace ROOT
1626
1627namespace ROOT {
1628 void TEvtRecPrimaryVertex_ShowMembers(void *obj, TMemberInspector &R__insp);
1629 static void *new_TEvtRecPrimaryVertex(void *p = 0);
1630 static void *newArray_TEvtRecPrimaryVertex(Long_t size, void *p);
1631 static void delete_TEvtRecPrimaryVertex(void *p);
1632 static void deleteArray_TEvtRecPrimaryVertex(void *p);
1633 static void destruct_TEvtRecPrimaryVertex(void *p);
1634
1635 // Function generating the singleton type initializer
1636 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecPrimaryVertex*)
1637 {
1638 ::TEvtRecPrimaryVertex *ptr = 0;
1639 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPrimaryVertex >(0);
1640 static ::ROOT::TGenericClassInfo
1641 instance("TEvtRecPrimaryVertex", ::TEvtRecPrimaryVertex::Class_Version(), "./../RootEventData/TEvtRecPrimaryVertex.h", 7,
1642 typeid(::TEvtRecPrimaryVertex), DefineBehavior(ptr, ptr),
1643 &::TEvtRecPrimaryVertex::Dictionary, isa_proxy, 4,
1644 sizeof(::TEvtRecPrimaryVertex) );
1645 instance.SetNew(&new_TEvtRecPrimaryVertex);
1646 instance.SetNewArray(&newArray_TEvtRecPrimaryVertex);
1647 instance.SetDelete(&delete_TEvtRecPrimaryVertex);
1648 instance.SetDeleteArray(&deleteArray_TEvtRecPrimaryVertex);
1649 instance.SetDestructor(&destruct_TEvtRecPrimaryVertex);
1650 return &instance;
1651 }
1652 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecPrimaryVertex*)
1653 {
1654 return GenerateInitInstanceLocal((::TEvtRecPrimaryVertex*)0);
1655 }
1656 // Static variable to force the class initialization
1657 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1658} // end of namespace ROOT
1659
1660namespace ROOT {
1661 void TEvtRecVeeVertex_ShowMembers(void *obj, TMemberInspector &R__insp);
1662 static void *new_TEvtRecVeeVertex(void *p = 0);
1663 static void *newArray_TEvtRecVeeVertex(Long_t size, void *p);
1664 static void delete_TEvtRecVeeVertex(void *p);
1665 static void deleteArray_TEvtRecVeeVertex(void *p);
1666 static void destruct_TEvtRecVeeVertex(void *p);
1667
1668 // Function generating the singleton type initializer
1669 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecVeeVertex*)
1670 {
1671 ::TEvtRecVeeVertex *ptr = 0;
1672 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecVeeVertex >(0);
1673 static ::ROOT::TGenericClassInfo
1674 instance("TEvtRecVeeVertex", ::TEvtRecVeeVertex::Class_Version(), "./../RootEventData/TEvtRecVeeVertex.h", 6,
1675 typeid(::TEvtRecVeeVertex), DefineBehavior(ptr, ptr),
1676 &::TEvtRecVeeVertex::Dictionary, isa_proxy, 4,
1677 sizeof(::TEvtRecVeeVertex) );
1678 instance.SetNew(&new_TEvtRecVeeVertex);
1679 instance.SetNewArray(&newArray_TEvtRecVeeVertex);
1680 instance.SetDelete(&delete_TEvtRecVeeVertex);
1681 instance.SetDeleteArray(&deleteArray_TEvtRecVeeVertex);
1682 instance.SetDestructor(&destruct_TEvtRecVeeVertex);
1683 return &instance;
1684 }
1685 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecVeeVertex*)
1686 {
1687 return GenerateInitInstanceLocal((::TEvtRecVeeVertex*)0);
1688 }
1689 // Static variable to force the class initialization
1690 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1691} // end of namespace ROOT
1692
1693namespace ROOT {
1694 void TEvtRecPi0_ShowMembers(void *obj, TMemberInspector &R__insp);
1695 static void *new_TEvtRecPi0(void *p = 0);
1696 static void *newArray_TEvtRecPi0(Long_t size, void *p);
1697 static void delete_TEvtRecPi0(void *p);
1698 static void deleteArray_TEvtRecPi0(void *p);
1699 static void destruct_TEvtRecPi0(void *p);
1700
1701 // Function generating the singleton type initializer
1702 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecPi0*)
1703 {
1704 ::TEvtRecPi0 *ptr = 0;
1705 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPi0 >(0);
1706 static ::ROOT::TGenericClassInfo
1707 instance("TEvtRecPi0", ::TEvtRecPi0::Class_Version(), "./../RootEventData/TEvtRecPi0.h", 8,
1708 typeid(::TEvtRecPi0), DefineBehavior(ptr, ptr),
1709 &::TEvtRecPi0::Dictionary, isa_proxy, 4,
1710 sizeof(::TEvtRecPi0) );
1711 instance.SetNew(&new_TEvtRecPi0);
1712 instance.SetNewArray(&newArray_TEvtRecPi0);
1713 instance.SetDelete(&delete_TEvtRecPi0);
1714 instance.SetDeleteArray(&deleteArray_TEvtRecPi0);
1715 instance.SetDestructor(&destruct_TEvtRecPi0);
1716 return &instance;
1717 }
1718 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecPi0*)
1719 {
1720 return GenerateInitInstanceLocal((::TEvtRecPi0*)0);
1721 }
1722 // Static variable to force the class initialization
1723 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1724} // end of namespace ROOT
1725
1726namespace ROOT {
1727 void TEvtRecEtaToGG_ShowMembers(void *obj, TMemberInspector &R__insp);
1728 static void *new_TEvtRecEtaToGG(void *p = 0);
1729 static void *newArray_TEvtRecEtaToGG(Long_t size, void *p);
1730 static void delete_TEvtRecEtaToGG(void *p);
1731 static void deleteArray_TEvtRecEtaToGG(void *p);
1732 static void destruct_TEvtRecEtaToGG(void *p);
1733
1734 // Function generating the singleton type initializer
1735 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecEtaToGG*)
1736 {
1737 ::TEvtRecEtaToGG *ptr = 0;
1738 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEtaToGG >(0);
1739 static ::ROOT::TGenericClassInfo
1740 instance("TEvtRecEtaToGG", ::TEvtRecEtaToGG::Class_Version(), "./../RootEventData/TEvtRecEtaToGG.h", 8,
1741 typeid(::TEvtRecEtaToGG), DefineBehavior(ptr, ptr),
1742 &::TEvtRecEtaToGG::Dictionary, isa_proxy, 4,
1743 sizeof(::TEvtRecEtaToGG) );
1744 instance.SetNew(&new_TEvtRecEtaToGG);
1745 instance.SetNewArray(&newArray_TEvtRecEtaToGG);
1746 instance.SetDelete(&delete_TEvtRecEtaToGG);
1747 instance.SetDeleteArray(&deleteArray_TEvtRecEtaToGG);
1748 instance.SetDestructor(&destruct_TEvtRecEtaToGG);
1749 return &instance;
1750 }
1751 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecEtaToGG*)
1752 {
1753 return GenerateInitInstanceLocal((::TEvtRecEtaToGG*)0);
1754 }
1755 // Static variable to force the class initialization
1756 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1757} // end of namespace ROOT
1758
1759namespace ROOT {
1760 void TEvtRecDTag_ShowMembers(void *obj, TMemberInspector &R__insp);
1761 static void *new_TEvtRecDTag(void *p = 0);
1762 static void *newArray_TEvtRecDTag(Long_t size, void *p);
1763 static void delete_TEvtRecDTag(void *p);
1764 static void deleteArray_TEvtRecDTag(void *p);
1765 static void destruct_TEvtRecDTag(void *p);
1766
1767 // Function generating the singleton type initializer
1768 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecDTag*)
1769 {
1770 ::TEvtRecDTag *ptr = 0;
1771 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecDTag >(0);
1772 static ::ROOT::TGenericClassInfo
1773 instance("TEvtRecDTag", ::TEvtRecDTag::Class_Version(), "./../RootEventData/TEvtRecDTag.h", 8,
1774 typeid(::TEvtRecDTag), DefineBehavior(ptr, ptr),
1775 &::TEvtRecDTag::Dictionary, isa_proxy, 4,
1776 sizeof(::TEvtRecDTag) );
1777 instance.SetNew(&new_TEvtRecDTag);
1778 instance.SetNewArray(&newArray_TEvtRecDTag);
1779 instance.SetDelete(&delete_TEvtRecDTag);
1780 instance.SetDeleteArray(&deleteArray_TEvtRecDTag);
1781 instance.SetDestructor(&destruct_TEvtRecDTag);
1782 return &instance;
1783 }
1784 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecDTag*)
1785 {
1786 return GenerateInitInstanceLocal((::TEvtRecDTag*)0);
1787 }
1788 // Static variable to force the class initialization
1789 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1790} // end of namespace ROOT
1791
1792namespace ROOT {
1793 void TEvtRecObject_ShowMembers(void *obj, TMemberInspector &R__insp);
1794 static void *new_TEvtRecObject(void *p = 0);
1795 static void *newArray_TEvtRecObject(Long_t size, void *p);
1796 static void delete_TEvtRecObject(void *p);
1797 static void deleteArray_TEvtRecObject(void *p);
1798 static void destruct_TEvtRecObject(void *p);
1799
1800 // Function generating the singleton type initializer
1801 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecObject*)
1802 {
1803 ::TEvtRecObject *ptr = 0;
1804 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecObject >(0);
1805 static ::ROOT::TGenericClassInfo
1806 instance("TEvtRecObject", ::TEvtRecObject::Class_Version(), "./../RootEventData/TEvtRecObject.h", 15,
1807 typeid(::TEvtRecObject), DefineBehavior(ptr, ptr),
1808 &::TEvtRecObject::Dictionary, isa_proxy, 4,
1809 sizeof(::TEvtRecObject) );
1810 instance.SetNew(&new_TEvtRecObject);
1811 instance.SetNewArray(&newArray_TEvtRecObject);
1812 instance.SetDelete(&delete_TEvtRecObject);
1813 instance.SetDeleteArray(&deleteArray_TEvtRecObject);
1814 instance.SetDestructor(&destruct_TEvtRecObject);
1815 return &instance;
1816 }
1817 TGenericClassInfo *GenerateInitInstance(const ::TEvtRecObject*)
1818 {
1819 return GenerateInitInstanceLocal((::TEvtRecObject*)0);
1820 }
1821 // Static variable to force the class initialization
1822 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1823} // end of namespace ROOT
1824
1825namespace ROOT {
1826 void TMcHitTof_ShowMembers(void *obj, TMemberInspector &R__insp);
1827 static void *new_TMcHitTof(void *p = 0);
1828 static void *newArray_TMcHitTof(Long_t size, void *p);
1829 static void delete_TMcHitTof(void *p);
1830 static void deleteArray_TMcHitTof(void *p);
1831 static void destruct_TMcHitTof(void *p);
1832
1833 // Function generating the singleton type initializer
1834 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitTof*)
1835 {
1836 ::TMcHitTof *ptr = 0;
1837 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitTof >(0);
1838 static ::ROOT::TGenericClassInfo
1839 instance("TMcHitTof", ::TMcHitTof::Class_Version(), "./../RootEventData/TMcHitTof.h", 8,
1840 typeid(::TMcHitTof), DefineBehavior(ptr, ptr),
1841 &::TMcHitTof::Dictionary, isa_proxy, 4,
1842 sizeof(::TMcHitTof) );
1843 instance.SetNew(&new_TMcHitTof);
1844 instance.SetNewArray(&newArray_TMcHitTof);
1845 instance.SetDelete(&delete_TMcHitTof);
1846 instance.SetDeleteArray(&deleteArray_TMcHitTof);
1847 instance.SetDestructor(&destruct_TMcHitTof);
1848 return &instance;
1849 }
1850 TGenericClassInfo *GenerateInitInstance(const ::TMcHitTof*)
1851 {
1852 return GenerateInitInstanceLocal((::TMcHitTof*)0);
1853 }
1854 // Static variable to force the class initialization
1855 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcHitTof*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1856} // end of namespace ROOT
1857
1858namespace ROOT {
1859 void TMcHitMdc_ShowMembers(void *obj, TMemberInspector &R__insp);
1860 static void *new_TMcHitMdc(void *p = 0);
1861 static void *newArray_TMcHitMdc(Long_t size, void *p);
1862 static void delete_TMcHitMdc(void *p);
1863 static void deleteArray_TMcHitMdc(void *p);
1864 static void destruct_TMcHitMdc(void *p);
1865
1866 // Function generating the singleton type initializer
1867 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitMdc*)
1868 {
1869 ::TMcHitMdc *ptr = 0;
1870 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitMdc >(0);
1871 static ::ROOT::TGenericClassInfo
1872 instance("TMcHitMdc", ::TMcHitMdc::Class_Version(), "./../RootEventData/TMcHitMdc.h", 8,
1873 typeid(::TMcHitMdc), DefineBehavior(ptr, ptr),
1874 &::TMcHitMdc::Dictionary, isa_proxy, 4,
1875 sizeof(::TMcHitMdc) );
1876 instance.SetNew(&new_TMcHitMdc);
1877 instance.SetNewArray(&newArray_TMcHitMdc);
1878 instance.SetDelete(&delete_TMcHitMdc);
1879 instance.SetDeleteArray(&deleteArray_TMcHitMdc);
1880 instance.SetDestructor(&destruct_TMcHitMdc);
1881 return &instance;
1882 }
1883 TGenericClassInfo *GenerateInitInstance(const ::TMcHitMdc*)
1884 {
1885 return GenerateInitInstanceLocal((::TMcHitMdc*)0);
1886 }
1887 // Static variable to force the class initialization
1888 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1889} // end of namespace ROOT
1890
1891namespace ROOT {
1892 void TMcDigiEmc_ShowMembers(void *obj, TMemberInspector &R__insp);
1893 static void *new_TMcDigiEmc(void *p = 0);
1894 static void *newArray_TMcDigiEmc(Long_t size, void *p);
1895 static void delete_TMcDigiEmc(void *p);
1896 static void deleteArray_TMcDigiEmc(void *p);
1897 static void destruct_TMcDigiEmc(void *p);
1898
1899 // Function generating the singleton type initializer
1900 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcDigiEmc*)
1901 {
1902 ::TMcDigiEmc *ptr = 0;
1903 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcDigiEmc >(0);
1904 static ::ROOT::TGenericClassInfo
1905 instance("TMcDigiEmc", ::TMcDigiEmc::Class_Version(), "./../RootEventData/TMcDigiEmc.h", 8,
1906 typeid(::TMcDigiEmc), DefineBehavior(ptr, ptr),
1907 &::TMcDigiEmc::Dictionary, isa_proxy, 4,
1908 sizeof(::TMcDigiEmc) );
1909 instance.SetNew(&new_TMcDigiEmc);
1910 instance.SetNewArray(&newArray_TMcDigiEmc);
1911 instance.SetDelete(&delete_TMcDigiEmc);
1912 instance.SetDeleteArray(&deleteArray_TMcDigiEmc);
1913 instance.SetDestructor(&destruct_TMcDigiEmc);
1914 return &instance;
1915 }
1916 TGenericClassInfo *GenerateInitInstance(const ::TMcDigiEmc*)
1917 {
1918 return GenerateInitInstanceLocal((::TMcDigiEmc*)0);
1919 }
1920 // Static variable to force the class initialization
1921 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1922} // end of namespace ROOT
1923
1924namespace ROOT {
1925 void TMcHitEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1926 static void *new_TMcHitEvent(void *p = 0);
1927 static void *newArray_TMcHitEvent(Long_t size, void *p);
1928 static void delete_TMcHitEvent(void *p);
1929 static void deleteArray_TMcHitEvent(void *p);
1930 static void destruct_TMcHitEvent(void *p);
1931
1932 // Function generating the singleton type initializer
1933 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitEvent*)
1934 {
1935 ::TMcHitEvent *ptr = 0;
1936 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitEvent >(0);
1937 static ::ROOT::TGenericClassInfo
1938 instance("TMcHitEvent", ::TMcHitEvent::Class_Version(), "./../RootEventData/TMcHitEvent.h", 12,
1939 typeid(::TMcHitEvent), DefineBehavior(ptr, ptr),
1940 &::TMcHitEvent::Dictionary, isa_proxy, 4,
1941 sizeof(::TMcHitEvent) );
1942 instance.SetNew(&new_TMcHitEvent);
1943 instance.SetNewArray(&newArray_TMcHitEvent);
1944 instance.SetDelete(&delete_TMcHitEvent);
1945 instance.SetDeleteArray(&deleteArray_TMcHitEvent);
1946 instance.SetDestructor(&destruct_TMcHitEvent);
1947 return &instance;
1948 }
1949 TGenericClassInfo *GenerateInitInstance(const ::TMcHitEvent*)
1950 {
1951 return GenerateInitInstanceLocal((::TMcHitEvent*)0);
1952 }
1953 // Static variable to force the class initialization
1954 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1955} // end of namespace ROOT
1956
1957namespace ROOT {
1958 void TBossFullEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
1959 static void *new_TBossFullEvent(void *p = 0);
1960 static void *newArray_TBossFullEvent(Long_t size, void *p);
1961 static void delete_TBossFullEvent(void *p);
1962 static void deleteArray_TBossFullEvent(void *p);
1963 static void destruct_TBossFullEvent(void *p);
1964 static void streamer_TBossFullEvent(TBuffer &buf, void *obj);
1965
1966 // Function generating the singleton type initializer
1967 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBossFullEvent*)
1968 {
1969 ::TBossFullEvent *ptr = 0;
1970 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBossFullEvent >(0);
1971 static ::ROOT::TGenericClassInfo
1972 instance("TBossFullEvent", ::TBossFullEvent::Class_Version(), "./../RootEventData/TBossFullEvent.h", 15,
1973 typeid(::TBossFullEvent), DefineBehavior(ptr, ptr),
1974 &::TBossFullEvent::Dictionary, isa_proxy, 1,
1975 sizeof(::TBossFullEvent) );
1976 instance.SetNew(&new_TBossFullEvent);
1977 instance.SetNewArray(&newArray_TBossFullEvent);
1978 instance.SetDelete(&delete_TBossFullEvent);
1979 instance.SetDeleteArray(&deleteArray_TBossFullEvent);
1980 instance.SetDestructor(&destruct_TBossFullEvent);
1981 instance.SetStreamerFunc(&streamer_TBossFullEvent);
1982 return &instance;
1983 }
1984 TGenericClassInfo *GenerateInitInstance(const ::TBossFullEvent*)
1985 {
1986 return GenerateInitInstanceLocal((::TBossFullEvent*)0);
1987 }
1988 // Static variable to force the class initialization
1989 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
1990} // end of namespace ROOT
1991
1992//______________________________________________________________________________
1993TClass *TJobInfo::fgIsA = 0; // static to hold class pointer
1994
1995//______________________________________________________________________________
1996const char *TJobInfo::Class_Name()
1997{
1998 return "TJobInfo";
1999}
2000
2001//______________________________________________________________________________
2002const char *TJobInfo::ImplFileName()
2003{
2004 return ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetImplFileName();
2005}
2006
2007//______________________________________________________________________________
2008int TJobInfo::ImplFileLine()
2009{
2010 return ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetImplFileLine();
2011}
2012
2013//______________________________________________________________________________
2014void TJobInfo::Dictionary()
2015{
2016 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetClass();
2017}
2018
2019//______________________________________________________________________________
2020TClass *TJobInfo::Class()
2021{
2022 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)0x0)->GetClass();
2023 return fgIsA;
2024}
2025
2026//______________________________________________________________________________
2027TClass *TRawData::fgIsA = 0; // static to hold class pointer
2028
2029//______________________________________________________________________________
2030const char *TRawData::Class_Name()
2031{
2032 return "TRawData";
2033}
2034
2035//______________________________________________________________________________
2036const char *TRawData::ImplFileName()
2037{
2038 return ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetImplFileName();
2039}
2040
2041//______________________________________________________________________________
2042int TRawData::ImplFileLine()
2043{
2044 return ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetImplFileLine();
2045}
2046
2047//______________________________________________________________________________
2048void TRawData::Dictionary()
2049{
2050 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetClass();
2051}
2052
2053//______________________________________________________________________________
2054TClass *TRawData::Class()
2055{
2056 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)0x0)->GetClass();
2057 return fgIsA;
2058}
2059
2060//______________________________________________________________________________
2061TClass *TMdcDigi::fgIsA = 0; // static to hold class pointer
2062
2063//______________________________________________________________________________
2064const char *TMdcDigi::Class_Name()
2065{
2066 return "TMdcDigi";
2067}
2068
2069//______________________________________________________________________________
2070const char *TMdcDigi::ImplFileName()
2071{
2072 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetImplFileName();
2073}
2074
2075//______________________________________________________________________________
2076int TMdcDigi::ImplFileLine()
2077{
2078 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetImplFileLine();
2079}
2080
2081//______________________________________________________________________________
2082void TMdcDigi::Dictionary()
2083{
2084 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetClass();
2085}
2086
2087//______________________________________________________________________________
2088TClass *TMdcDigi::Class()
2089{
2090 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)0x0)->GetClass();
2091 return fgIsA;
2092}
2093
2094//______________________________________________________________________________
2095TClass *TEmcDigi::fgIsA = 0; // static to hold class pointer
2096
2097//______________________________________________________________________________
2098const char *TEmcDigi::Class_Name()
2099{
2100 return "TEmcDigi";
2101}
2102
2103//______________________________________________________________________________
2104const char *TEmcDigi::ImplFileName()
2105{
2106 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetImplFileName();
2107}
2108
2109//______________________________________________________________________________
2110int TEmcDigi::ImplFileLine()
2111{
2112 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetImplFileLine();
2113}
2114
2115//______________________________________________________________________________
2116void TEmcDigi::Dictionary()
2117{
2118 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetClass();
2119}
2120
2121//______________________________________________________________________________
2122TClass *TEmcDigi::Class()
2123{
2124 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)0x0)->GetClass();
2125 return fgIsA;
2126}
2127
2128//______________________________________________________________________________
2129TClass *TTofDigi::fgIsA = 0; // static to hold class pointer
2130
2131//______________________________________________________________________________
2132const char *TTofDigi::Class_Name()
2133{
2134 return "TTofDigi";
2135}
2136
2137//______________________________________________________________________________
2138const char *TTofDigi::ImplFileName()
2139{
2140 return ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetImplFileName();
2141}
2142
2143//______________________________________________________________________________
2144int TTofDigi::ImplFileLine()
2145{
2146 return ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetImplFileLine();
2147}
2148
2149//______________________________________________________________________________
2150void TTofDigi::Dictionary()
2151{
2152 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetClass();
2153}
2154
2155//______________________________________________________________________________
2156TClass *TTofDigi::Class()
2157{
2158 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)0x0)->GetClass();
2159 return fgIsA;
2160}
2161
2162//______________________________________________________________________________
2163TClass *TMucDigi::fgIsA = 0; // static to hold class pointer
2164
2165//______________________________________________________________________________
2166const char *TMucDigi::Class_Name()
2167{
2168 return "TMucDigi";
2169}
2170
2171//______________________________________________________________________________
2172const char *TMucDigi::ImplFileName()
2173{
2174 return ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetImplFileName();
2175}
2176
2177//______________________________________________________________________________
2178int TMucDigi::ImplFileLine()
2179{
2180 return ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetImplFileLine();
2181}
2182
2183//______________________________________________________________________________
2184void TMucDigi::Dictionary()
2185{
2186 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetClass();
2187}
2188
2189//______________________________________________________________________________
2190TClass *TMucDigi::Class()
2191{
2192 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)0x0)->GetClass();
2193 return fgIsA;
2194}
2195
2196//______________________________________________________________________________
2197TClass *TLumiDigi::fgIsA = 0; // static to hold class pointer
2198
2199//______________________________________________________________________________
2200const char *TLumiDigi::Class_Name()
2201{
2202 return "TLumiDigi";
2203}
2204
2205//______________________________________________________________________________
2206const char *TLumiDigi::ImplFileName()
2207{
2208 return ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetImplFileName();
2209}
2210
2211//______________________________________________________________________________
2212int TLumiDigi::ImplFileLine()
2213{
2214 return ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetImplFileLine();
2215}
2216
2217//______________________________________________________________________________
2218void TLumiDigi::Dictionary()
2219{
2220 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetClass();
2221}
2222
2223//______________________________________________________________________________
2224TClass *TLumiDigi::Class()
2225{
2226 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)0x0)->GetClass();
2227 return fgIsA;
2228}
2229
2230//______________________________________________________________________________
2231TClass *TDigiEvent::fgIsA = 0; // static to hold class pointer
2232
2233//______________________________________________________________________________
2234const char *TDigiEvent::Class_Name()
2235{
2236 return "TDigiEvent";
2237}
2238
2239//______________________________________________________________________________
2240const char *TDigiEvent::ImplFileName()
2241{
2242 return ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetImplFileName();
2243}
2244
2245//______________________________________________________________________________
2246int TDigiEvent::ImplFileLine()
2247{
2248 return ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetImplFileLine();
2249}
2250
2251//______________________________________________________________________________
2252void TDigiEvent::Dictionary()
2253{
2254 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetClass();
2255}
2256
2257//______________________________________________________________________________
2258TClass *TDigiEvent::Class()
2259{
2260 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)0x0)->GetClass();
2261 return fgIsA;
2262}
2263
2264//______________________________________________________________________________
2265TClass *TRecMdcTrack::fgIsA = 0; // static to hold class pointer
2266
2267//______________________________________________________________________________
2268const char *TRecMdcTrack::Class_Name()
2269{
2270 return "TRecMdcTrack";
2271}
2272
2273//______________________________________________________________________________
2274const char *TRecMdcTrack::ImplFileName()
2275{
2276 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetImplFileName();
2277}
2278
2279//______________________________________________________________________________
2280int TRecMdcTrack::ImplFileLine()
2281{
2282 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetImplFileLine();
2283}
2284
2285//______________________________________________________________________________
2286void TRecMdcTrack::Dictionary()
2287{
2288 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetClass();
2289}
2290
2291//______________________________________________________________________________
2292TClass *TRecMdcTrack::Class()
2293{
2294 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0)->GetClass();
2295 return fgIsA;
2296}
2297
2298//______________________________________________________________________________
2299TClass *TRecMdcKalTrack::fgIsA = 0; // static to hold class pointer
2300
2301//______________________________________________________________________________
2302const char *TRecMdcKalTrack::Class_Name()
2303{
2304 return "TRecMdcKalTrack";
2305}
2306
2307//______________________________________________________________________________
2308const char *TRecMdcKalTrack::ImplFileName()
2309{
2310 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetImplFileName();
2311}
2312
2313//______________________________________________________________________________
2314int TRecMdcKalTrack::ImplFileLine()
2315{
2316 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetImplFileLine();
2317}
2318
2319//______________________________________________________________________________
2320void TRecMdcKalTrack::Dictionary()
2321{
2322 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetClass();
2323}
2324
2325//______________________________________________________________________________
2326TClass *TRecMdcKalTrack::Class()
2327{
2328 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0)->GetClass();
2329 return fgIsA;
2330}
2331
2332//______________________________________________________________________________
2333TClass *TRecMdcHit::fgIsA = 0; // static to hold class pointer
2334
2335//______________________________________________________________________________
2336const char *TRecMdcHit::Class_Name()
2337{
2338 return "TRecMdcHit";
2339}
2340
2341//______________________________________________________________________________
2342const char *TRecMdcHit::ImplFileName()
2343{
2344 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetImplFileName();
2345}
2346
2347//______________________________________________________________________________
2348int TRecMdcHit::ImplFileLine()
2349{
2350 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetImplFileLine();
2351}
2352
2353//______________________________________________________________________________
2354void TRecMdcHit::Dictionary()
2355{
2356 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetClass();
2357}
2358
2359//______________________________________________________________________________
2360TClass *TRecMdcHit::Class()
2361{
2362 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0)->GetClass();
2363 return fgIsA;
2364}
2365
2366//______________________________________________________________________________
2367TClass *TTofTrack::fgIsA = 0; // static to hold class pointer
2368
2369//______________________________________________________________________________
2370const char *TTofTrack::Class_Name()
2371{
2372 return "TTofTrack";
2373}
2374
2375//______________________________________________________________________________
2376const char *TTofTrack::ImplFileName()
2377{
2378 return ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetImplFileName();
2379}
2380
2381//______________________________________________________________________________
2382int TTofTrack::ImplFileLine()
2383{
2384 return ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetImplFileLine();
2385}
2386
2387//______________________________________________________________________________
2388void TTofTrack::Dictionary()
2389{
2390 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetClass();
2391}
2392
2393//______________________________________________________________________________
2394TClass *TTofTrack::Class()
2395{
2396 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)0x0)->GetClass();
2397 return fgIsA;
2398}
2399
2400//______________________________________________________________________________
2401TClass *TRecTofTrack::fgIsA = 0; // static to hold class pointer
2402
2403//______________________________________________________________________________
2404const char *TRecTofTrack::Class_Name()
2405{
2406 return "TRecTofTrack";
2407}
2408
2409//______________________________________________________________________________
2410const char *TRecTofTrack::ImplFileName()
2411{
2412 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetImplFileName();
2413}
2414
2415//______________________________________________________________________________
2416int TRecTofTrack::ImplFileLine()
2417{
2418 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetImplFileLine();
2419}
2420
2421//______________________________________________________________________________
2422void TRecTofTrack::Dictionary()
2423{
2424 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetClass();
2425}
2426
2427//______________________________________________________________________________
2428TClass *TRecTofTrack::Class()
2429{
2430 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0)->GetClass();
2431 return fgIsA;
2432}
2433
2434//______________________________________________________________________________
2435TClass *TRecEmcHit::fgIsA = 0; // static to hold class pointer
2436
2437//______________________________________________________________________________
2438const char *TRecEmcHit::Class_Name()
2439{
2440 return "TRecEmcHit";
2441}
2442
2443//______________________________________________________________________________
2444const char *TRecEmcHit::ImplFileName()
2445{
2446 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetImplFileName();
2447}
2448
2449//______________________________________________________________________________
2450int TRecEmcHit::ImplFileLine()
2451{
2452 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetImplFileLine();
2453}
2454
2455//______________________________________________________________________________
2456void TRecEmcHit::Dictionary()
2457{
2458 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetClass();
2459}
2460
2461//______________________________________________________________________________
2462TClass *TRecEmcHit::Class()
2463{
2464 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0)->GetClass();
2465 return fgIsA;
2466}
2467
2468//______________________________________________________________________________
2469TClass *TRecEmcCluster::fgIsA = 0; // static to hold class pointer
2470
2471//______________________________________________________________________________
2472const char *TRecEmcCluster::Class_Name()
2473{
2474 return "TRecEmcCluster";
2475}
2476
2477//______________________________________________________________________________
2478const char *TRecEmcCluster::ImplFileName()
2479{
2480 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetImplFileName();
2481}
2482
2483//______________________________________________________________________________
2484int TRecEmcCluster::ImplFileLine()
2485{
2486 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetImplFileLine();
2487}
2488
2489//______________________________________________________________________________
2490void TRecEmcCluster::Dictionary()
2491{
2492 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetClass();
2493}
2494
2495//______________________________________________________________________________
2496TClass *TRecEmcCluster::Class()
2497{
2498 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0)->GetClass();
2499 return fgIsA;
2500}
2501
2502//______________________________________________________________________________
2503TClass *TRecEmcShower::fgIsA = 0; // static to hold class pointer
2504
2505//______________________________________________________________________________
2506const char *TRecEmcShower::Class_Name()
2507{
2508 return "TRecEmcShower";
2509}
2510
2511//______________________________________________________________________________
2512const char *TRecEmcShower::ImplFileName()
2513{
2514 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetImplFileName();
2515}
2516
2517//______________________________________________________________________________
2518int TRecEmcShower::ImplFileLine()
2519{
2520 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetImplFileLine();
2521}
2522
2523//______________________________________________________________________________
2524void TRecEmcShower::Dictionary()
2525{
2526 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetClass();
2527}
2528
2529//______________________________________________________________________________
2530TClass *TRecEmcShower::Class()
2531{
2532 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0)->GetClass();
2533 return fgIsA;
2534}
2535
2536//______________________________________________________________________________
2537TClass *TRecMucTrack::fgIsA = 0; // static to hold class pointer
2538
2539//______________________________________________________________________________
2540const char *TRecMucTrack::Class_Name()
2541{
2542 return "TRecMucTrack";
2543}
2544
2545//______________________________________________________________________________
2546const char *TRecMucTrack::ImplFileName()
2547{
2548 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetImplFileName();
2549}
2550
2551//______________________________________________________________________________
2552int TRecMucTrack::ImplFileLine()
2553{
2554 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetImplFileLine();
2555}
2556
2557//______________________________________________________________________________
2558void TRecMucTrack::Dictionary()
2559{
2560 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetClass();
2561}
2562
2563//______________________________________________________________________________
2564TClass *TRecMucTrack::Class()
2565{
2566 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0)->GetClass();
2567 return fgIsA;
2568}
2569
2570//______________________________________________________________________________
2571TClass *TRecMdcDedx::fgIsA = 0; // static to hold class pointer
2572
2573//______________________________________________________________________________
2574const char *TRecMdcDedx::Class_Name()
2575{
2576 return "TRecMdcDedx";
2577}
2578
2579//______________________________________________________________________________
2580const char *TRecMdcDedx::ImplFileName()
2581{
2582 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetImplFileName();
2583}
2584
2585//______________________________________________________________________________
2586int TRecMdcDedx::ImplFileLine()
2587{
2588 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetImplFileLine();
2589}
2590
2591//______________________________________________________________________________
2592void TRecMdcDedx::Dictionary()
2593{
2594 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetClass();
2595}
2596
2597//______________________________________________________________________________
2598TClass *TRecMdcDedx::Class()
2599{
2600 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0)->GetClass();
2601 return fgIsA;
2602}
2603
2604//______________________________________________________________________________
2605TClass *TRecMdcDedxHit::fgIsA = 0; // static to hold class pointer
2606
2607//______________________________________________________________________________
2608const char *TRecMdcDedxHit::Class_Name()
2609{
2610 return "TRecMdcDedxHit";
2611}
2612
2613//______________________________________________________________________________
2614const char *TRecMdcDedxHit::ImplFileName()
2615{
2616 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetImplFileName();
2617}
2618
2619//______________________________________________________________________________
2620int TRecMdcDedxHit::ImplFileLine()
2621{
2622 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetImplFileLine();
2623}
2624
2625//______________________________________________________________________________
2626void TRecMdcDedxHit::Dictionary()
2627{
2628 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetClass();
2629}
2630
2631//______________________________________________________________________________
2632TClass *TRecMdcDedxHit::Class()
2633{
2634 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0)->GetClass();
2635 return fgIsA;
2636}
2637
2638//______________________________________________________________________________
2639TClass *TRecExtTrack::fgIsA = 0; // static to hold class pointer
2640
2641//______________________________________________________________________________
2642const char *TRecExtTrack::Class_Name()
2643{
2644 return "TRecExtTrack";
2645}
2646
2647//______________________________________________________________________________
2648const char *TRecExtTrack::ImplFileName()
2649{
2650 return ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetImplFileName();
2651}
2652
2653//______________________________________________________________________________
2654int TRecExtTrack::ImplFileLine()
2655{
2656 return ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetImplFileLine();
2657}
2658
2659//______________________________________________________________________________
2660void TRecExtTrack::Dictionary()
2661{
2662 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetClass();
2663}
2664
2665//______________________________________________________________________________
2666TClass *TRecExtTrack::Class()
2667{
2668 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0)->GetClass();
2669 return fgIsA;
2670}
2671
2672//______________________________________________________________________________
2673TClass *TRecEvTime::fgIsA = 0; // static to hold class pointer
2674
2675//______________________________________________________________________________
2676const char *TRecEvTime::Class_Name()
2677{
2678 return "TRecEvTime";
2679}
2680
2681//______________________________________________________________________________
2682const char *TRecEvTime::ImplFileName()
2683{
2684 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetImplFileName();
2685}
2686
2687//______________________________________________________________________________
2688int TRecEvTime::ImplFileLine()
2689{
2690 return ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetImplFileLine();
2691}
2692
2693//______________________________________________________________________________
2694void TRecEvTime::Dictionary()
2695{
2696 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetClass();
2697}
2698
2699//______________________________________________________________________________
2700TClass *TRecEvTime::Class()
2701{
2702 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)0x0)->GetClass();
2703 return fgIsA;
2704}
2705
2706//______________________________________________________________________________
2707TClass *TRecMdcKalHelixSeg::fgIsA = 0; // static to hold class pointer
2708
2709//______________________________________________________________________________
2710const char *TRecMdcKalHelixSeg::Class_Name()
2711{
2712 return "TRecMdcKalHelixSeg";
2713}
2714
2715//______________________________________________________________________________
2716const char *TRecMdcKalHelixSeg::ImplFileName()
2717{
2718 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetImplFileName();
2719}
2720
2721//______________________________________________________________________________
2722int TRecMdcKalHelixSeg::ImplFileLine()
2723{
2724 return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetImplFileLine();
2725}
2726
2727//______________________________________________________________________________
2728void TRecMdcKalHelixSeg::Dictionary()
2729{
2730 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetClass();
2731}
2732
2733//______________________________________________________________________________
2734TClass *TRecMdcKalHelixSeg::Class()
2735{
2736 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0)->GetClass();
2737 return fgIsA;
2738}
2739
2740//______________________________________________________________________________
2741TClass *TRecZddChannel::fgIsA = 0; // static to hold class pointer
2742
2743//______________________________________________________________________________
2744const char *TRecZddChannel::Class_Name()
2745{
2746 return "TRecZddChannel";
2747}
2748
2749//______________________________________________________________________________
2750const char *TRecZddChannel::ImplFileName()
2751{
2752 return ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetImplFileName();
2753}
2754
2755//______________________________________________________________________________
2756int TRecZddChannel::ImplFileLine()
2757{
2758 return ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetImplFileLine();
2759}
2760
2761//______________________________________________________________________________
2762void TRecZddChannel::Dictionary()
2763{
2764 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetClass();
2765}
2766
2767//______________________________________________________________________________
2768TClass *TRecZddChannel::Class()
2769{
2770 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0)->GetClass();
2771 return fgIsA;
2772}
2773
2774//______________________________________________________________________________
2775TClass *TRecTrackEvent::fgIsA = 0; // static to hold class pointer
2776
2777//______________________________________________________________________________
2778const char *TRecTrackEvent::Class_Name()
2779{
2780 return "TRecTrackEvent";
2781}
2782
2783//______________________________________________________________________________
2784const char *TRecTrackEvent::ImplFileName()
2785{
2786 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetImplFileName();
2787}
2788
2789//______________________________________________________________________________
2790int TRecTrackEvent::ImplFileLine()
2791{
2792 return ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetImplFileLine();
2793}
2794
2795//______________________________________________________________________________
2796void TRecTrackEvent::Dictionary()
2797{
2798 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetClass();
2799}
2800
2801//______________________________________________________________________________
2802TClass *TRecTrackEvent::Class()
2803{
2804 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0)->GetClass();
2805 return fgIsA;
2806}
2807
2808//______________________________________________________________________________
2809TClass *TMdcTrack::fgIsA = 0; // static to hold class pointer
2810
2811//______________________________________________________________________________
2812const char *TMdcTrack::Class_Name()
2813{
2814 return "TMdcTrack";
2815}
2816
2817//______________________________________________________________________________
2818const char *TMdcTrack::ImplFileName()
2819{
2820 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetImplFileName();
2821}
2822
2823//______________________________________________________________________________
2824int TMdcTrack::ImplFileLine()
2825{
2826 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetImplFileLine();
2827}
2828
2829//______________________________________________________________________________
2830void TMdcTrack::Dictionary()
2831{
2832 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetClass();
2833}
2834
2835//______________________________________________________________________________
2836TClass *TMdcTrack::Class()
2837{
2838 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)0x0)->GetClass();
2839 return fgIsA;
2840}
2841
2842//______________________________________________________________________________
2843TClass *TEmcTrack::fgIsA = 0; // static to hold class pointer
2844
2845//______________________________________________________________________________
2846const char *TEmcTrack::Class_Name()
2847{
2848 return "TEmcTrack";
2849}
2850
2851//______________________________________________________________________________
2852const char *TEmcTrack::ImplFileName()
2853{
2854 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetImplFileName();
2855}
2856
2857//______________________________________________________________________________
2858int TEmcTrack::ImplFileLine()
2859{
2860 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetImplFileLine();
2861}
2862
2863//______________________________________________________________________________
2864void TEmcTrack::Dictionary()
2865{
2866 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetClass();
2867}
2868
2869//______________________________________________________________________________
2870TClass *TEmcTrack::Class()
2871{
2872 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)0x0)->GetClass();
2873 return fgIsA;
2874}
2875
2876//______________________________________________________________________________
2877TClass *TMucTrack::fgIsA = 0; // static to hold class pointer
2878
2879//______________________________________________________________________________
2880const char *TMucTrack::Class_Name()
2881{
2882 return "TMucTrack";
2883}
2884
2885//______________________________________________________________________________
2886const char *TMucTrack::ImplFileName()
2887{
2888 return ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetImplFileName();
2889}
2890
2891//______________________________________________________________________________
2892int TMucTrack::ImplFileLine()
2893{
2894 return ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetImplFileLine();
2895}
2896
2897//______________________________________________________________________________
2898void TMucTrack::Dictionary()
2899{
2900 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetClass();
2901}
2902
2903//______________________________________________________________________________
2904TClass *TMucTrack::Class()
2905{
2906 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)0x0)->GetClass();
2907 return fgIsA;
2908}
2909
2910//______________________________________________________________________________
2911TClass *TMdcDedx::fgIsA = 0; // static to hold class pointer
2912
2913//______________________________________________________________________________
2914const char *TMdcDedx::Class_Name()
2915{
2916 return "TMdcDedx";
2917}
2918
2919//______________________________________________________________________________
2920const char *TMdcDedx::ImplFileName()
2921{
2922 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetImplFileName();
2923}
2924
2925//______________________________________________________________________________
2926int TMdcDedx::ImplFileLine()
2927{
2928 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetImplFileLine();
2929}
2930
2931//______________________________________________________________________________
2932void TMdcDedx::Dictionary()
2933{
2934 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetClass();
2935}
2936
2937//______________________________________________________________________________
2938TClass *TMdcDedx::Class()
2939{
2940 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)0x0)->GetClass();
2941 return fgIsA;
2942}
2943
2944//______________________________________________________________________________
2945TClass *TExtTrack::fgIsA = 0; // static to hold class pointer
2946
2947//______________________________________________________________________________
2948const char *TExtTrack::Class_Name()
2949{
2950 return "TExtTrack";
2951}
2952
2953//______________________________________________________________________________
2954const char *TExtTrack::ImplFileName()
2955{
2956 return ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetImplFileName();
2957}
2958
2959//______________________________________________________________________________
2960int TExtTrack::ImplFileLine()
2961{
2962 return ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetImplFileLine();
2963}
2964
2965//______________________________________________________________________________
2966void TExtTrack::Dictionary()
2967{
2968 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetClass();
2969}
2970
2971//______________________________________________________________________________
2972TClass *TExtTrack::Class()
2973{
2974 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)0x0)->GetClass();
2975 return fgIsA;
2976}
2977
2978//______________________________________________________________________________
2979TClass *TMdcKalTrack::fgIsA = 0; // static to hold class pointer
2980
2981//______________________________________________________________________________
2982const char *TMdcKalTrack::Class_Name()
2983{
2984 return "TMdcKalTrack";
2985}
2986
2987//______________________________________________________________________________
2988const char *TMdcKalTrack::ImplFileName()
2989{
2990 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetImplFileName();
2991}
2992
2993//______________________________________________________________________________
2994int TMdcKalTrack::ImplFileLine()
2995{
2996 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetImplFileLine();
2997}
2998
2999//______________________________________________________________________________
3000void TMdcKalTrack::Dictionary()
3001{
3002 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetClass();
3003}
3004
3005//______________________________________________________________________________
3006TClass *TMdcKalTrack::Class()
3007{
3008 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0)->GetClass();
3009 return fgIsA;
3010}
3011
3012//______________________________________________________________________________
3013TClass *TDstEvent::fgIsA = 0; // static to hold class pointer
3014
3015//______________________________________________________________________________
3016const char *TDstEvent::Class_Name()
3017{
3018 return "TDstEvent";
3019}
3020
3021//______________________________________________________________________________
3022const char *TDstEvent::ImplFileName()
3023{
3024 return ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetImplFileName();
3025}
3026
3027//______________________________________________________________________________
3028int TDstEvent::ImplFileLine()
3029{
3030 return ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetImplFileLine();
3031}
3032
3033//______________________________________________________________________________
3034void TDstEvent::Dictionary()
3035{
3036 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetClass();
3037}
3038
3039//______________________________________________________________________________
3040TClass *TDstEvent::Class()
3041{
3042 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)0x0)->GetClass();
3043 return fgIsA;
3044}
3045
3046//______________________________________________________________________________
3047TClass *TMdcMc::fgIsA = 0; // static to hold class pointer
3048
3049//______________________________________________________________________________
3050const char *TMdcMc::Class_Name()
3051{
3052 return "TMdcMc";
3053}
3054
3055//______________________________________________________________________________
3056const char *TMdcMc::ImplFileName()
3057{
3058 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetImplFileName();
3059}
3060
3061//______________________________________________________________________________
3062int TMdcMc::ImplFileLine()
3063{
3064 return ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetImplFileLine();
3065}
3066
3067//______________________________________________________________________________
3068void TMdcMc::Dictionary()
3069{
3070 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetClass();
3071}
3072
3073//______________________________________________________________________________
3074TClass *TMdcMc::Class()
3075{
3076 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)0x0)->GetClass();
3077 return fgIsA;
3078}
3079
3080//______________________________________________________________________________
3081TClass *TEmcMc::fgIsA = 0; // static to hold class pointer
3082
3083//______________________________________________________________________________
3084const char *TEmcMc::Class_Name()
3085{
3086 return "TEmcMc";
3087}
3088
3089//______________________________________________________________________________
3090const char *TEmcMc::ImplFileName()
3091{
3092 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetImplFileName();
3093}
3094
3095//______________________________________________________________________________
3096int TEmcMc::ImplFileLine()
3097{
3098 return ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetImplFileLine();
3099}
3100
3101//______________________________________________________________________________
3102void TEmcMc::Dictionary()
3103{
3104 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetClass();
3105}
3106
3107//______________________________________________________________________________
3108TClass *TEmcMc::Class()
3109{
3110 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)0x0)->GetClass();
3111 return fgIsA;
3112}
3113
3114//______________________________________________________________________________
3115TClass *TTofMc::fgIsA = 0; // static to hold class pointer
3116
3117//______________________________________________________________________________
3118const char *TTofMc::Class_Name()
3119{
3120 return "TTofMc";
3121}
3122
3123//______________________________________________________________________________
3124const char *TTofMc::ImplFileName()
3125{
3126 return ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetImplFileName();
3127}
3128
3129//______________________________________________________________________________
3130int TTofMc::ImplFileLine()
3131{
3132 return ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetImplFileLine();
3133}
3134
3135//______________________________________________________________________________
3136void TTofMc::Dictionary()
3137{
3138 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetClass();
3139}
3140
3141//______________________________________________________________________________
3142TClass *TTofMc::Class()
3143{
3144 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)0x0)->GetClass();
3145 return fgIsA;
3146}
3147
3148//______________________________________________________________________________
3149TClass *TMucMc::fgIsA = 0; // static to hold class pointer
3150
3151//______________________________________________________________________________
3152const char *TMucMc::Class_Name()
3153{
3154 return "TMucMc";
3155}
3156
3157//______________________________________________________________________________
3158const char *TMucMc::ImplFileName()
3159{
3160 return ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetImplFileName();
3161}
3162
3163//______________________________________________________________________________
3164int TMucMc::ImplFileLine()
3165{
3166 return ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetImplFileLine();
3167}
3168
3169//______________________________________________________________________________
3170void TMucMc::Dictionary()
3171{
3172 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetClass();
3173}
3174
3175//______________________________________________________________________________
3176TClass *TMucMc::Class()
3177{
3178 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)0x0)->GetClass();
3179 return fgIsA;
3180}
3181
3182//______________________________________________________________________________
3183TClass *TMcParticle::fgIsA = 0; // static to hold class pointer
3184
3185//______________________________________________________________________________
3186const char *TMcParticle::Class_Name()
3187{
3188 return "TMcParticle";
3189}
3190
3191//______________________________________________________________________________
3192const char *TMcParticle::ImplFileName()
3193{
3194 return ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetImplFileName();
3195}
3196
3197//______________________________________________________________________________
3198int TMcParticle::ImplFileLine()
3199{
3200 return ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetImplFileLine();
3201}
3202
3203//______________________________________________________________________________
3204void TMcParticle::Dictionary()
3205{
3206 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetClass();
3207}
3208
3209//______________________________________________________________________________
3210TClass *TMcParticle::Class()
3211{
3212 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)0x0)->GetClass();
3213 return fgIsA;
3214}
3215
3216//______________________________________________________________________________
3217TClass *TMcEvent::fgIsA = 0; // static to hold class pointer
3218
3219//______________________________________________________________________________
3220const char *TMcEvent::Class_Name()
3221{
3222 return "TMcEvent";
3223}
3224
3225//______________________________________________________________________________
3226const char *TMcEvent::ImplFileName()
3227{
3228 return ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetImplFileName();
3229}
3230
3231//______________________________________________________________________________
3232int TMcEvent::ImplFileLine()
3233{
3234 return ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetImplFileLine();
3235}
3236
3237//______________________________________________________________________________
3238void TMcEvent::Dictionary()
3239{
3240 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetClass();
3241}
3242
3243//______________________________________________________________________________
3244TClass *TMcEvent::Class()
3245{
3246 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)0x0)->GetClass();
3247 return fgIsA;
3248}
3249
3250//______________________________________________________________________________
3251TClass *TEvtHeader::fgIsA = 0; // static to hold class pointer
3252
3253//______________________________________________________________________________
3254const char *TEvtHeader::Class_Name()
3255{
3256 return "TEvtHeader";
3257}
3258
3259//______________________________________________________________________________
3260const char *TEvtHeader::ImplFileName()
3261{
3262 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetImplFileName();
3263}
3264
3265//______________________________________________________________________________
3266int TEvtHeader::ImplFileLine()
3267{
3268 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetImplFileLine();
3269}
3270
3271//______________________________________________________________________________
3272void TEvtHeader::Dictionary()
3273{
3274 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetClass();
3275}
3276
3277//______________________________________________________________________________
3278TClass *TEvtHeader::Class()
3279{
3280 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)0x0)->GetClass();
3281 return fgIsA;
3282}
3283
3284//______________________________________________________________________________
3285TClass *TEvtNavigator::fgIsA = 0; // static to hold class pointer
3286
3287//______________________________________________________________________________
3288const char *TEvtNavigator::Class_Name()
3289{
3290 return "TEvtNavigator";
3291}
3292
3293//______________________________________________________________________________
3294const char *TEvtNavigator::ImplFileName()
3295{
3296 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetImplFileName();
3297}
3298
3299//______________________________________________________________________________
3300int TEvtNavigator::ImplFileLine()
3301{
3302 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetImplFileLine();
3303}
3304
3305//______________________________________________________________________________
3306void TEvtNavigator::Dictionary()
3307{
3308 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetClass();
3309}
3310
3311//______________________________________________________________________________
3312TClass *TEvtNavigator::Class()
3313{
3314 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0)->GetClass();
3315 return fgIsA;
3316}
3317
3318//______________________________________________________________________________
3319TClass *TTrigData::fgIsA = 0; // static to hold class pointer
3320
3321//______________________________________________________________________________
3322const char *TTrigData::Class_Name()
3323{
3324 return "TTrigData";
3325}
3326
3327//______________________________________________________________________________
3328const char *TTrigData::ImplFileName()
3329{
3330 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetImplFileName();
3331}
3332
3333//______________________________________________________________________________
3334int TTrigData::ImplFileLine()
3335{
3336 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetImplFileLine();
3337}
3338
3339//______________________________________________________________________________
3340void TTrigData::Dictionary()
3341{
3342 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetClass();
3343}
3344
3345//______________________________________________________________________________
3346TClass *TTrigData::Class()
3347{
3348 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)0x0)->GetClass();
3349 return fgIsA;
3350}
3351
3352//______________________________________________________________________________
3353TClass *TTrigEvent::fgIsA = 0; // static to hold class pointer
3354
3355//______________________________________________________________________________
3356const char *TTrigEvent::Class_Name()
3357{
3358 return "TTrigEvent";
3359}
3360
3361//______________________________________________________________________________
3362const char *TTrigEvent::ImplFileName()
3363{
3364 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetImplFileName();
3365}
3366
3367//______________________________________________________________________________
3368int TTrigEvent::ImplFileLine()
3369{
3370 return ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetImplFileLine();
3371}
3372
3373//______________________________________________________________________________
3374void TTrigEvent::Dictionary()
3375{
3376 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetClass();
3377}
3378
3379//______________________________________________________________________________
3380TClass *TTrigEvent::Class()
3381{
3382 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)0x0)->GetClass();
3383 return fgIsA;
3384}
3385
3386//______________________________________________________________________________
3387TClass *THltRaw::fgIsA = 0; // static to hold class pointer
3388
3389//______________________________________________________________________________
3390const char *THltRaw::Class_Name()
3391{
3392 return "THltRaw";
3393}
3394
3395//______________________________________________________________________________
3396const char *THltRaw::ImplFileName()
3397{
3398 return ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetImplFileName();
3399}
3400
3401//______________________________________________________________________________
3402int THltRaw::ImplFileLine()
3403{
3404 return ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetImplFileLine();
3405}
3406
3407//______________________________________________________________________________
3408void THltRaw::Dictionary()
3409{
3410 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetClass();
3411}
3412
3413//______________________________________________________________________________
3414TClass *THltRaw::Class()
3415{
3416 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)0x0)->GetClass();
3417 return fgIsA;
3418}
3419
3420//______________________________________________________________________________
3421TClass *THltInf::fgIsA = 0; // static to hold class pointer
3422
3423//______________________________________________________________________________
3424const char *THltInf::Class_Name()
3425{
3426 return "THltInf";
3427}
3428
3429//______________________________________________________________________________
3430const char *THltInf::ImplFileName()
3431{
3432 return ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetImplFileName();
3433}
3434
3435//______________________________________________________________________________
3436int THltInf::ImplFileLine()
3437{
3438 return ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetImplFileLine();
3439}
3440
3441//______________________________________________________________________________
3442void THltInf::Dictionary()
3443{
3444 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetClass();
3445}
3446
3447//______________________________________________________________________________
3448TClass *THltInf::Class()
3449{
3450 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)0x0)->GetClass();
3451 return fgIsA;
3452}
3453
3454//______________________________________________________________________________
3455TClass *TDstHltInf::fgIsA = 0; // static to hold class pointer
3456
3457//______________________________________________________________________________
3458const char *TDstHltInf::Class_Name()
3459{
3460 return "TDstHltInf";
3461}
3462
3463//______________________________________________________________________________
3464const char *TDstHltInf::ImplFileName()
3465{
3466 return ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetImplFileName();
3467}
3468
3469//______________________________________________________________________________
3470int TDstHltInf::ImplFileLine()
3471{
3472 return ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetImplFileLine();
3473}
3474
3475//______________________________________________________________________________
3476void TDstHltInf::Dictionary()
3477{
3478 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetClass();
3479}
3480
3481//______________________________________________________________________________
3482TClass *TDstHltInf::Class()
3483{
3484 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)0x0)->GetClass();
3485 return fgIsA;
3486}
3487
3488//______________________________________________________________________________
3489TClass *THltEvent::fgIsA = 0; // static to hold class pointer
3490
3491//______________________________________________________________________________
3492const char *THltEvent::Class_Name()
3493{
3494 return "THltEvent";
3495}
3496
3497//______________________________________________________________________________
3498const char *THltEvent::ImplFileName()
3499{
3500 return ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetImplFileName();
3501}
3502
3503//______________________________________________________________________________
3504int THltEvent::ImplFileLine()
3505{
3506 return ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetImplFileLine();
3507}
3508
3509//______________________________________________________________________________
3510void THltEvent::Dictionary()
3511{
3512 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetClass();
3513}
3514
3515//______________________________________________________________________________
3516TClass *THltEvent::Class()
3517{
3518 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)0x0)->GetClass();
3519 return fgIsA;
3520}
3521
3522//______________________________________________________________________________
3523TClass *TDisTrack::fgIsA = 0; // static to hold class pointer
3524
3525//______________________________________________________________________________
3526const char *TDisTrack::Class_Name()
3527{
3528 return "TDisTrack";
3529}
3530
3531//______________________________________________________________________________
3532const char *TDisTrack::ImplFileName()
3533{
3534 return ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetImplFileName();
3535}
3536
3537//______________________________________________________________________________
3538int TDisTrack::ImplFileLine()
3539{
3540 return ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetImplFileLine();
3541}
3542
3543//______________________________________________________________________________
3544void TDisTrack::Dictionary()
3545{
3546 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetClass();
3547}
3548
3549//______________________________________________________________________________
3550TClass *TDisTrack::Class()
3551{
3552 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)0x0)->GetClass();
3553 return fgIsA;
3554}
3555
3556//______________________________________________________________________________
3557TClass *TEvtRecEvent::fgIsA = 0; // static to hold class pointer
3558
3559//______________________________________________________________________________
3560const char *TEvtRecEvent::Class_Name()
3561{
3562 return "TEvtRecEvent";
3563}
3564
3565//______________________________________________________________________________
3566const char *TEvtRecEvent::ImplFileName()
3567{
3568 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetImplFileName();
3569}
3570
3571//______________________________________________________________________________
3572int TEvtRecEvent::ImplFileLine()
3573{
3574 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetImplFileLine();
3575}
3576
3577//______________________________________________________________________________
3578void TEvtRecEvent::Dictionary()
3579{
3580 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetClass();
3581}
3582
3583//______________________________________________________________________________
3584TClass *TEvtRecEvent::Class()
3585{
3586 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0)->GetClass();
3587 return fgIsA;
3588}
3589
3590//______________________________________________________________________________
3591TClass *TEvtRecTrack::fgIsA = 0; // static to hold class pointer
3592
3593//______________________________________________________________________________
3594const char *TEvtRecTrack::Class_Name()
3595{
3596 return "TEvtRecTrack";
3597}
3598
3599//______________________________________________________________________________
3600const char *TEvtRecTrack::ImplFileName()
3601{
3602 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetImplFileName();
3603}
3604
3605//______________________________________________________________________________
3606int TEvtRecTrack::ImplFileLine()
3607{
3608 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetImplFileLine();
3609}
3610
3611//______________________________________________________________________________
3612void TEvtRecTrack::Dictionary()
3613{
3614 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetClass();
3615}
3616
3617//______________________________________________________________________________
3618TClass *TEvtRecTrack::Class()
3619{
3620 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0)->GetClass();
3621 return fgIsA;
3622}
3623
3624//______________________________________________________________________________
3625TClass *TEvtRecPrimaryVertex::fgIsA = 0; // static to hold class pointer
3626
3627//______________________________________________________________________________
3628const char *TEvtRecPrimaryVertex::Class_Name()
3629{
3630 return "TEvtRecPrimaryVertex";
3631}
3632
3633//______________________________________________________________________________
3634const char *TEvtRecPrimaryVertex::ImplFileName()
3635{
3636 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetImplFileName();
3637}
3638
3639//______________________________________________________________________________
3640int TEvtRecPrimaryVertex::ImplFileLine()
3641{
3642 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetImplFileLine();
3643}
3644
3645//______________________________________________________________________________
3646void TEvtRecPrimaryVertex::Dictionary()
3647{
3648 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetClass();
3649}
3650
3651//______________________________________________________________________________
3652TClass *TEvtRecPrimaryVertex::Class()
3653{
3654 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0)->GetClass();
3655 return fgIsA;
3656}
3657
3658//______________________________________________________________________________
3659TClass *TEvtRecVeeVertex::fgIsA = 0; // static to hold class pointer
3660
3661//______________________________________________________________________________
3662const char *TEvtRecVeeVertex::Class_Name()
3663{
3664 return "TEvtRecVeeVertex";
3665}
3666
3667//______________________________________________________________________________
3668const char *TEvtRecVeeVertex::ImplFileName()
3669{
3670 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetImplFileName();
3671}
3672
3673//______________________________________________________________________________
3674int TEvtRecVeeVertex::ImplFileLine()
3675{
3676 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetImplFileLine();
3677}
3678
3679//______________________________________________________________________________
3680void TEvtRecVeeVertex::Dictionary()
3681{
3682 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetClass();
3683}
3684
3685//______________________________________________________________________________
3686TClass *TEvtRecVeeVertex::Class()
3687{
3688 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0)->GetClass();
3689 return fgIsA;
3690}
3691
3692//______________________________________________________________________________
3693TClass *TEvtRecPi0::fgIsA = 0; // static to hold class pointer
3694
3695//______________________________________________________________________________
3696const char *TEvtRecPi0::Class_Name()
3697{
3698 return "TEvtRecPi0";
3699}
3700
3701//______________________________________________________________________________
3702const char *TEvtRecPi0::ImplFileName()
3703{
3704 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetImplFileName();
3705}
3706
3707//______________________________________________________________________________
3708int TEvtRecPi0::ImplFileLine()
3709{
3710 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetImplFileLine();
3711}
3712
3713//______________________________________________________________________________
3714void TEvtRecPi0::Dictionary()
3715{
3716 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetClass();
3717}
3718
3719//______________________________________________________________________________
3720TClass *TEvtRecPi0::Class()
3721{
3722 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0)->GetClass();
3723 return fgIsA;
3724}
3725
3726//______________________________________________________________________________
3727TClass *TEvtRecEtaToGG::fgIsA = 0; // static to hold class pointer
3728
3729//______________________________________________________________________________
3730const char *TEvtRecEtaToGG::Class_Name()
3731{
3732 return "TEvtRecEtaToGG";
3733}
3734
3735//______________________________________________________________________________
3736const char *TEvtRecEtaToGG::ImplFileName()
3737{
3738 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetImplFileName();
3739}
3740
3741//______________________________________________________________________________
3742int TEvtRecEtaToGG::ImplFileLine()
3743{
3744 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetImplFileLine();
3745}
3746
3747//______________________________________________________________________________
3748void TEvtRecEtaToGG::Dictionary()
3749{
3750 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetClass();
3751}
3752
3753//______________________________________________________________________________
3754TClass *TEvtRecEtaToGG::Class()
3755{
3756 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0)->GetClass();
3757 return fgIsA;
3758}
3759
3760//______________________________________________________________________________
3761TClass *TEvtRecDTag::fgIsA = 0; // static to hold class pointer
3762
3763//______________________________________________________________________________
3764const char *TEvtRecDTag::Class_Name()
3765{
3766 return "TEvtRecDTag";
3767}
3768
3769//______________________________________________________________________________
3770const char *TEvtRecDTag::ImplFileName()
3771{
3772 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetImplFileName();
3773}
3774
3775//______________________________________________________________________________
3776int TEvtRecDTag::ImplFileLine()
3777{
3778 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetImplFileLine();
3779}
3780
3781//______________________________________________________________________________
3782void TEvtRecDTag::Dictionary()
3783{
3784 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetClass();
3785}
3786
3787//______________________________________________________________________________
3788TClass *TEvtRecDTag::Class()
3789{
3790 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0)->GetClass();
3791 return fgIsA;
3792}
3793
3794//______________________________________________________________________________
3795TClass *TEvtRecObject::fgIsA = 0; // static to hold class pointer
3796
3797//______________________________________________________________________________
3798const char *TEvtRecObject::Class_Name()
3799{
3800 return "TEvtRecObject";
3801}
3802
3803//______________________________________________________________________________
3804const char *TEvtRecObject::ImplFileName()
3805{
3806 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetImplFileName();
3807}
3808
3809//______________________________________________________________________________
3810int TEvtRecObject::ImplFileLine()
3811{
3812 return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetImplFileLine();
3813}
3814
3815//______________________________________________________________________________
3816void TEvtRecObject::Dictionary()
3817{
3818 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetClass();
3819}
3820
3821//______________________________________________________________________________
3822TClass *TEvtRecObject::Class()
3823{
3824 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0)->GetClass();
3825 return fgIsA;
3826}
3827
3828//______________________________________________________________________________
3829TClass *TMcHitTof::fgIsA = 0; // static to hold class pointer
3830
3831//______________________________________________________________________________
3832const char *TMcHitTof::Class_Name()
3833{
3834 return "TMcHitTof";
3835}
3836
3837//______________________________________________________________________________
3838const char *TMcHitTof::ImplFileName()
3839{
3840 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetImplFileName();
3841}
3842
3843//______________________________________________________________________________
3844int TMcHitTof::ImplFileLine()
3845{
3846 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetImplFileLine();
3847}
3848
3849//______________________________________________________________________________
3850void TMcHitTof::Dictionary()
3851{
3852 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetClass();
3853}
3854
3855//______________________________________________________________________________
3856TClass *TMcHitTof::Class()
3857{
3858 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)0x0)->GetClass();
3859 return fgIsA;
3860}
3861
3862//______________________________________________________________________________
3863TClass *TMcHitMdc::fgIsA = 0; // static to hold class pointer
3864
3865//______________________________________________________________________________
3866const char *TMcHitMdc::Class_Name()
3867{
3868 return "TMcHitMdc";
3869}
3870
3871//______________________________________________________________________________
3872const char *TMcHitMdc::ImplFileName()
3873{
3874 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetImplFileName();
3875}
3876
3877//______________________________________________________________________________
3878int TMcHitMdc::ImplFileLine()
3879{
3880 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetImplFileLine();
3881}
3882
3883//______________________________________________________________________________
3884void TMcHitMdc::Dictionary()
3885{
3886 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetClass();
3887}
3888
3889//______________________________________________________________________________
3890TClass *TMcHitMdc::Class()
3891{
3892 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0)->GetClass();
3893 return fgIsA;
3894}
3895
3896//______________________________________________________________________________
3897TClass *TMcDigiEmc::fgIsA = 0; // static to hold class pointer
3898
3899//______________________________________________________________________________
3900const char *TMcDigiEmc::Class_Name()
3901{
3902 return "TMcDigiEmc";
3903}
3904
3905//______________________________________________________________________________
3906const char *TMcDigiEmc::ImplFileName()
3907{
3908 return ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetImplFileName();
3909}
3910
3911//______________________________________________________________________________
3912int TMcDigiEmc::ImplFileLine()
3913{
3914 return ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetImplFileLine();
3915}
3916
3917//______________________________________________________________________________
3918void TMcDigiEmc::Dictionary()
3919{
3920 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetClass();
3921}
3922
3923//______________________________________________________________________________
3924TClass *TMcDigiEmc::Class()
3925{
3926 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0)->GetClass();
3927 return fgIsA;
3928}
3929
3930//______________________________________________________________________________
3931TClass *TMcHitEvent::fgIsA = 0; // static to hold class pointer
3932
3933//______________________________________________________________________________
3934const char *TMcHitEvent::Class_Name()
3935{
3936 return "TMcHitEvent";
3937}
3938
3939//______________________________________________________________________________
3940const char *TMcHitEvent::ImplFileName()
3941{
3942 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetImplFileName();
3943}
3944
3945//______________________________________________________________________________
3946int TMcHitEvent::ImplFileLine()
3947{
3948 return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetImplFileLine();
3949}
3950
3951//______________________________________________________________________________
3952void TMcHitEvent::Dictionary()
3953{
3954 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetClass();
3955}
3956
3957//______________________________________________________________________________
3958TClass *TMcHitEvent::Class()
3959{
3960 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0)->GetClass();
3961 return fgIsA;
3962}
3963
3964//______________________________________________________________________________
3965TClass *TBossFullEvent::fgIsA = 0; // static to hold class pointer
3966
3967//______________________________________________________________________________
3968const char *TBossFullEvent::Class_Name()
3969{
3970 return "TBossFullEvent";
3971}
3972
3973//______________________________________________________________________________
3974const char *TBossFullEvent::ImplFileName()
3975{
3976 return ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetImplFileName();
3977}
3978
3979//______________________________________________________________________________
3980int TBossFullEvent::ImplFileLine()
3981{
3982 return ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetImplFileLine();
3983}
3984
3985//______________________________________________________________________________
3986void TBossFullEvent::Dictionary()
3987{
3988 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetClass();
3989}
3990
3991//______________________________________________________________________________
3992TClass *TBossFullEvent::Class()
3993{
3994 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0)->GetClass();
3995 return fgIsA;
3996}
3997
3998//______________________________________________________________________________
3999void TDigiEvent::Streamer(TBuffer &R__b)
4000{
4001 // Stream an object of class TDigiEvent.
4002
4003 if (R__b.IsReading()) {
4004 R__b.ReadClassBuffer(TDigiEvent::Class(),this);
4005 } else {
4006 R__b.WriteClassBuffer(TDigiEvent::Class(),this);
4007 }
4008}
4009
4010//______________________________________________________________________________
4011void TDigiEvent::ShowMembers(TMemberInspector &R__insp)
4012{
4013 // Inspect the data members of an object of class TDigiEvent.
4014 TClass *R__cl = ::TDigiEvent::IsA();
4015 if (R__cl || R__insp.IsA()) { }
4016 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fromMc", &m_fromMc);
4017 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcDigiCol", &m_mdcDigiCol);
4018 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_emcDigiCol", &m_emcDigiCol);
4019 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tofDigiCol", &m_tofDigiCol);
4020 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mucDigiCol", &m_mucDigiCol);
4021 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_lumiDigiCol", &m_lumiDigiCol);
4022 TObject::ShowMembers(R__insp);
4023}
4024
4025namespace ROOT {
4026 // Wrappers around operator new
4027 static void *new_TDigiEvent(void *p) {
4028 return p ? new(p) ::TDigiEvent : new ::TDigiEvent;
4029 }
4030 static void *newArray_TDigiEvent(Long_t nElements, void *p) {
4031 return p ? new(p) ::TDigiEvent[nElements] : new ::TDigiEvent[nElements];
4032 }
4033 // Wrapper around operator delete
4034 static void delete_TDigiEvent(void *p) {
4035 delete ((::TDigiEvent*)p);
4036 }
4037 static void deleteArray_TDigiEvent(void *p) {
4038 delete [] ((::TDigiEvent*)p);
4039 }
4040 static void destruct_TDigiEvent(void *p) {
4041 typedef ::TDigiEvent current_t;
4042 ((current_t*)p)->~current_t();
4043 }
4044} // end of namespace ROOT for class ::TDigiEvent
4045
4046//______________________________________________________________________________
4047void TRawData::Streamer(TBuffer &R__b)
4048{
4049 // Stream an object of class TRawData.
4050
4051 if (R__b.IsReading()) {
4052 R__b.ReadClassBuffer(TRawData::Class(),this);
4053 } else {
4054 R__b.WriteClassBuffer(TRawData::Class(),this);
4055 }
4056}
4057
4058//______________________________________________________________________________
4059void TRawData::ShowMembers(TMemberInspector &R__insp)
4060{
4061 // Inspect the data members of an object of class TRawData.
4062 TClass *R__cl = ::TRawData::IsA();
4063 if (R__cl || R__insp.IsA()) { }
4064 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_intId", &m_intId);
4065 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_timeChannel", &m_timeChannel);
4066 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chargeChannel", &m_chargeChannel);
4067 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
4068 TObject::ShowMembers(R__insp);
4069}
4070
4071namespace ROOT {
4072 // Wrappers around operator new
4073 static void *new_TRawData(void *p) {
4074 return p ? new(p) ::TRawData : new ::TRawData;
4075 }
4076 static void *newArray_TRawData(Long_t nElements, void *p) {
4077 return p ? new(p) ::TRawData[nElements] : new ::TRawData[nElements];
4078 }
4079 // Wrapper around operator delete
4080 static void delete_TRawData(void *p) {
4081 delete ((::TRawData*)p);
4082 }
4083 static void deleteArray_TRawData(void *p) {
4084 delete [] ((::TRawData*)p);
4085 }
4086 static void destruct_TRawData(void *p) {
4087 typedef ::TRawData current_t;
4088 ((current_t*)p)->~current_t();
4089 }
4090} // end of namespace ROOT for class ::TRawData
4091
4092//______________________________________________________________________________
4093void TMdcDigi::Streamer(TBuffer &R__b)
4094{
4095 // Stream an object of class TMdcDigi.
4096
4097 if (R__b.IsReading()) {
4098 R__b.ReadClassBuffer(TMdcDigi::Class(),this);
4099 } else {
4100 R__b.WriteClassBuffer(TMdcDigi::Class(),this);
4101 }
4102}
4103
4104//______________________________________________________________________________
4105void TMdcDigi::ShowMembers(TMemberInspector &R__insp)
4106{
4107 // Inspect the data members of an object of class TMdcDigi.
4108 TClass *R__cl = ::TMdcDigi::IsA();
4109 if (R__cl || R__insp.IsA()) { }
4110 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_overflow", &m_overflow);
4111 TRawData::ShowMembers(R__insp);
4112}
4113
4114namespace ROOT {
4115 // Wrappers around operator new
4116 static void *new_TMdcDigi(void *p) {
4117 return p ? new(p) ::TMdcDigi : new ::TMdcDigi;
4118 }
4119 static void *newArray_TMdcDigi(Long_t nElements, void *p) {
4120 return p ? new(p) ::TMdcDigi[nElements] : new ::TMdcDigi[nElements];
4121 }
4122 // Wrapper around operator delete
4123 static void delete_TMdcDigi(void *p) {
4124 delete ((::TMdcDigi*)p);
4125 }
4126 static void deleteArray_TMdcDigi(void *p) {
4127 delete [] ((::TMdcDigi*)p);
4128 }
4129 static void destruct_TMdcDigi(void *p) {
4130 typedef ::TMdcDigi current_t;
4131 ((current_t*)p)->~current_t();
4132 }
4133} // end of namespace ROOT for class ::TMdcDigi
4134
4135//______________________________________________________________________________
4136void TEmcDigi::Streamer(TBuffer &R__b)
4137{
4138 // Stream an object of class TEmcDigi.
4139
4140 if (R__b.IsReading()) {
4141 R__b.ReadClassBuffer(TEmcDigi::Class(),this);
4142 } else {
4143 R__b.WriteClassBuffer(TEmcDigi::Class(),this);
4144 }
4145}
4146
4147//______________________________________________________________________________
4148void TEmcDigi::ShowMembers(TMemberInspector &R__insp)
4149{
4150 // Inspect the data members of an object of class TEmcDigi.
4151 TClass *R__cl = ::TEmcDigi::IsA();
4152 if (R__cl || R__insp.IsA()) { }
4153 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_measure", &m_measure);
4154 TRawData::ShowMembers(R__insp);
4155}
4156
4157namespace ROOT {
4158 // Wrappers around operator new
4159 static void *new_TEmcDigi(void *p) {
4160 return p ? new(p) ::TEmcDigi : new ::TEmcDigi;
4161 }
4162 static void *newArray_TEmcDigi(Long_t nElements, void *p) {
4163 return p ? new(p) ::TEmcDigi[nElements] : new ::TEmcDigi[nElements];
4164 }
4165 // Wrapper around operator delete
4166 static void delete_TEmcDigi(void *p) {
4167 delete ((::TEmcDigi*)p);
4168 }
4169 static void deleteArray_TEmcDigi(void *p) {
4170 delete [] ((::TEmcDigi*)p);
4171 }
4172 static void destruct_TEmcDigi(void *p) {
4173 typedef ::TEmcDigi current_t;
4174 ((current_t*)p)->~current_t();
4175 }
4176} // end of namespace ROOT for class ::TEmcDigi
4177
4178//______________________________________________________________________________
4179void TTofDigi::Streamer(TBuffer &R__b)
4180{
4181 // Stream an object of class TTofDigi.
4182
4183 if (R__b.IsReading()) {
4184 R__b.ReadClassBuffer(TTofDigi::Class(),this);
4185 } else {
4186 R__b.WriteClassBuffer(TTofDigi::Class(),this);
4187 }
4188}
4189
4190//______________________________________________________________________________
4191void TTofDigi::ShowMembers(TMemberInspector &R__insp)
4192{
4193 // Inspect the data members of an object of class TTofDigi.
4194 TClass *R__cl = ::TTofDigi::IsA();
4195 if (R__cl || R__insp.IsA()) { }
4196 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_overflow", &m_overflow);
4197 TRawData::ShowMembers(R__insp);
4198}
4199
4200namespace ROOT {
4201 // Wrappers around operator new
4202 static void *new_TTofDigi(void *p) {
4203 return p ? new(p) ::TTofDigi : new ::TTofDigi;
4204 }
4205 static void *newArray_TTofDigi(Long_t nElements, void *p) {
4206 return p ? new(p) ::TTofDigi[nElements] : new ::TTofDigi[nElements];
4207 }
4208 // Wrapper around operator delete
4209 static void delete_TTofDigi(void *p) {
4210 delete ((::TTofDigi*)p);
4211 }
4212 static void deleteArray_TTofDigi(void *p) {
4213 delete [] ((::TTofDigi*)p);
4214 }
4215 static void destruct_TTofDigi(void *p) {
4216 typedef ::TTofDigi current_t;
4217 ((current_t*)p)->~current_t();
4218 }
4219} // end of namespace ROOT for class ::TTofDigi
4220
4221//______________________________________________________________________________
4222void TMucDigi::Streamer(TBuffer &R__b)
4223{
4224 // Stream an object of class TMucDigi.
4225
4226 if (R__b.IsReading()) {
4227 R__b.ReadClassBuffer(TMucDigi::Class(),this);
4228 } else {
4229 R__b.WriteClassBuffer(TMucDigi::Class(),this);
4230 }
4231}
4232
4233//______________________________________________________________________________
4234void TMucDigi::ShowMembers(TMemberInspector &R__insp)
4235{
4236 // Inspect the data members of an object of class TMucDigi.
4237 TClass *R__cl = ::TMucDigi::IsA();
4238 if (R__cl || R__insp.IsA()) { }
4239 TRawData::ShowMembers(R__insp);
4240}
4241
4242namespace ROOT {
4243 // Wrappers around operator new
4244 static void *new_TMucDigi(void *p) {
4245 return p ? new(p) ::TMucDigi : new ::TMucDigi;
4246 }
4247 static void *newArray_TMucDigi(Long_t nElements, void *p) {
4248 return p ? new(p) ::TMucDigi[nElements] : new ::TMucDigi[nElements];
4249 }
4250 // Wrapper around operator delete
4251 static void delete_TMucDigi(void *p) {
4252 delete ((::TMucDigi*)p);
4253 }
4254 static void deleteArray_TMucDigi(void *p) {
4255 delete [] ((::TMucDigi*)p);
4256 }
4257 static void destruct_TMucDigi(void *p) {
4258 typedef ::TMucDigi current_t;
4259 ((current_t*)p)->~current_t();
4260 }
4261} // end of namespace ROOT for class ::TMucDigi
4262
4263//______________________________________________________________________________
4264void TLumiDigi::Streamer(TBuffer &R__b)
4265{
4266 // Stream an object of class TLumiDigi.
4267
4268 if (R__b.IsReading()) {
4269 R__b.ReadClassBuffer(TLumiDigi::Class(),this);
4270 } else {
4271 R__b.WriteClassBuffer(TLumiDigi::Class(),this);
4272 }
4273}
4274
4275//______________________________________________________________________________
4276void TLumiDigi::ShowMembers(TMemberInspector &R__insp)
4277{
4278 // Inspect the data members of an object of class TLumiDigi.
4279 TClass *R__cl = ::TLumiDigi::IsA();
4280 if (R__cl || R__insp.IsA()) { }
4281 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_overflow", &m_overflow);
4282 TRawData::ShowMembers(R__insp);
4283}
4284
4285namespace ROOT {
4286 // Wrappers around operator new
4287 static void *new_TLumiDigi(void *p) {
4288 return p ? new(p) ::TLumiDigi : new ::TLumiDigi;
4289 }
4290 static void *newArray_TLumiDigi(Long_t nElements, void *p) {
4291 return p ? new(p) ::TLumiDigi[nElements] : new ::TLumiDigi[nElements];
4292 }
4293 // Wrapper around operator delete
4294 static void delete_TLumiDigi(void *p) {
4295 delete ((::TLumiDigi*)p);
4296 }
4297 static void deleteArray_TLumiDigi(void *p) {
4298 delete [] ((::TLumiDigi*)p);
4299 }
4300 static void destruct_TLumiDigi(void *p) {
4301 typedef ::TLumiDigi current_t;
4302 ((current_t*)p)->~current_t();
4303 }
4304} // end of namespace ROOT for class ::TLumiDigi
4305
4306//______________________________________________________________________________
4307void TDstEvent::Streamer(TBuffer &R__b)
4308{
4309 // Stream an object of class TDstEvent.
4310
4311 if (R__b.IsReading()) {
4312 R__b.ReadClassBuffer(TDstEvent::Class(),this);
4313 } else {
4314 R__b.WriteClassBuffer(TDstEvent::Class(),this);
4315 }
4316}
4317
4318//______________________________________________________________________________
4319void TDstEvent::ShowMembers(TMemberInspector &R__insp)
4320{
4321 // Inspect the data members of an object of class TDstEvent.
4322 TClass *R__cl = ::TDstEvent::IsA();
4323 if (R__cl || R__insp.IsA()) { }
4324 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_emcTrackCol", &m_emcTrackCol);
4325 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcTrackCol", &m_mdcTrackCol);
4326 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tofTrackCol", &m_tofTrackCol);
4327 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mucTrackCol", &m_mucTrackCol);
4328 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcDedxCol", &m_mdcDedxCol);
4329 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_extTrackCol", &m_extTrackCol);
4330 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcKalTrackCol", &m_mdcKalTrackCol);
4331 TObject::ShowMembers(R__insp);
4332}
4333
4334namespace ROOT {
4335 // Wrappers around operator new
4336 static void *new_TDstEvent(void *p) {
4337 return p ? new(p) ::TDstEvent : new ::TDstEvent;
4338 }
4339 static void *newArray_TDstEvent(Long_t nElements, void *p) {
4340 return p ? new(p) ::TDstEvent[nElements] : new ::TDstEvent[nElements];
4341 }
4342 // Wrapper around operator delete
4343 static void delete_TDstEvent(void *p) {
4344 delete ((::TDstEvent*)p);
4345 }
4346 static void deleteArray_TDstEvent(void *p) {
4347 delete [] ((::TDstEvent*)p);
4348 }
4349 static void destruct_TDstEvent(void *p) {
4350 typedef ::TDstEvent current_t;
4351 ((current_t*)p)->~current_t();
4352 }
4353} // end of namespace ROOT for class ::TDstEvent
4354
4355//______________________________________________________________________________
4356void TMdcTrack::Streamer(TBuffer &R__b)
4357{
4358 // Stream an object of class TMdcTrack.
4359
4360 if (R__b.IsReading()) {
4361 R__b.ReadClassBuffer(TMdcTrack::Class(),this);
4362 } else {
4363 R__b.WriteClassBuffer(TMdcTrack::Class(),this);
4364 }
4365}
4366
4367//______________________________________________________________________________
4368void TMdcTrack::ShowMembers(TMemberInspector &R__insp)
4369{
4370 // Inspect the data members of an object of class TMdcTrack.
4371 TClass *R__cl = ::TMdcTrack::IsA();
4372 if (R__cl || R__insp.IsA()) { }
4373 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
4374 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helix[5]", m_helix);
4375 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[15]", m_err);
4376 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat", &m_stat);
4377 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
4378 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
4379 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nster", &m_nster);
4380 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer", &m_nlayer);
4381 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_firstLayer", &m_firstLayer);
4382 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lastLayer", &m_lastLayer);
4383 TObject::ShowMembers(R__insp);
4384}
4385
4386namespace ROOT {
4387 // Wrappers around operator new
4388 static void *new_TMdcTrack(void *p) {
4389 return p ? new(p) ::TMdcTrack : new ::TMdcTrack;
4390 }
4391 static void *newArray_TMdcTrack(Long_t nElements, void *p) {
4392 return p ? new(p) ::TMdcTrack[nElements] : new ::TMdcTrack[nElements];
4393 }
4394 // Wrapper around operator delete
4395 static void delete_TMdcTrack(void *p) {
4396 delete ((::TMdcTrack*)p);
4397 }
4398 static void deleteArray_TMdcTrack(void *p) {
4399 delete [] ((::TMdcTrack*)p);
4400 }
4401 static void destruct_TMdcTrack(void *p) {
4402 typedef ::TMdcTrack current_t;
4403 ((current_t*)p)->~current_t();
4404 }
4405} // end of namespace ROOT for class ::TMdcTrack
4406
4407//______________________________________________________________________________
4408void TEmcTrack::Streamer(TBuffer &R__b)
4409{
4410 // Stream an object of class TEmcTrack.
4411
4412 if (R__b.IsReading()) {
4413 R__b.ReadClassBuffer(TEmcTrack::Class(),this);
4414 } else {
4415 R__b.WriteClassBuffer(TEmcTrack::Class(),this);
4416 }
4417}
4418
4419//______________________________________________________________________________
4420void TEmcTrack::ShowMembers(TMemberInspector &R__insp)
4421{
4422 // Inspect the data members of an object of class TEmcTrack.
4423 TClass *R__cl = ::TEmcTrack::IsA();
4424 if (R__cl || R__insp.IsA()) { }
4425 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
4426 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
4427 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
4428 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId", &m_cellId);
4429 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_module", &m_module);
4430 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_x", &m_x);
4431 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_y", &m_y);
4432 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_z", &m_z);
4433 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dTheta", &m_dTheta);
4434 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dPhi", &m_dPhi);
4435 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
4436 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dE", &m_dE);
4437 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eSeed", &m_eSeed);
4438 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e3x3", &m_e3x3);
4439 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e5x5", &m_e5x5);
4440 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
4441 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_secondMoment", &m_secondMoment);
4442 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_latMoment", &m_latMoment);
4443 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a20Moment", &m_a20Moment);
4444 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a42Moment", &m_a42Moment);
4445 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[6]", m_err);
4446 TObject::ShowMembers(R__insp);
4447}
4448
4449namespace ROOT {
4450 // Wrappers around operator new
4451 static void *new_TEmcTrack(void *p) {
4452 return p ? new(p) ::TEmcTrack : new ::TEmcTrack;
4453 }
4454 static void *newArray_TEmcTrack(Long_t nElements, void *p) {
4455 return p ? new(p) ::TEmcTrack[nElements] : new ::TEmcTrack[nElements];
4456 }
4457 // Wrapper around operator delete
4458 static void delete_TEmcTrack(void *p) {
4459 delete ((::TEmcTrack*)p);
4460 }
4461 static void deleteArray_TEmcTrack(void *p) {
4462 delete [] ((::TEmcTrack*)p);
4463 }
4464 static void destruct_TEmcTrack(void *p) {
4465 typedef ::TEmcTrack current_t;
4466 ((current_t*)p)->~current_t();
4467 }
4468} // end of namespace ROOT for class ::TEmcTrack
4469
4470//______________________________________________________________________________
4471void TTofTrack::Streamer(TBuffer &R__b)
4472{
4473 // Stream an object of class TTofTrack.
4474
4475 if (R__b.IsReading()) {
4476 R__b.ReadClassBuffer(TTofTrack::Class(),this);
4477 } else {
4478 R__b.WriteClassBuffer(TTofTrack::Class(),this);
4479 }
4480}
4481
4482//______________________________________________________________________________
4483void TTofTrack::ShowMembers(TMemberInspector &R__insp)
4484{
4485 // Inspect the data members of an object of class TTofTrack.
4486 TClass *R__cl = ::TTofTrack::IsA();
4487 if (R__cl || R__insp.IsA()) { }
4488 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackID", &m_tofTrackID);
4489 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackID", &m_trackID);
4490 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofID", &m_tofID);
4491 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
4492 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_path", &m_path);
4493 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zrhit", &m_zrhit);
4494 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ph", &m_ph);
4495 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof", &m_tof);
4496 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beta", &m_beta);
4497 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_texp[5]", m_texp);
4498 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_toffset[6]", m_toffset);
4499 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sigma[6]", m_sigma);
4500 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
4501 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_t0", &m_t0);
4502 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errt0", &m_errt0);
4503 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errz", &m_errz);
4504 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phi", &m_phi);
4505 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errphi", &m_errphi);
4506 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
4507 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errenergy", &m_errenergy);
4508 TObject::ShowMembers(R__insp);
4509}
4510
4511namespace ROOT {
4512 // Wrappers around operator new
4513 static void *new_TTofTrack(void *p) {
4514 return p ? new(p) ::TTofTrack : new ::TTofTrack;
4515 }
4516 static void *newArray_TTofTrack(Long_t nElements, void *p) {
4517 return p ? new(p) ::TTofTrack[nElements] : new ::TTofTrack[nElements];
4518 }
4519 // Wrapper around operator delete
4520 static void delete_TTofTrack(void *p) {
4521 delete ((::TTofTrack*)p);
4522 }
4523 static void deleteArray_TTofTrack(void *p) {
4524 delete [] ((::TTofTrack*)p);
4525 }
4526 static void destruct_TTofTrack(void *p) {
4527 typedef ::TTofTrack current_t;
4528 ((current_t*)p)->~current_t();
4529 }
4530} // end of namespace ROOT for class ::TTofTrack
4531
4532//______________________________________________________________________________
4533void TMucTrack::Streamer(TBuffer &R__b)
4534{
4535 // Stream an object of class TMucTrack.
4536
4537 if (R__b.IsReading()) {
4538 R__b.ReadClassBuffer(TMucTrack::Class(),this);
4539 } else {
4540 R__b.WriteClassBuffer(TMucTrack::Class(),this);
4541 }
4542}
4543
4544//______________________________________________________________________________
4545void TMucTrack::ShowMembers(TMemberInspector &R__insp)
4546{
4547 // Inspect the data members of an object of class TMucTrack.
4548 TClass *R__cl = ::TMucTrack::IsA();
4549 if (R__cl || R__insp.IsA()) { }
4550 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
4551 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
4552 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
4553 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
4554 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_startPart", &m_startPart);
4555 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_endPart", &m_endPart);
4556 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_brLastLayer", &m_brLastLayer);
4557 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ecLastLayer", &m_ecLastLayer);
4558 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
4559 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numLayers", &m_numLayers);
4560 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_maxHitsInLayer", &m_maxHitsInLayer);
4561 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depth", &m_depth);
4562 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
4563 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dof", &m_dof);
4564 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_rms", &m_rms);
4565 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPos", &m_xPos);
4566 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPos", &m_yPos);
4567 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPos", &m_zPos);
4568 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosSigma", &m_xPosSigma);
4569 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosSigma", &m_yPosSigma);
4570 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosSigma", &m_zPosSigma);
4571 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
4572 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
4573 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
4574 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_distance", &m_distance);
4575 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaPhi", &m_deltaPhi);
4576 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalrechi2", &m_kalrechi2);
4577 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldof", &m_kaldof);
4578 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldepth", &m_kaldepth);
4579 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalbrLastLayer", &m_kalbrLastLayer);
4580 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalecLastLayer", &m_kalecLastLayer);
4581 TObject::ShowMembers(R__insp);
4582}
4583
4584namespace ROOT {
4585 // Wrappers around operator new
4586 static void *new_TMucTrack(void *p) {
4587 return p ? new(p) ::TMucTrack : new ::TMucTrack;
4588 }
4589 static void *newArray_TMucTrack(Long_t nElements, void *p) {
4590 return p ? new(p) ::TMucTrack[nElements] : new ::TMucTrack[nElements];
4591 }
4592 // Wrapper around operator delete
4593 static void delete_TMucTrack(void *p) {
4594 delete ((::TMucTrack*)p);
4595 }
4596 static void deleteArray_TMucTrack(void *p) {
4597 delete [] ((::TMucTrack*)p);
4598 }
4599 static void destruct_TMucTrack(void *p) {
4600 typedef ::TMucTrack current_t;
4601 ((current_t*)p)->~current_t();
4602 }
4603} // end of namespace ROOT for class ::TMucTrack
4604
4605//______________________________________________________________________________
4606void TMdcDedx::Streamer(TBuffer &R__b)
4607{
4608 // Stream an object of class TMdcDedx.
4609
4610 if (R__b.IsReading()) {
4611 R__b.ReadClassBuffer(TMdcDedx::Class(),this);
4612 } else {
4613 R__b.WriteClassBuffer(TMdcDedx::Class(),this);
4614 }
4615}
4616
4617//______________________________________________________________________________
4618void TMdcDedx::ShowMembers(TMemberInspector &R__insp)
4619{
4620 // Inspect the data members of an object of class TMdcDedx.
4621 TClass *R__cl = ::TMdcDedx::IsA();
4622 if (R__cl || R__insp.IsA()) { }
4623 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
4624 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_particleId", &m_particleId);
4625 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
4626 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trunc_alg", &m_trunc_alg);
4627 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiE", &m_chiE);
4628 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiMu", &m_chiMu);
4629 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiPi", &m_chiPi);
4630 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiK", &m_chiK);
4631 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiP", &m_chiP);
4632 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numGoodHits", &m_numGoodHits);
4633 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numTotalHits", &m_numTotalHits);
4634 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_probPH", &m_probPH);
4635 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_normPH", &m_normPH);
4636 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errorPH", &m_errorPH);
4637 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_twentyPH", &m_twentyPH);
4638 TObject::ShowMembers(R__insp);
4639}
4640
4641namespace ROOT {
4642 // Wrappers around operator new
4643 static void *new_TMdcDedx(void *p) {
4644 return p ? new(p) ::TMdcDedx : new ::TMdcDedx;
4645 }
4646 static void *newArray_TMdcDedx(Long_t nElements, void *p) {
4647 return p ? new(p) ::TMdcDedx[nElements] : new ::TMdcDedx[nElements];
4648 }
4649 // Wrapper around operator delete
4650 static void delete_TMdcDedx(void *p) {
4651 delete ((::TMdcDedx*)p);
4652 }
4653 static void deleteArray_TMdcDedx(void *p) {
4654 delete [] ((::TMdcDedx*)p);
4655 }
4656 static void destruct_TMdcDedx(void *p) {
4657 typedef ::TMdcDedx current_t;
4658 ((current_t*)p)->~current_t();
4659 }
4660} // end of namespace ROOT for class ::TMdcDedx
4661
4662//______________________________________________________________________________
4663void TExtTrack::Streamer(TBuffer &R__b)
4664{
4665 // Stream an object of class TExtTrack.
4666
4667 if (R__b.IsReading()) {
4668 R__b.ReadClassBuffer(TExtTrack::Class(),this);
4669 } else {
4670 R__b.WriteClassBuffer(TExtTrack::Class(),this);
4671 }
4672}
4673
4674//______________________________________________________________________________
4675void TExtTrack::ShowMembers(TMemberInspector &R__insp)
4676{
4677 // Inspect the data members of an object of class TExtTrack.
4678 TClass *R__cl = ::TExtTrack::IsA();
4679 if (R__cl || R__insp.IsA()) { }
4680 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
4681 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionX", &myTof1PositionX);
4682 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionY", &myTof1PositionY);
4683 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionZ", &myTof1PositionZ);
4684 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumX", &myTof1MomentumX);
4685 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumY", &myTof1MomentumY);
4686 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumZ", &myTof1MomentumZ);
4687 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeName", &myTof1VolumeName);
4688 R__insp.InspectMember(myTof1VolumeName, "myTof1VolumeName.");
4689 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeNumber", &myTof1VolumeNumber);
4690 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1", &myTof1);
4691 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1Path", &myTof1Path);
4692 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongZ", &myTof1PosSigmaAlongZ);
4693 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongT", &myTof1PosSigmaAlongT);
4694 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongX", &myTof1PosSigmaAlongX);
4695 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongY", &myTof1PosSigmaAlongY);
4696 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1ErrorMatrix[21]", myTof1ErrorMatrix);
4697 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionX", &myTof2PositionX);
4698 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionY", &myTof2PositionY);
4699 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionZ", &myTof2PositionZ);
4700 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumX", &myTof2MomentumX);
4701 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumY", &myTof2MomentumY);
4702 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumZ", &myTof2MomentumZ);
4703 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeName", &myTof2VolumeName);
4704 R__insp.InspectMember(myTof2VolumeName, "myTof2VolumeName.");
4705 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeNumber", &myTof2VolumeNumber);
4706 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2", &myTof2);
4707 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2Path", &myTof2Path);
4708 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongZ", &myTof2PosSigmaAlongZ);
4709 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongT", &myTof2PosSigmaAlongT);
4710 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongX", &myTof2PosSigmaAlongX);
4711 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongY", &myTof2PosSigmaAlongY);
4712 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2ErrorMatrix[21]", myTof2ErrorMatrix);
4713 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionX", &myEmcPositionX);
4714 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionY", &myEmcPositionY);
4715 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionZ", &myEmcPositionZ);
4716 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumX", &myEmcMomentumX);
4717 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumY", &myEmcMomentumY);
4718 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumZ", &myEmcMomentumZ);
4719 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeName", &myEmcVolumeName);
4720 R__insp.InspectMember(myEmcVolumeName, "myEmcVolumeName.");
4721 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeNumber", &myEmcVolumeNumber);
4722 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongTheta", &myEmcPosSigmaAlongTheta);
4723 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongPhi", &myEmcPosSigmaAlongPhi);
4724 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcErrorMatrix[21]", myEmcErrorMatrix);
4725 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPath", &myEmcPath);
4726 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionX", &myMucPositionX);
4727 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionY", &myMucPositionY);
4728 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionZ", &myMucPositionZ);
4729 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumX", &myMucMomentumX);
4730 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumY", &myMucMomentumY);
4731 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumZ", &myMucMomentumZ);
4732 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeName", &myMucVolumeName);
4733 R__insp.InspectMember(myMucVolumeName, "myMucVolumeName.");
4734 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeNumber", &myMucVolumeNumber);
4735 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongZ", &myMucPosSigmaAlongZ);
4736 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongT", &myMucPosSigmaAlongT);
4737 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongX", &myMucPosSigmaAlongX);
4738 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongY", &myMucPosSigmaAlongY);
4739 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucErrorMatrix[21]", myMucErrorMatrix);
4740 TObject::ShowMembers(R__insp);
4741}
4742
4743namespace ROOT {
4744 // Wrappers around operator new
4745 static void *new_TExtTrack(void *p) {
4746 return p ? new(p) ::TExtTrack : new ::TExtTrack;
4747 }
4748 static void *newArray_TExtTrack(Long_t nElements, void *p) {
4749 return p ? new(p) ::TExtTrack[nElements] : new ::TExtTrack[nElements];
4750 }
4751 // Wrapper around operator delete
4752 static void delete_TExtTrack(void *p) {
4753 delete ((::TExtTrack*)p);
4754 }
4755 static void deleteArray_TExtTrack(void *p) {
4756 delete [] ((::TExtTrack*)p);
4757 }
4758 static void destruct_TExtTrack(void *p) {
4759 typedef ::TExtTrack current_t;
4760 ((current_t*)p)->~current_t();
4761 }
4762} // end of namespace ROOT for class ::TExtTrack
4763
4764//______________________________________________________________________________
4765void TMdcKalTrack::Streamer(TBuffer &R__b)
4766{
4767 // Stream an object of class TMdcKalTrack.
4768
4769 if (R__b.IsReading()) {
4770 R__b.ReadClassBuffer(TMdcKalTrack::Class(),this);
4771 } else {
4772 R__b.WriteClassBuffer(TMdcKalTrack::Class(),this);
4773 }
4774}
4775
4776//______________________________________________________________________________
4777void TMdcKalTrack::ShowMembers(TMemberInspector &R__insp)
4778{
4779 // Inspect the data members of an object of class TMdcKalTrack.
4780 TClass *R__cl = ::TMdcKalTrack::IsA();
4781 if (R__cl || R__insp.IsA()) { }
4782 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
4783 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat[5]", m_stat);
4784 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat2[5]", m_stat2);
4785 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq[5]", m_chisq);
4786 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndf[5]", m_ndf);
4787 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer[5]", m_nlayer);
4788 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix[5]", m_zhelix);
4789 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror[15]", m_zerror);
4790 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_e[5]", m_zhelix_e);
4791 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_e[15]", m_zerror_e);
4792 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_mu[5]", m_zhelix_mu);
4793 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_mu[15]", m_zerror_mu);
4794 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_k[5]", m_zhelix_k);
4795 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_k[15]", m_zerror_k);
4796 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_p[5]", m_zhelix_p);
4797 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_p[15]", m_zerror_p);
4798 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix[5]", m_fhelix);
4799 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror[15]", m_ferror);
4800 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_e[5]", m_fhelix_e);
4801 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_e[15]", m_ferror_e);
4802 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_mu[5]", m_fhelix_mu);
4803 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_mu[15]", m_ferror_mu);
4804 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_k[5]", m_fhelix_k);
4805 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_k[15]", m_ferror_k);
4806 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_p[5]", m_fhelix_p);
4807 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_p[15]", m_ferror_p);
4808 TObject::ShowMembers(R__insp);
4809}
4810
4811namespace ROOT {
4812 // Wrappers around operator new
4813 static void *new_TMdcKalTrack(void *p) {
4814 return p ? new(p) ::TMdcKalTrack : new ::TMdcKalTrack;
4815 }
4816 static void *newArray_TMdcKalTrack(Long_t nElements, void *p) {
4817 return p ? new(p) ::TMdcKalTrack[nElements] : new ::TMdcKalTrack[nElements];
4818 }
4819 // Wrapper around operator delete
4820 static void delete_TMdcKalTrack(void *p) {
4821 delete ((::TMdcKalTrack*)p);
4822 }
4823 static void deleteArray_TMdcKalTrack(void *p) {
4824 delete [] ((::TMdcKalTrack*)p);
4825 }
4826 static void destruct_TMdcKalTrack(void *p) {
4827 typedef ::TMdcKalTrack current_t;
4828 ((current_t*)p)->~current_t();
4829 }
4830} // end of namespace ROOT for class ::TMdcKalTrack
4831
4832//______________________________________________________________________________
4833void TMcEvent::Streamer(TBuffer &R__b)
4834{
4835 // Stream an object of class TMcEvent.
4836
4837 if (R__b.IsReading()) {
4838 R__b.ReadClassBuffer(TMcEvent::Class(),this);
4839 } else {
4840 R__b.WriteClassBuffer(TMcEvent::Class(),this);
4841 }
4842}
4843
4844//______________________________________________________________________________
4845void TMcEvent::ShowMembers(TMemberInspector &R__insp)
4846{
4847 // Inspect the data members of an object of class TMcEvent.
4848 TClass *R__cl = ::TMcEvent::IsA();
4849 if (R__cl || R__insp.IsA()) { }
4850 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcMcHitCol", &m_mdcMcHitCol);
4851 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_emcMcHitCol", &m_emcMcHitCol);
4852 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tofMcHitCol", &m_tofMcHitCol);
4853 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mucMcHitCol", &m_mucMcHitCol);
4854 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mcParticleCol", &m_mcParticleCol);
4855 TObject::ShowMembers(R__insp);
4856}
4857
4858namespace ROOT {
4859 // Wrappers around operator new
4860 static void *new_TMcEvent(void *p) {
4861 return p ? new(p) ::TMcEvent : new ::TMcEvent;
4862 }
4863 static void *newArray_TMcEvent(Long_t nElements, void *p) {
4864 return p ? new(p) ::TMcEvent[nElements] : new ::TMcEvent[nElements];
4865 }
4866 // Wrapper around operator delete
4867 static void delete_TMcEvent(void *p) {
4868 delete ((::TMcEvent*)p);
4869 }
4870 static void deleteArray_TMcEvent(void *p) {
4871 delete [] ((::TMcEvent*)p);
4872 }
4873 static void destruct_TMcEvent(void *p) {
4874 typedef ::TMcEvent current_t;
4875 ((current_t*)p)->~current_t();
4876 }
4877} // end of namespace ROOT for class ::TMcEvent
4878
4879//______________________________________________________________________________
4880void TMdcMc::Streamer(TBuffer &R__b)
4881{
4882 // Stream an object of class TMdcMc.
4883
4884 if (R__b.IsReading()) {
4885 R__b.ReadClassBuffer(TMdcMc::Class(),this);
4886 } else {
4887 R__b.WriteClassBuffer(TMdcMc::Class(),this);
4888 }
4889}
4890
4891//______________________________________________________________________________
4892void TMdcMc::ShowMembers(TMemberInspector &R__insp)
4893{
4894 // Inspect the data members of an object of class TMdcMc.
4895 TClass *R__cl = ::TMdcMc::IsA();
4896 if (R__cl || R__insp.IsA()) { }
4897 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
4898 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
4899 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
4900 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
4901 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
4902 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_driftDistance", &m_driftDistance);
4903 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depositEnergy", &m_depositEnergy);
4904 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_posFlag", &m_posFlag);
4905 TObject::ShowMembers(R__insp);
4906}
4907
4908namespace ROOT {
4909 // Wrappers around operator new
4910 static void *new_TMdcMc(void *p) {
4911 return p ? new(p) ::TMdcMc : new ::TMdcMc;
4912 }
4913 static void *newArray_TMdcMc(Long_t nElements, void *p) {
4914 return p ? new(p) ::TMdcMc[nElements] : new ::TMdcMc[nElements];
4915 }
4916 // Wrapper around operator delete
4917 static void delete_TMdcMc(void *p) {
4918 delete ((::TMdcMc*)p);
4919 }
4920 static void deleteArray_TMdcMc(void *p) {
4921 delete [] ((::TMdcMc*)p);
4922 }
4923 static void destruct_TMdcMc(void *p) {
4924 typedef ::TMdcMc current_t;
4925 ((current_t*)p)->~current_t();
4926 }
4927} // end of namespace ROOT for class ::TMdcMc
4928
4929//______________________________________________________________________________
4930void TEmcMc::Streamer(TBuffer &R__b)
4931{
4932 // Stream an object of class TEmcMc.
4933
4934 if (R__b.IsReading()) {
4935 R__b.ReadClassBuffer(TEmcMc::Class(),this);
4936 } else {
4937 R__b.WriteClassBuffer(TEmcMc::Class(),this);
4938 }
4939}
4940
4941//______________________________________________________________________________
4942void TEmcMc::ShowMembers(TMemberInspector &R__insp)
4943{
4944 // Inspect the data members of an object of class TEmcMc.
4945 TClass *R__cl = ::TEmcMc::IsA();
4946 if (R__cl || R__insp.IsA()) { }
4947 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hitEmc", &m_hitEmc);
4948 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_PDGCode", &m_PDGCode);
4949 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_PDGCharge", &m_PDGCharge);
4950 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
4951 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
4952 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
4953 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
4954 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
4955 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
4956 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
4957 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
4958 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
4959 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depositEnergy", &m_depositEnergy);
4960 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hitMap", (void*)&m_hitMap);
4961 R__insp.InspectMember("map<Int_t,Double_t>", (void*)&m_hitMap, "m_hitMap.", false);
4962 TObject::ShowMembers(R__insp);
4963}
4964
4965namespace ROOT {
4966 // Wrappers around operator new
4967 static void *new_TEmcMc(void *p) {
4968 return p ? new(p) ::TEmcMc : new ::TEmcMc;
4969 }
4970 static void *newArray_TEmcMc(Long_t nElements, void *p) {
4971 return p ? new(p) ::TEmcMc[nElements] : new ::TEmcMc[nElements];
4972 }
4973 // Wrapper around operator delete
4974 static void delete_TEmcMc(void *p) {
4975 delete ((::TEmcMc*)p);
4976 }
4977 static void deleteArray_TEmcMc(void *p) {
4978 delete [] ((::TEmcMc*)p);
4979 }
4980 static void destruct_TEmcMc(void *p) {
4981 typedef ::TEmcMc current_t;
4982 ((current_t*)p)->~current_t();
4983 }
4984} // end of namespace ROOT for class ::TEmcMc
4985
4986//______________________________________________________________________________
4987void TTofMc::Streamer(TBuffer &R__b)
4988{
4989 // Stream an object of class TTofMc.
4990
4991 if (R__b.IsReading()) {
4992 R__b.ReadClassBuffer(TTofMc::Class(),this);
4993 } else {
4994 R__b.WriteClassBuffer(TTofMc::Class(),this);
4995 }
4996}
4997
4998//______________________________________________________________________________
4999void TTofMc::ShowMembers(TMemberInspector &R__insp)
5000{
5001 // Inspect the data members of an object of class TTofMc.
5002 TClass *R__cl = ::TTofMc::IsA();
5003 if (R__cl || R__insp.IsA()) { }
5004 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
5005 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
5006 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
5007 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
5008 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
5009 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
5010 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
5011 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
5012 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackLength", &m_trackLength);
5013 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_flightTime", &m_flightTime);
5014 TObject::ShowMembers(R__insp);
5015}
5016
5017namespace ROOT {
5018 // Wrappers around operator new
5019 static void *new_TTofMc(void *p) {
5020 return p ? new(p) ::TTofMc : new ::TTofMc;
5021 }
5022 static void *newArray_TTofMc(Long_t nElements, void *p) {
5023 return p ? new(p) ::TTofMc[nElements] : new ::TTofMc[nElements];
5024 }
5025 // Wrapper around operator delete
5026 static void delete_TTofMc(void *p) {
5027 delete ((::TTofMc*)p);
5028 }
5029 static void deleteArray_TTofMc(void *p) {
5030 delete [] ((::TTofMc*)p);
5031 }
5032 static void destruct_TTofMc(void *p) {
5033 typedef ::TTofMc current_t;
5034 ((current_t*)p)->~current_t();
5035 }
5036} // end of namespace ROOT for class ::TTofMc
5037
5038//______________________________________________________________________________
5039void TMucMc::Streamer(TBuffer &R__b)
5040{
5041 // Stream an object of class TMucMc.
5042
5043 if (R__b.IsReading()) {
5044 R__b.ReadClassBuffer(TMucMc::Class(),this);
5045 } else {
5046 R__b.WriteClassBuffer(TMucMc::Class(),this);
5047 }
5048}
5049
5050//______________________________________________________________________________
5051void TMucMc::ShowMembers(TMemberInspector &R__insp)
5052{
5053 // Inspect the data members of an object of class TMucMc.
5054 TClass *R__cl = ::TMucMc::IsA();
5055 if (R__cl || R__insp.IsA()) { }
5056 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
5057 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
5058 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
5059 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
5060 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
5061 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
5062 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
5063 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
5064 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depositEnergy", &m_depositEnergy);
5065 TObject::ShowMembers(R__insp);
5066}
5067
5068namespace ROOT {
5069 // Wrappers around operator new
5070 static void *new_TMucMc(void *p) {
5071 return p ? new(p) ::TMucMc : new ::TMucMc;
5072 }
5073 static void *newArray_TMucMc(Long_t nElements, void *p) {
5074 return p ? new(p) ::TMucMc[nElements] : new ::TMucMc[nElements];
5075 }
5076 // Wrapper around operator delete
5077 static void delete_TMucMc(void *p) {
5078 delete ((::TMucMc*)p);
5079 }
5080 static void deleteArray_TMucMc(void *p) {
5081 delete [] ((::TMucMc*)p);
5082 }
5083 static void destruct_TMucMc(void *p) {
5084 typedef ::TMucMc current_t;
5085 ((current_t*)p)->~current_t();
5086 }
5087} // end of namespace ROOT for class ::TMucMc
5088
5089//______________________________________________________________________________
5090void TMcParticle::Streamer(TBuffer &R__b)
5091{
5092 // Stream an object of class TMcParticle.
5093
5094 if (R__b.IsReading()) {
5095 R__b.ReadClassBuffer(TMcParticle::Class(),this);
5096 } else {
5097 R__b.WriteClassBuffer(TMcParticle::Class(),this);
5098 }
5099}
5100
5101//______________________________________________________________________________
5102void TMcParticle::ShowMembers(TMemberInspector &R__insp)
5103{
5104 // Inspect the data members of an object of class TMcParticle.
5105 TClass *R__cl = ::TMcParticle::IsA();
5106 if (R__cl || R__insp.IsA()) { }
5107 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_particleID", &m_particleID);
5108 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
5109 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexIndex0", &m_vertexIndex0);
5110 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexIndex1", &m_vertexIndex1);
5111 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_statusFlags", &m_statusFlags);
5112 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xInitialPosition", &m_xInitialPosition);
5113 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yInitialPosition", &m_yInitialPosition);
5114 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zInitialPosition", &m_zInitialPosition);
5115 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tInitialPosition", &m_tInitialPosition);
5116 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xFinalPosition", &m_xFinalPosition);
5117 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yFinalPosition", &m_yFinalPosition);
5118 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zFinalPosition", &m_zFinalPosition);
5119 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tFinalPosition", &m_tFinalPosition);
5120 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xInitialMomentum", &m_xInitialMomentum);
5121 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yInitialMomentum", &m_yInitialMomentum);
5122 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zInitialMomentum", &m_zInitialMomentum);
5123 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eInitialMomentum", &m_eInitialMomentum);
5124 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mother", &m_mother);
5125 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_daughters", (void*)&m_daughters);
5126 R__insp.InspectMember("vector<Int_t>", (void*)&m_daughters, "m_daughters.", false);
5127 TObject::ShowMembers(R__insp);
5128}
5129
5130namespace ROOT {
5131 // Wrappers around operator new
5132 static void *new_TMcParticle(void *p) {
5133 return p ? new(p) ::TMcParticle : new ::TMcParticle;
5134 }
5135 static void *newArray_TMcParticle(Long_t nElements, void *p) {
5136 return p ? new(p) ::TMcParticle[nElements] : new ::TMcParticle[nElements];
5137 }
5138 // Wrapper around operator delete
5139 static void delete_TMcParticle(void *p) {
5140 delete ((::TMcParticle*)p);
5141 }
5142 static void deleteArray_TMcParticle(void *p) {
5143 delete [] ((::TMcParticle*)p);
5144 }
5145 static void destruct_TMcParticle(void *p) {
5146 typedef ::TMcParticle current_t;
5147 ((current_t*)p)->~current_t();
5148 }
5149} // end of namespace ROOT for class ::TMcParticle
5150
5151//______________________________________________________________________________
5152void TRecMdcHit::Streamer(TBuffer &R__b)
5153{
5154 // Stream an object of class TRecMdcHit.
5155
5156 if (R__b.IsReading()) {
5157 R__b.ReadClassBuffer(TRecMdcHit::Class(),this);
5158 } else {
5159 R__b.WriteClassBuffer(TRecMdcHit::Class(),this);
5160 }
5161}
5162
5163//______________________________________________________________________________
5164void TRecMdcHit::ShowMembers(TMemberInspector &R__insp)
5165{
5166 // Inspect the data members of an object of class TRecMdcHit.
5167 TClass *R__cl = ::TRecMdcHit::IsA();
5168 if (R__cl || R__insp.IsA()) { }
5169 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isGrouped", &m_isGrouped);
5170 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
5171 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trkid", &m_trkid);
5172 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ddl", &m_ddl);
5173 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ddr", &m_ddr);
5174 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_erddl", &m_erddl);
5175 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_erddr", &m_erddr);
5176 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pChisq", &m_pChisq);
5177 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lr", &m_lr);
5178 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat", &m_stat);
5179 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcid", &m_mdcid);
5180 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tdc", &m_tdc);
5181 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_adc", &m_adc);
5182 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_driftT", &m_driftT);
5183 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_doca", &m_doca);
5184 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_entra", &m_entra);
5185 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhit", &m_zhit);
5186 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fltLen", &m_fltLen);
5187 TObject::ShowMembers(R__insp);
5188}
5189
5190namespace ROOT {
5191 // Wrappers around operator new
5192 static void *new_TRecMdcHit(void *p) {
5193 return p ? new(p) ::TRecMdcHit : new ::TRecMdcHit;
5194 }
5195 static void *newArray_TRecMdcHit(Long_t nElements, void *p) {
5196 return p ? new(p) ::TRecMdcHit[nElements] : new ::TRecMdcHit[nElements];
5197 }
5198 // Wrapper around operator delete
5199 static void delete_TRecMdcHit(void *p) {
5200 delete ((::TRecMdcHit*)p);
5201 }
5202 static void deleteArray_TRecMdcHit(void *p) {
5203 delete [] ((::TRecMdcHit*)p);
5204 }
5205 static void destruct_TRecMdcHit(void *p) {
5206 typedef ::TRecMdcHit current_t;
5207 ((current_t*)p)->~current_t();
5208 }
5209} // end of namespace ROOT for class ::TRecMdcHit
5210
5211//______________________________________________________________________________
5212void TRecMdcTrack::Streamer(TBuffer &R__b)
5213{
5214 // Stream an object of class TRecMdcTrack.
5215
5216 if (R__b.IsReading()) {
5217 R__b.ReadClassBuffer(TRecMdcTrack::Class(),this);
5218 } else {
5219 R__b.WriteClassBuffer(TRecMdcTrack::Class(),this);
5220 }
5221}
5222
5223//______________________________________________________________________________
5224void TRecMdcTrack::ShowMembers(TMemberInspector &R__insp)
5225{
5226 // Inspect the data members of an object of class TRecMdcTrack.
5227 TClass *R__cl = ::TRecMdcTrack::IsA();
5228 if (R__cl || R__insp.IsA()) { }
5229 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
5230 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helix[5]", m_helix);
5231 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat", &m_stat);
5232 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
5233 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
5234 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[15]", m_err);
5235 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nhits", &m_nhits);
5236 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nster", &m_nster);
5237 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer", &m_nlayer);
5238 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vx0", &m_vx0);
5239 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vy0", &m_vy0);
5240 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vz0", &m_vz0);
5241 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fiTerm", &m_fiTerm);
5242 TObject::ShowMembers(R__insp);
5243}
5244
5245namespace ROOT {
5246 // Wrappers around operator new
5247 static void *new_TRecMdcTrack(void *p) {
5248 return p ? new(p) ::TRecMdcTrack : new ::TRecMdcTrack;
5249 }
5250 static void *newArray_TRecMdcTrack(Long_t nElements, void *p) {
5251 return p ? new(p) ::TRecMdcTrack[nElements] : new ::TRecMdcTrack[nElements];
5252 }
5253 // Wrapper around operator delete
5254 static void delete_TRecMdcTrack(void *p) {
5255 delete ((::TRecMdcTrack*)p);
5256 }
5257 static void deleteArray_TRecMdcTrack(void *p) {
5258 delete [] ((::TRecMdcTrack*)p);
5259 }
5260 static void destruct_TRecMdcTrack(void *p) {
5261 typedef ::TRecMdcTrack current_t;
5262 ((current_t*)p)->~current_t();
5263 }
5264} // end of namespace ROOT for class ::TRecMdcTrack
5265
5266//______________________________________________________________________________
5267void TRecMdcKalTrack::Streamer(TBuffer &R__b)
5268{
5269 // Stream an object of class TRecMdcKalTrack.
5270
5271 if (R__b.IsReading()) {
5272 R__b.ReadClassBuffer(TRecMdcKalTrack::Class(),this);
5273 } else {
5274 R__b.WriteClassBuffer(TRecMdcKalTrack::Class(),this);
5275 }
5276}
5277
5278//______________________________________________________________________________
5279void TRecMdcKalTrack::ShowMembers(TMemberInspector &R__insp)
5280{
5281 // Inspect the data members of an object of class TRecMdcKalTrack.
5282 TClass *R__cl = ::TRecMdcKalTrack::IsA();
5283 if (R__cl || R__insp.IsA()) { }
5284 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
5285 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass[5]", m_mass);
5286 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_length[5]", m_length);
5287 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof[5]", m_tof);
5288 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fiTerm[5]", m_fiTerm);
5289 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pathSM[5]", m_pathSM);
5290 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nhits[5]", m_nhits);
5291 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer[5]", m_nlayer);
5292 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat[2][5]", m_stat);
5293 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq[2][5]", m_chisq);
5294 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndf[2][5]", m_ndf);
5295 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nSegs[5]", m_nSegs);
5296 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca[3]", m_poca);
5297 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_e[3]", m_poca_e);
5298 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_mu[3]", m_poca_mu);
5299 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_k[3]", m_poca_k);
5300 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_p[3]", m_poca_p);
5301 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint[3]", m_lpoint);
5302 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_e[3]", m_lpoint_e);
5303 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_mu[3]", m_lpoint_mu);
5304 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_k[3]", m_lpoint_k);
5305 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_p[3]", m_lpoint_p);
5306 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot[3]", m_lpivot);
5307 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_e[3]", m_lpivot_e);
5308 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_mu[3]", m_lpivot_mu);
5309 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_k[3]", m_lpivot_k);
5310 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_p[3]", m_lpivot_p);
5311 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix[5]", m_zhelix);
5312 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror[5][5]", m_zerror);
5313 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_e[5]", m_zhelix_e);
5314 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_e[5][5]", m_zerror_e);
5315 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_mu[5]", m_zhelix_mu);
5316 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_mu[5][5]", m_zerror_mu);
5317 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_k[5]", m_zhelix_k);
5318 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_k[5][5]", m_zerror_k);
5319 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_p[5]", m_zhelix_p);
5320 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_p[5][5]", m_zerror_p);
5321 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix[5]", m_fhelix);
5322 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror[5][5]", m_ferror);
5323 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_e[5]", m_fhelix_e);
5324 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_e[5][5]", m_ferror_e);
5325 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_mu[5]", m_fhelix_mu);
5326 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_mu[5][5]", m_ferror_mu);
5327 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_k[5]", m_fhelix_k);
5328 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_k[5][5]", m_ferror_k);
5329 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_p[5]", m_fhelix_p);
5330 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_p[5][5]", m_ferror_p);
5331 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix[5]", m_lhelix);
5332 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror[5][5]", m_lerror);
5333 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_e[5]", m_lhelix_e);
5334 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_e[5][5]", m_lerror_e);
5335 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_mu[5]", m_lhelix_mu);
5336 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_mu[5][5]", m_lerror_mu);
5337 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_k[5]", m_lhelix_k);
5338 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_k[5][5]", m_lerror_k);
5339 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_p[5]", m_lhelix_p);
5340 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_p[5][5]", m_lerror_p);
5341 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_thelix[5]", m_thelix);
5342 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_terror[15]", m_terror);
5343 TObject::ShowMembers(R__insp);
5344}
5345
5346namespace ROOT {
5347 // Wrappers around operator new
5348 static void *new_TRecMdcKalTrack(void *p) {
5349 return p ? new(p) ::TRecMdcKalTrack : new ::TRecMdcKalTrack;
5350 }
5351 static void *newArray_TRecMdcKalTrack(Long_t nElements, void *p) {
5352 return p ? new(p) ::TRecMdcKalTrack[nElements] : new ::TRecMdcKalTrack[nElements];
5353 }
5354 // Wrapper around operator delete
5355 static void delete_TRecMdcKalTrack(void *p) {
5356 delete ((::TRecMdcKalTrack*)p);
5357 }
5358 static void deleteArray_TRecMdcKalTrack(void *p) {
5359 delete [] ((::TRecMdcKalTrack*)p);
5360 }
5361 static void destruct_TRecMdcKalTrack(void *p) {
5362 typedef ::TRecMdcKalTrack current_t;
5363 ((current_t*)p)->~current_t();
5364 }
5365} // end of namespace ROOT for class ::TRecMdcKalTrack
5366
5367//______________________________________________________________________________
5368void TRecMdcKalHelixSeg::Streamer(TBuffer &R__b)
5369{
5370 // Stream an object of class TRecMdcKalHelixSeg.
5371
5372 if (R__b.IsReading()) {
5373 R__b.ReadClassBuffer(TRecMdcKalHelixSeg::Class(),this);
5374 } else {
5375 R__b.WriteClassBuffer(TRecMdcKalHelixSeg::Class(),this);
5376 }
5377}
5378
5379//______________________________________________________________________________
5380void TRecMdcKalHelixSeg::ShowMembers(TMemberInspector &R__insp)
5381{
5382 // Inspect the data members of an object of class TRecMdcKalHelixSeg.
5383 TClass *R__cl = ::TRecMdcKalHelixSeg::IsA();
5384 if (R__cl || R__insp.IsA()) { }
5385 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackid", &m_trackid);
5386 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lr", &m_lr);
5387 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcid", &m_mdcid);
5388 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tdc", &m_tdc);
5389 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_adc", &m_adc);
5390 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhit", &m_zhit);
5391 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof", &m_tof);
5392 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_docaincl", &m_docaincl);
5393 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_docaexcl", &m_docaexcl);
5394 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dd", &m_dd);
5395 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_entra", &m_entra);
5396 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_driftT", &m_driftT);
5397 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helixincl[5]", m_helixincl);
5398 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helixexcl[5]", m_helixexcl);
5399 TObject::ShowMembers(R__insp);
5400}
5401
5402namespace ROOT {
5403 // Wrappers around operator new
5404 static void *new_TRecMdcKalHelixSeg(void *p) {
5405 return p ? new(p) ::TRecMdcKalHelixSeg : new ::TRecMdcKalHelixSeg;
5406 }
5407 static void *newArray_TRecMdcKalHelixSeg(Long_t nElements, void *p) {
5408 return p ? new(p) ::TRecMdcKalHelixSeg[nElements] : new ::TRecMdcKalHelixSeg[nElements];
5409 }
5410 // Wrapper around operator delete
5411 static void delete_TRecMdcKalHelixSeg(void *p) {
5412 delete ((::TRecMdcKalHelixSeg*)p);
5413 }
5414 static void deleteArray_TRecMdcKalHelixSeg(void *p) {
5415 delete [] ((::TRecMdcKalHelixSeg*)p);
5416 }
5417 static void destruct_TRecMdcKalHelixSeg(void *p) {
5418 typedef ::TRecMdcKalHelixSeg current_t;
5419 ((current_t*)p)->~current_t();
5420 }
5421} // end of namespace ROOT for class ::TRecMdcKalHelixSeg
5422
5423//______________________________________________________________________________
5424void TRecTofTrack::Streamer(TBuffer &R__b)
5425{
5426 // Stream an object of class TRecTofTrack.
5427
5428 if (R__b.IsReading()) {
5429 R__b.ReadClassBuffer(TRecTofTrack::Class(),this);
5430 } else {
5431 R__b.WriteClassBuffer(TRecTofTrack::Class(),this);
5432 }
5433}
5434
5435//______________________________________________________________________________
5436void TRecTofTrack::ShowMembers(TMemberInspector &R__insp)
5437{
5438 // Inspect the data members of an object of class TRecTofTrack.
5439 TClass *R__cl = ::TRecTofTrack::IsA();
5440 if (R__cl || R__insp.IsA()) { }
5441 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackID", &m_tofTrackID);
5442 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackID", &m_trackID);
5443 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofID", &m_tofID);
5444 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
5445 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_path", &m_path);
5446 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zrhit", &m_zrhit);
5447 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ph", &m_ph);
5448 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof", &m_tof);
5449 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beta", &m_beta);
5450 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_texp[5]", m_texp);
5451 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_toffset[6]", m_toffset);
5452 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sigma[6]", m_sigma);
5453 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
5454 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_t0", &m_t0);
5455 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errt0", &m_errt0);
5456 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errz", &m_errz);
5457 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phi", &m_phi);
5458 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errphi", &m_errphi);
5459 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
5460 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errenergy", &m_errenergy);
5461 TObject::ShowMembers(R__insp);
5462}
5463
5464namespace ROOT {
5465 // Wrappers around operator new
5466 static void *new_TRecTofTrack(void *p) {
5467 return p ? new(p) ::TRecTofTrack : new ::TRecTofTrack;
5468 }
5469 static void *newArray_TRecTofTrack(Long_t nElements, void *p) {
5470 return p ? new(p) ::TRecTofTrack[nElements] : new ::TRecTofTrack[nElements];
5471 }
5472 // Wrapper around operator delete
5473 static void delete_TRecTofTrack(void *p) {
5474 delete ((::TRecTofTrack*)p);
5475 }
5476 static void deleteArray_TRecTofTrack(void *p) {
5477 delete [] ((::TRecTofTrack*)p);
5478 }
5479 static void destruct_TRecTofTrack(void *p) {
5480 typedef ::TRecTofTrack current_t;
5481 ((current_t*)p)->~current_t();
5482 }
5483} // end of namespace ROOT for class ::TRecTofTrack
5484
5485//______________________________________________________________________________
5486void TRecEmcHit::Streamer(TBuffer &R__b)
5487{
5488 // Stream an object of class TRecEmcHit.
5489
5490 if (R__b.IsReading()) {
5491 R__b.ReadClassBuffer(TRecEmcHit::Class(),this);
5492 } else {
5493 R__b.WriteClassBuffer(TRecEmcHit::Class(),this);
5494 }
5495}
5496
5497//______________________________________________________________________________
5498void TRecEmcHit::ShowMembers(TMemberInspector &R__insp)
5499{
5500 // Inspect the data members of an object of class TRecEmcHit.
5501 TClass *R__cl = ::TRecEmcHit::IsA();
5502 if (R__cl || R__insp.IsA()) { }
5503 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId", &m_cellId);
5504 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
5505 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
5506 TObject::ShowMembers(R__insp);
5507}
5508
5509namespace ROOT {
5510 // Wrappers around operator new
5511 static void *new_TRecEmcHit(void *p) {
5512 return p ? new(p) ::TRecEmcHit : new ::TRecEmcHit;
5513 }
5514 static void *newArray_TRecEmcHit(Long_t nElements, void *p) {
5515 return p ? new(p) ::TRecEmcHit[nElements] : new ::TRecEmcHit[nElements];
5516 }
5517 // Wrapper around operator delete
5518 static void delete_TRecEmcHit(void *p) {
5519 delete ((::TRecEmcHit*)p);
5520 }
5521 static void deleteArray_TRecEmcHit(void *p) {
5522 delete [] ((::TRecEmcHit*)p);
5523 }
5524 static void destruct_TRecEmcHit(void *p) {
5525 typedef ::TRecEmcHit current_t;
5526 ((current_t*)p)->~current_t();
5527 }
5528} // end of namespace ROOT for class ::TRecEmcHit
5529
5530//______________________________________________________________________________
5531void TRecEmcCluster::Streamer(TBuffer &R__b)
5532{
5533 // Stream an object of class TRecEmcCluster.
5534
5535 if (R__b.IsReading()) {
5536 R__b.ReadClassBuffer(TRecEmcCluster::Class(),this);
5537 } else {
5538 R__b.WriteClassBuffer(TRecEmcCluster::Class(),this);
5539 }
5540}
5541
5542//______________________________________________________________________________
5543void TRecEmcCluster::ShowMembers(TMemberInspector &R__insp)
5544{
5545 // Inspect the data members of an object of class TRecEmcCluster.
5546 TClass *R__cl = ::TRecEmcCluster::IsA();
5547 if (R__cl || R__insp.IsA()) { }
5548 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_clusterId", &m_clusterId);
5549 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vecHits", (void*)&m_vecHits);
5550 R__insp.InspectMember("vector<Int_t>", (void*)&m_vecHits, "m_vecHits.", false);
5551 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vecSeeds", (void*)&m_vecSeeds);
5552 R__insp.InspectMember("vector<Int_t>", (void*)&m_vecSeeds, "m_vecSeeds.", false);
5553 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vecShowers", (void*)&m_vecShowers);
5554 R__insp.InspectMember("vector<Int_t>", (void*)&m_vecShowers, "m_vecShowers.", false);
5555 TObject::ShowMembers(R__insp);
5556}
5557
5558namespace ROOT {
5559 // Wrappers around operator new
5560 static void *new_TRecEmcCluster(void *p) {
5561 return p ? new(p) ::TRecEmcCluster : new ::TRecEmcCluster;
5562 }
5563 static void *newArray_TRecEmcCluster(Long_t nElements, void *p) {
5564 return p ? new(p) ::TRecEmcCluster[nElements] : new ::TRecEmcCluster[nElements];
5565 }
5566 // Wrapper around operator delete
5567 static void delete_TRecEmcCluster(void *p) {
5568 delete ((::TRecEmcCluster*)p);
5569 }
5570 static void deleteArray_TRecEmcCluster(void *p) {
5571 delete [] ((::TRecEmcCluster*)p);
5572 }
5573 static void destruct_TRecEmcCluster(void *p) {
5574 typedef ::TRecEmcCluster current_t;
5575 ((current_t*)p)->~current_t();
5576 }
5577} // end of namespace ROOT for class ::TRecEmcCluster
5578
5579//______________________________________________________________________________
5580void TRecEmcShower::Streamer(TBuffer &R__b)
5581{
5582 // Stream an object of class TRecEmcShower.
5583
5584 if (R__b.IsReading()) {
5585 R__b.ReadClassBuffer(TRecEmcShower::Class(),this);
5586 } else {
5587 R__b.WriteClassBuffer(TRecEmcShower::Class(),this);
5588 }
5589}
5590
5591//______________________________________________________________________________
5592void TRecEmcShower::ShowMembers(TMemberInspector &R__insp)
5593{
5594 // Inspect the data members of an object of class TRecEmcShower.
5595 TClass *R__cl = ::TRecEmcShower::IsA();
5596 if (R__cl || R__insp.IsA()) { }
5597 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
5598 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
5599 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
5600 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId", &m_cellId);
5601 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_module", &m_module);
5602 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_x", &m_x);
5603 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_y", &m_y);
5604 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_z", &m_z);
5605 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_theta", &m_theta);
5606 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dTheta", &m_dTheta);
5607 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phi", &m_phi);
5608 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dPhi", &m_dPhi);
5609 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
5610 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dE", &m_dE);
5611 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eSeed", &m_eSeed);
5612 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e3x3", &m_e3x3);
5613 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e5x5", &m_e5x5);
5614 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eall", &m_eall);
5615 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_elepton", &m_elepton);
5616 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
5617 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_secondMoment", &m_secondMoment);
5618 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_latMoment", &m_latMoment);
5619 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a20Moment", &m_a20Moment);
5620 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a42Moment", &m_a42Moment);
5621 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[6]", m_err);
5622 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellIdMap", (void*)&m_cellIdMap);
5623 R__insp.InspectMember("map<Int_t,Double_t>", (void*)&m_cellIdMap, "m_cellIdMap.", false);
5624 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId3x3", (void*)&m_cellId3x3);
5625 R__insp.InspectMember("vector<Int_t>", (void*)&m_cellId3x3, "m_cellId3x3.", false);
5626 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId5x5", (void*)&m_cellId5x5);
5627 R__insp.InspectMember("vector<Int_t>", (void*)&m_cellId5x5, "m_cellId5x5.", false);
5628 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_clusterId", &m_clusterId);
5629 TObject::ShowMembers(R__insp);
5630}
5631
5632namespace ROOT {
5633 // Wrappers around operator new
5634 static void *new_TRecEmcShower(void *p) {
5635 return p ? new(p) ::TRecEmcShower : new ::TRecEmcShower;
5636 }
5637 static void *newArray_TRecEmcShower(Long_t nElements, void *p) {
5638 return p ? new(p) ::TRecEmcShower[nElements] : new ::TRecEmcShower[nElements];
5639 }
5640 // Wrapper around operator delete
5641 static void delete_TRecEmcShower(void *p) {
5642 delete ((::TRecEmcShower*)p);
5643 }
5644 static void deleteArray_TRecEmcShower(void *p) {
5645 delete [] ((::TRecEmcShower*)p);
5646 }
5647 static void destruct_TRecEmcShower(void *p) {
5648 typedef ::TRecEmcShower current_t;
5649 ((current_t*)p)->~current_t();
5650 }
5651} // end of namespace ROOT for class ::TRecEmcShower
5652
5653//______________________________________________________________________________
5654void TRecMucTrack::Streamer(TBuffer &R__b)
5655{
5656 // Stream an object of class TRecMucTrack.
5657
5658 if (R__b.IsReading()) {
5659 R__b.ReadClassBuffer(TRecMucTrack::Class(),this);
5660 } else {
5661 R__b.WriteClassBuffer(TRecMucTrack::Class(),this);
5662 }
5663}
5664
5665//______________________________________________________________________________
5666void TRecMucTrack::ShowMembers(TMemberInspector &R__insp)
5667{
5668 // Inspect the data members of an object of class TRecMucTrack.
5669 TClass *R__cl = ::TRecMucTrack::IsA();
5670 if (R__cl || R__insp.IsA()) { }
5671 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
5672 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
5673 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
5674 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
5675 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_startPart", &m_startPart);
5676 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_endPart", &m_endPart);
5677 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_brLastLayer", &m_brLastLayer);
5678 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ecLastLayer", &m_ecLastLayer);
5679 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
5680 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numLayers", &m_numLayers);
5681 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_maxHitsInLayer", &m_maxHitsInLayer);
5682 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depth", &m_depth);
5683 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
5684 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dof", &m_dof);
5685 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_rms", &m_rms);
5686 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPos", &m_xPos);
5687 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPos", &m_yPos);
5688 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPos", &m_zPos);
5689 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosSigma", &m_xPosSigma);
5690 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosSigma", &m_yPosSigma);
5691 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosSigma", &m_zPosSigma);
5692 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
5693 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
5694 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
5695 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_distance", &m_distance);
5696 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaPhi", &m_deltaPhi);
5697 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vecHits", (void*)&m_vecHits);
5698 R__insp.InspectMember("vector<Int_t>", (void*)&m_vecHits, "m_vecHits.", false);
5699 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_expHits", (void*)&m_expHits);
5700 R__insp.InspectMember("vector<Int_t>", (void*)&m_expHits, "m_expHits.", false);
5701 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_distHits", (void*)&m_distHits);
5702 R__insp.InspectMember("vector<Float_t>", (void*)&m_distHits, "m_distHits.", false);
5703 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalrechi2", &m_kalrechi2);
5704 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldof", &m_kaldof);
5705 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldepth", &m_kaldepth);
5706 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalbrLastLayer", &m_kalbrLastLayer);
5707 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalecLastLayer", &m_kalecLastLayer);
5708 TObject::ShowMembers(R__insp);
5709}
5710
5711namespace ROOT {
5712 // Wrappers around operator new
5713 static void *new_TRecMucTrack(void *p) {
5714 return p ? new(p) ::TRecMucTrack : new ::TRecMucTrack;
5715 }
5716 static void *newArray_TRecMucTrack(Long_t nElements, void *p) {
5717 return p ? new(p) ::TRecMucTrack[nElements] : new ::TRecMucTrack[nElements];
5718 }
5719 // Wrapper around operator delete
5720 static void delete_TRecMucTrack(void *p) {
5721 delete ((::TRecMucTrack*)p);
5722 }
5723 static void deleteArray_TRecMucTrack(void *p) {
5724 delete [] ((::TRecMucTrack*)p);
5725 }
5726 static void destruct_TRecMucTrack(void *p) {
5727 typedef ::TRecMucTrack current_t;
5728 ((current_t*)p)->~current_t();
5729 }
5730} // end of namespace ROOT for class ::TRecMucTrack
5731
5732//______________________________________________________________________________
5733void TRecTrackEvent::Streamer(TBuffer &R__b)
5734{
5735 // Stream an object of class TRecTrackEvent.
5736
5737 if (R__b.IsReading()) {
5738 R__b.ReadClassBuffer(TRecTrackEvent::Class(),this);
5739 } else {
5740 R__b.WriteClassBuffer(TRecTrackEvent::Class(),this);
5741 }
5742}
5743
5744//______________________________________________________________________________
5745void TRecTrackEvent::ShowMembers(TMemberInspector &R__insp)
5746{
5747 // Inspect the data members of an object of class TRecTrackEvent.
5748 TClass *R__cl = ::TRecTrackEvent::IsA();
5749 if (R__cl || R__insp.IsA()) { }
5750 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcTrackCol", &m_recMdcTrackCol);
5751 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcHitCol", &m_recMdcHitCol);
5752 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcHitCol", &m_recEmcHitCol);
5753 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcClusterCol", &m_recEmcClusterCol);
5754 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcShowerCol", &m_recEmcShowerCol);
5755 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recTofTrackCol", &m_recTofTrackCol);
5756 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMucTrackCol", &m_recMucTrackCol);
5757 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcDedxCol", &m_recMdcDedxCol);
5758 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcDedxHitCol", &m_recMdcDedxHitCol);
5759 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recExtTrackCol", &m_recExtTrackCol);
5760 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcKalTrackCol", &m_recMdcKalTrackCol);
5761 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcKalHelixSegCol", &m_recMdcKalHelixSegCol);
5762 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEvTimeCol", &m_recEvTimeCol);
5763 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recZddChannelCol", &m_recZddChannelCol);
5764 TObject::ShowMembers(R__insp);
5765}
5766
5767namespace ROOT {
5768 // Wrappers around operator new
5769 static void *new_TRecTrackEvent(void *p) {
5770 return p ? new(p) ::TRecTrackEvent : new ::TRecTrackEvent;
5771 }
5772 static void *newArray_TRecTrackEvent(Long_t nElements, void *p) {
5773 return p ? new(p) ::TRecTrackEvent[nElements] : new ::TRecTrackEvent[nElements];
5774 }
5775 // Wrapper around operator delete
5776 static void delete_TRecTrackEvent(void *p) {
5777 delete ((::TRecTrackEvent*)p);
5778 }
5779 static void deleteArray_TRecTrackEvent(void *p) {
5780 delete [] ((::TRecTrackEvent*)p);
5781 }
5782 static void destruct_TRecTrackEvent(void *p) {
5783 typedef ::TRecTrackEvent current_t;
5784 ((current_t*)p)->~current_t();
5785 }
5786} // end of namespace ROOT for class ::TRecTrackEvent
5787
5788//______________________________________________________________________________
5789void TRecMdcDedx::Streamer(TBuffer &R__b)
5790{
5791 // Stream an object of class TRecMdcDedx.
5792
5793 if (R__b.IsReading()) {
5794 R__b.ReadClassBuffer(TRecMdcDedx::Class(),this);
5795 } else {
5796 R__b.WriteClassBuffer(TRecMdcDedx::Class(),this);
5797 }
5798}
5799
5800//______________________________________________________________________________
5801void TRecMdcDedx::ShowMembers(TMemberInspector &R__insp)
5802{
5803 // Inspect the data members of an object of class TRecMdcDedx.
5804 TClass *R__cl = ::TRecMdcDedx::IsA();
5805 if (R__cl || R__insp.IsA()) { }
5806 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_hit", &m_dedx_hit);
5807 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_esat", &m_dedx_esat);
5808 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_norun", &m_dedx_norun);
5809 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_momentum", &m_dedx_momentum);
5810 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
5811 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcTrackId", &m_mdcTrackId);
5812 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalTrackId", &m_mdcKalTrackId);
5813 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_particleId", &m_particleId);
5814 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
5815 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trunc_alg", &m_trunc_alg);
5816 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiE", &m_chiE);
5817 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiMu", &m_chiMu);
5818 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiPi", &m_chiPi);
5819 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiK", &m_chiK);
5820 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiP", &m_chiP);
5821 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numGoodHits", &m_numGoodHits);
5822 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numTotalHits", &m_numTotalHits);
5823 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_probPH", &m_probPH);
5824 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_normPH", &m_normPH);
5825 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errorPH", &m_errorPH);
5826 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_twentyPH", &m_twentyPH);
5827 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi[5]", m_chi);
5828 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_exp[5]", m_dedx_exp);
5829 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sigma_dedx[5]", m_sigma_dedx);
5830 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pid_prob[5]", m_pid_prob);
5831 TObject::ShowMembers(R__insp);
5832}
5833
5834namespace ROOT {
5835 // Wrappers around operator new
5836 static void *new_TRecMdcDedx(void *p) {
5837 return p ? new(p) ::TRecMdcDedx : new ::TRecMdcDedx;
5838 }
5839 static void *newArray_TRecMdcDedx(Long_t nElements, void *p) {
5840 return p ? new(p) ::TRecMdcDedx[nElements] : new ::TRecMdcDedx[nElements];
5841 }
5842 // Wrapper around operator delete
5843 static void delete_TRecMdcDedx(void *p) {
5844 delete ((::TRecMdcDedx*)p);
5845 }
5846 static void deleteArray_TRecMdcDedx(void *p) {
5847 delete [] ((::TRecMdcDedx*)p);
5848 }
5849 static void destruct_TRecMdcDedx(void *p) {
5850 typedef ::TRecMdcDedx current_t;
5851 ((current_t*)p)->~current_t();
5852 }
5853} // end of namespace ROOT for class ::TRecMdcDedx
5854
5855//______________________________________________________________________________
5856void TRecMdcDedxHit::Streamer(TBuffer &R__b)
5857{
5858 // Stream an object of class TRecMdcDedxHit.
5859
5860 if (R__b.IsReading()) {
5861 R__b.ReadClassBuffer(TRecMdcDedxHit::Class(),this);
5862 } else {
5863 R__b.WriteClassBuffer(TRecMdcDedxHit::Class(),this);
5864 }
5865}
5866
5867//______________________________________________________________________________
5868void TRecMdcDedxHit::ShowMembers(TMemberInspector &R__insp)
5869{
5870 // Inspect the data members of an object of class TRecMdcDedxHit.
5871 TClass *R__cl = ::TRecMdcDedxHit::IsA();
5872 if (R__cl || R__insp.IsA()) { }
5873 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isGrouped", &m_isGrouped);
5874 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trkid", &m_trkid);
5875 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcHitId", &m_mdcHitId);
5876 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalHelixSegId", &m_mdcKalHelixSegId);
5877 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lr", &m_lr);
5878 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcid", &m_mdcid);
5879 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pathlength", &m_pathlength);
5880 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx", &m_dedx);
5881 TObject::ShowMembers(R__insp);
5882}
5883
5884namespace ROOT {
5885 // Wrappers around operator new
5886 static void *new_TRecMdcDedxHit(void *p) {
5887 return p ? new(p) ::TRecMdcDedxHit : new ::TRecMdcDedxHit;
5888 }
5889 static void *newArray_TRecMdcDedxHit(Long_t nElements, void *p) {
5890 return p ? new(p) ::TRecMdcDedxHit[nElements] : new ::TRecMdcDedxHit[nElements];
5891 }
5892 // Wrapper around operator delete
5893 static void delete_TRecMdcDedxHit(void *p) {
5894 delete ((::TRecMdcDedxHit*)p);
5895 }
5896 static void deleteArray_TRecMdcDedxHit(void *p) {
5897 delete [] ((::TRecMdcDedxHit*)p);
5898 }
5899 static void destruct_TRecMdcDedxHit(void *p) {
5900 typedef ::TRecMdcDedxHit current_t;
5901 ((current_t*)p)->~current_t();
5902 }
5903} // end of namespace ROOT for class ::TRecMdcDedxHit
5904
5905//______________________________________________________________________________
5906void TRecEvTime::Streamer(TBuffer &R__b)
5907{
5908 // Stream an object of class TRecEvTime.
5909
5910 if (R__b.IsReading()) {
5911 R__b.ReadClassBuffer(TRecEvTime::Class(),this);
5912 } else {
5913 R__b.WriteClassBuffer(TRecEvTime::Class(),this);
5914 }
5915}
5916
5917//______________________________________________________________________________
5918void TRecEvTime::ShowMembers(TMemberInspector &R__insp)
5919{
5920 // Inspect the data members of an object of class TRecEvTime.
5921 TClass *R__cl = ::TRecEvTime::IsA();
5922 if (R__cl || R__insp.IsA()) { }
5923 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
5924 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_estime", &m_estime);
5925 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
5926 TObject::ShowMembers(R__insp);
5927}
5928
5929namespace ROOT {
5930 // Wrappers around operator new
5931 static void *new_TRecEvTime(void *p) {
5932 return p ? new(p) ::TRecEvTime : new ::TRecEvTime;
5933 }
5934 static void *newArray_TRecEvTime(Long_t nElements, void *p) {
5935 return p ? new(p) ::TRecEvTime[nElements] : new ::TRecEvTime[nElements];
5936 }
5937 // Wrapper around operator delete
5938 static void delete_TRecEvTime(void *p) {
5939 delete ((::TRecEvTime*)p);
5940 }
5941 static void deleteArray_TRecEvTime(void *p) {
5942 delete [] ((::TRecEvTime*)p);
5943 }
5944 static void destruct_TRecEvTime(void *p) {
5945 typedef ::TRecEvTime current_t;
5946 ((current_t*)p)->~current_t();
5947 }
5948} // end of namespace ROOT for class ::TRecEvTime
5949
5950//______________________________________________________________________________
5951void TEvtHeader::Streamer(TBuffer &R__b)
5952{
5953 // Stream an object of class TEvtHeader.
5954
5955 if (R__b.IsReading()) {
5956 R__b.ReadClassBuffer(TEvtHeader::Class(),this);
5957 } else {
5958 R__b.WriteClassBuffer(TEvtHeader::Class(),this);
5959 }
5960}
5961
5962//______________________________________________________________________________
5963void TEvtHeader::ShowMembers(TMemberInspector &R__insp)
5964{
5965 // Inspect the data members of an object of class TEvtHeader.
5966 TClass *R__cl = ::TEvtHeader::IsA();
5967 if (R__cl || R__insp.IsA()) { }
5968 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eventId", &m_eventId);
5969 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_runId", &m_runId);
5970 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
5971 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eventTag", &m_eventTag);
5972 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_flag1", &m_flag1);
5973 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_flag2", &m_flag2);
5974 TObject::ShowMembers(R__insp);
5975}
5976
5977namespace ROOT {
5978 // Wrappers around operator new
5979 static void *new_TEvtHeader(void *p) {
5980 return p ? new(p) ::TEvtHeader : new ::TEvtHeader;
5981 }
5982 static void *newArray_TEvtHeader(Long_t nElements, void *p) {
5983 return p ? new(p) ::TEvtHeader[nElements] : new ::TEvtHeader[nElements];
5984 }
5985 // Wrapper around operator delete
5986 static void delete_TEvtHeader(void *p) {
5987 delete ((::TEvtHeader*)p);
5988 }
5989 static void deleteArray_TEvtHeader(void *p) {
5990 delete [] ((::TEvtHeader*)p);
5991 }
5992 static void destruct_TEvtHeader(void *p) {
5993 typedef ::TEvtHeader current_t;
5994 ((current_t*)p)->~current_t();
5995 }
5996} // end of namespace ROOT for class ::TEvtHeader
5997
5998//______________________________________________________________________________
5999void TEvtNavigator::Streamer(TBuffer &R__b)
6000{
6001 // Stream an object of class TEvtNavigator.
6002
6003 if (R__b.IsReading()) {
6004 R__b.ReadClassBuffer(TEvtNavigator::Class(),this);
6005 } else {
6006 R__b.WriteClassBuffer(TEvtNavigator::Class(),this);
6007 }
6008}
6009
6010//______________________________________________________________________________
6011void TEvtNavigator::ShowMembers(TMemberInspector &R__insp)
6012{
6013 // Inspect the data members of an object of class TEvtNavigator.
6014 TClass *R__cl = ::TEvtNavigator::IsA();
6015 if (R__cl || R__insp.IsA()) { }
6016 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcMdcMcHits", (void*)&m_mcMdcMcHits);
6017 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcMdcMcHits, "m_mcMdcMcHits.", false);
6018 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcMdcTracks", (void*)&m_mcMdcTracks);
6019 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcMdcTracks, "m_mcMdcTracks.", false);
6020 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcEmcMcHits", (void*)&m_mcEmcMcHits);
6021 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcEmcMcHits, "m_mcEmcMcHits.", false);
6022 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcEmcRecShowers", (void*)&m_mcEmcRecShowers);
6023 R__insp.InspectMember("multimap<int,int>", (void*)&m_mcEmcRecShowers, "m_mcEmcRecShowers.", false);
6024 TObject::ShowMembers(R__insp);
6025}
6026
6027namespace ROOT {
6028 // Wrappers around operator new
6029 static void *new_TEvtNavigator(void *p) {
6030 return p ? new(p) ::TEvtNavigator : new ::TEvtNavigator;
6031 }
6032 static void *newArray_TEvtNavigator(Long_t nElements, void *p) {
6033 return p ? new(p) ::TEvtNavigator[nElements] : new ::TEvtNavigator[nElements];
6034 }
6035 // Wrapper around operator delete
6036 static void delete_TEvtNavigator(void *p) {
6037 delete ((::TEvtNavigator*)p);
6038 }
6039 static void deleteArray_TEvtNavigator(void *p) {
6040 delete [] ((::TEvtNavigator*)p);
6041 }
6042 static void destruct_TEvtNavigator(void *p) {
6043 typedef ::TEvtNavigator current_t;
6044 ((current_t*)p)->~current_t();
6045 }
6046} // end of namespace ROOT for class ::TEvtNavigator
6047
6048//______________________________________________________________________________
6049void TRecExtTrack::Streamer(TBuffer &R__b)
6050{
6051 // Stream an object of class TRecExtTrack.
6052
6053 if (R__b.IsReading()) {
6054 R__b.ReadClassBuffer(TRecExtTrack::Class(),this);
6055 } else {
6056 R__b.WriteClassBuffer(TRecExtTrack::Class(),this);
6057 }
6058}
6059
6060//______________________________________________________________________________
6061void TRecExtTrack::ShowMembers(TMemberInspector &R__insp)
6062{
6063 // Inspect the data members of an object of class TRecExtTrack.
6064 TClass *R__cl = ::TRecExtTrack::IsA();
6065 if (R__cl || R__insp.IsA()) { }
6066 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
6067 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionX[5]", myTof1PositionX);
6068 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionY[5]", myTof1PositionY);
6069 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionZ[5]", myTof1PositionZ);
6070 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumX[5]", myTof1MomentumX);
6071 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumY[5]", myTof1MomentumY);
6072 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumZ[5]", myTof1MomentumZ);
6073 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeName[5]", myTof1VolumeName);
6074 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeNumber[5]", myTof1VolumeNumber);
6075 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1[5]", myTof1);
6076 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1Path[5]", myTof1Path);
6077 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongZ[5]", myTof1PosSigmaAlongZ);
6078 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongT[5]", myTof1PosSigmaAlongT);
6079 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongX[5]", myTof1PosSigmaAlongX);
6080 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongY[5]", myTof1PosSigmaAlongY);
6081 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1ErrorMatrix[5][6][6]", myTof1ErrorMatrix);
6082 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionX[5]", myTof2PositionX);
6083 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionY[5]", myTof2PositionY);
6084 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionZ[5]", myTof2PositionZ);
6085 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumX[5]", myTof2MomentumX);
6086 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumY[5]", myTof2MomentumY);
6087 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumZ[5]", myTof2MomentumZ);
6088 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeName[5]", myTof2VolumeName);
6089 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeNumber[5]", myTof2VolumeNumber);
6090 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2[5]", myTof2);
6091 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2Path[5]", myTof2Path);
6092 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongZ[5]", myTof2PosSigmaAlongZ);
6093 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongT[5]", myTof2PosSigmaAlongT);
6094 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongX[5]", myTof2PosSigmaAlongX);
6095 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongY[5]", myTof2PosSigmaAlongY);
6096 R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2ErrorMatrix[5][6][6]", myTof2ErrorMatrix);
6097 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionX[5]", myEmcPositionX);
6098 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionY[5]", myEmcPositionY);
6099 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionZ[5]", myEmcPositionZ);
6100 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumX[5]", myEmcMomentumX);
6101 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumY[5]", myEmcMomentumY);
6102 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumZ[5]", myEmcMomentumZ);
6103 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeName[5]", myEmcVolumeName);
6104 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeNumber[5]", myEmcVolumeNumber);
6105 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongTheta[5]", myEmcPosSigmaAlongTheta);
6106 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongPhi[5]", myEmcPosSigmaAlongPhi);
6107 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcErrorMatrix[5][6][6]", myEmcErrorMatrix);
6108 R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPath[5]", myEmcPath);
6109 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionX[5]", myMucPositionX);
6110 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionY[5]", myMucPositionY);
6111 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionZ[5]", myMucPositionZ);
6112 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumX[5]", myMucMomentumX);
6113 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumY[5]", myMucMomentumY);
6114 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumZ[5]", myMucMomentumZ);
6115 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeName[5]", myMucVolumeName);
6116 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeNumber[5]", myMucVolumeNumber);
6117 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongZ[5]", myMucPosSigmaAlongZ);
6118 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongT[5]", myMucPosSigmaAlongT);
6119 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongX[5]", myMucPosSigmaAlongX);
6120 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongY[5]", myMucPosSigmaAlongY);
6121 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucErrorMatrix[5][6][6]", myMucErrorMatrix);
6122 R__insp.Inspect(R__cl, R__insp.GetParent(), "mySize[5]", mySize);
6123 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionX[5]", myPositionX);
6124 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionY[5]", myPositionY);
6125 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionZ[5]", myPositionZ);
6126 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumX[5]", myMomentumX);
6127 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumY[5]", myMomentumY);
6128 R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumZ[5]", myMomentumZ);
6129 R__insp.Inspect(R__cl, R__insp.GetParent(), "myVolumeName[5]", myVolumeName);
6130 R__insp.Inspect(R__cl, R__insp.GetParent(), "myVolumeNumber[5]", myVolumeNumber);
6131 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongZ[5]", myPosSigmaAlongZ);
6132 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongT[5]", myPosSigmaAlongT);
6133 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongX[5]", myPosSigmaAlongX);
6134 R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongY[5]", myPosSigmaAlongY);
6135 R__insp.Inspect(R__cl, R__insp.GetParent(), "myErrorMatrix[5]", myErrorMatrix);
6136 TObject::ShowMembers(R__insp);
6137}
6138
6139namespace ROOT {
6140 // Wrappers around operator new
6141 static void *new_TRecExtTrack(void *p) {
6142 return p ? new(p) ::TRecExtTrack : new ::TRecExtTrack;
6143 }
6144 static void *newArray_TRecExtTrack(Long_t nElements, void *p) {
6145 return p ? new(p) ::TRecExtTrack[nElements] : new ::TRecExtTrack[nElements];
6146 }
6147 // Wrapper around operator delete
6148 static void delete_TRecExtTrack(void *p) {
6149 delete ((::TRecExtTrack*)p);
6150 }
6151 static void deleteArray_TRecExtTrack(void *p) {
6152 delete [] ((::TRecExtTrack*)p);
6153 }
6154 static void destruct_TRecExtTrack(void *p) {
6155 typedef ::TRecExtTrack current_t;
6156 ((current_t*)p)->~current_t();
6157 }
6158} // end of namespace ROOT for class ::TRecExtTrack
6159
6160//______________________________________________________________________________
6161void TRecZddChannel::Streamer(TBuffer &R__b)
6162{
6163 // Stream an object of class TRecZddChannel.
6164
6165 if (R__b.IsReading()) {
6166 R__b.ReadClassBuffer(TRecZddChannel::Class(),this);
6167 } else {
6168 R__b.WriteClassBuffer(TRecZddChannel::Class(),this);
6169 }
6170}
6171
6172//______________________________________________________________________________
6173void TRecZddChannel::ShowMembers(TMemberInspector &R__insp)
6174{
6175 // Inspect the data members of an object of class TRecZddChannel.
6176 TClass *R__cl = ::TRecZddChannel::IsA();
6177 if (R__cl || R__insp.IsA()) { }
6178 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chId", &m_chId);
6179 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_scanCode", &m_scanCode);
6180 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_baseLine", &m_baseLine);
6181 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phase", &m_phase);
6182 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_frags", (void*)&m_frags);
6183 R__insp.InspectMember("vector<std::pair<Int_t,Float_t> >", (void*)&m_frags, "m_frags.", false);
6184 TObject::ShowMembers(R__insp);
6185}
6186
6187namespace ROOT {
6188 // Wrappers around operator new
6189 static void *new_TRecZddChannel(void *p) {
6190 return p ? new(p) ::TRecZddChannel : new ::TRecZddChannel;
6191 }
6192 static void *newArray_TRecZddChannel(Long_t nElements, void *p) {
6193 return p ? new(p) ::TRecZddChannel[nElements] : new ::TRecZddChannel[nElements];
6194 }
6195 // Wrapper around operator delete
6196 static void delete_TRecZddChannel(void *p) {
6197 delete ((::TRecZddChannel*)p);
6198 }
6199 static void deleteArray_TRecZddChannel(void *p) {
6200 delete [] ((::TRecZddChannel*)p);
6201 }
6202 static void destruct_TRecZddChannel(void *p) {
6203 typedef ::TRecZddChannel current_t;
6204 ((current_t*)p)->~current_t();
6205 }
6206} // end of namespace ROOT for class ::TRecZddChannel
6207
6208//______________________________________________________________________________
6209void TTrigEvent::Streamer(TBuffer &R__b)
6210{
6211 // Stream an object of class TTrigEvent.
6212
6213 if (R__b.IsReading()) {
6214 R__b.ReadClassBuffer(TTrigEvent::Class(),this);
6215 } else {
6216 R__b.WriteClassBuffer(TTrigEvent::Class(),this);
6217 }
6218}
6219
6220//______________________________________________________________________________
6221void TTrigEvent::ShowMembers(TMemberInspector &R__insp)
6222{
6223 // Inspect the data members of an object of class TTrigEvent.
6224 TClass *R__cl = ::TTrigEvent::IsA();
6225 if (R__cl || R__insp.IsA()) { }
6226 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_trigData", &m_trigData);
6227 TObject::ShowMembers(R__insp);
6228}
6229
6230namespace ROOT {
6231 // Wrappers around operator new
6232 static void *new_TTrigEvent(void *p) {
6233 return p ? new(p) ::TTrigEvent : new ::TTrigEvent;
6234 }
6235 static void *newArray_TTrigEvent(Long_t nElements, void *p) {
6236 return p ? new(p) ::TTrigEvent[nElements] : new ::TTrigEvent[nElements];
6237 }
6238 // Wrapper around operator delete
6239 static void delete_TTrigEvent(void *p) {
6240 delete ((::TTrigEvent*)p);
6241 }
6242 static void deleteArray_TTrigEvent(void *p) {
6243 delete [] ((::TTrigEvent*)p);
6244 }
6245 static void destruct_TTrigEvent(void *p) {
6246 typedef ::TTrigEvent current_t;
6247 ((current_t*)p)->~current_t();
6248 }
6249} // end of namespace ROOT for class ::TTrigEvent
6250
6251//______________________________________________________________________________
6252void TTrigData::Streamer(TBuffer &R__b)
6253{
6254 // Stream an object of class TTrigData.
6255
6256 if (R__b.IsReading()) {
6257 R__b.ReadClassBuffer(TTrigData::Class(),this);
6258 } else {
6259 R__b.WriteClassBuffer(TTrigData::Class(),this);
6260 }
6261}
6262
6263//______________________________________________________________________________
6264void TTrigData::ShowMembers(TMemberInspector &R__insp)
6265{
6266 // Inspect the data members of an object of class TTrigData.
6267 TClass *R__cl = ::TTrigData::IsA();
6268 if (R__cl || R__insp.IsA()) { }
6269 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_preScale", &m_preScale);
6270 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trigcond[48]", m_trigcond);
6271 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trigChan[16]", m_trigChan);
6272 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_timeWindow", &m_timeWindow);
6273 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Timing", &m_Timing);
6274 TObject::ShowMembers(R__insp);
6275}
6276
6277namespace ROOT {
6278 // Wrappers around operator new
6279 static void *new_TTrigData(void *p) {
6280 return p ? new(p) ::TTrigData : new ::TTrigData;
6281 }
6282 static void *newArray_TTrigData(Long_t nElements, void *p) {
6283 return p ? new(p) ::TTrigData[nElements] : new ::TTrigData[nElements];
6284 }
6285 // Wrapper around operator delete
6286 static void delete_TTrigData(void *p) {
6287 delete ((::TTrigData*)p);
6288 }
6289 static void deleteArray_TTrigData(void *p) {
6290 delete [] ((::TTrigData*)p);
6291 }
6292 static void destruct_TTrigData(void *p) {
6293 typedef ::TTrigData current_t;
6294 ((current_t*)p)->~current_t();
6295 }
6296} // end of namespace ROOT for class ::TTrigData
6297
6298//______________________________________________________________________________
6299void THltEvent::Streamer(TBuffer &R__b)
6300{
6301 // Stream an object of class THltEvent.
6302
6303 if (R__b.IsReading()) {
6304 R__b.ReadClassBuffer(THltEvent::Class(),this);
6305 } else {
6306 R__b.WriteClassBuffer(THltEvent::Class(),this);
6307 }
6308}
6309
6310//______________________________________________________________________________
6311void THltEvent::ShowMembers(TMemberInspector &R__insp)
6312{
6313 // Inspect the data members of an object of class THltEvent.
6314 TClass *R__cl = ::THltEvent::IsA();
6315 if (R__cl || R__insp.IsA()) { }
6316 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltRawCol", &m_hltRawCol);
6317 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltInf", &m_hltInf);
6318 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_dstHltInf", &m_dstHltInf);
6319 TObject::ShowMembers(R__insp);
6320}
6321
6322namespace ROOT {
6323 // Wrappers around operator new
6324 static void *new_THltEvent(void *p) {
6325 return p ? new(p) ::THltEvent : new ::THltEvent;
6326 }
6327 static void *newArray_THltEvent(Long_t nElements, void *p) {
6328 return p ? new(p) ::THltEvent[nElements] : new ::THltEvent[nElements];
6329 }
6330 // Wrapper around operator delete
6331 static void delete_THltEvent(void *p) {
6332 delete ((::THltEvent*)p);
6333 }
6334 static void deleteArray_THltEvent(void *p) {
6335 delete [] ((::THltEvent*)p);
6336 }
6337 static void destruct_THltEvent(void *p) {
6338 typedef ::THltEvent current_t;
6339 ((current_t*)p)->~current_t();
6340 }
6341} // end of namespace ROOT for class ::THltEvent
6342
6343//______________________________________________________________________________
6344void THltRaw::Streamer(TBuffer &R__b)
6345{
6346 // Stream an object of class THltRaw.
6347
6348 if (R__b.IsReading()) {
6349 R__b.ReadClassBuffer(THltRaw::Class(),this);
6350 } else {
6351 R__b.WriteClassBuffer(THltRaw::Class(),this);
6352 }
6353}
6354
6355//______________________________________________________________________________
6356void THltRaw::ShowMembers(TMemberInspector &R__insp)
6357{
6358 // Inspect the data members of an object of class THltRaw.
6359 TClass *R__cl = ::THltRaw::IsA();
6360 if (R__cl || R__insp.IsA()) { }
6361 TRawData::ShowMembers(R__insp);
6362}
6363
6364namespace ROOT {
6365 // Wrappers around operator new
6366 static void *new_THltRaw(void *p) {
6367 return p ? new(p) ::THltRaw : new ::THltRaw;
6368 }
6369 static void *newArray_THltRaw(Long_t nElements, void *p) {
6370 return p ? new(p) ::THltRaw[nElements] : new ::THltRaw[nElements];
6371 }
6372 // Wrapper around operator delete
6373 static void delete_THltRaw(void *p) {
6374 delete ((::THltRaw*)p);
6375 }
6376 static void deleteArray_THltRaw(void *p) {
6377 delete [] ((::THltRaw*)p);
6378 }
6379 static void destruct_THltRaw(void *p) {
6380 typedef ::THltRaw current_t;
6381 ((current_t*)p)->~current_t();
6382 }
6383} // end of namespace ROOT for class ::THltRaw
6384
6385//______________________________________________________________________________
6386void THltInf::Streamer(TBuffer &R__b)
6387{
6388 // Stream an object of class THltInf.
6389
6390 if (R__b.IsReading()) {
6391 R__b.ReadClassBuffer(THltInf::Class(),this);
6392 } else {
6393 R__b.WriteClassBuffer(THltInf::Class(),this);
6394 }
6395}
6396
6397//______________________________________________________________________________
6398void THltInf::ShowMembers(TMemberInspector &R__insp)
6399{
6400 // Inspect the data members of an object of class THltInf.
6401 TClass *R__cl = ::THltInf::IsA();
6402 if (R__cl || R__insp.IsA()) { }
6403 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_evtType", &m_evtType);
6404 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_algProcess", &m_algProcess);
6405 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_criTable", &m_criTable);
6406 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_verNumber", &m_verNumber);
6407 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eTotal", &m_eTotal);
6408 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_subNumber", &m_subNumber);
6409 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conNumber", &m_conNumber);
6410 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcData", (void*)&m_mdcData);
6411 R__insp.InspectMember("vector<Int_t>", (void*)&m_mdcData, "m_mdcData.", false);
6412 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofData", (void*)&m_tofData);
6413 R__insp.InspectMember("vector<Int_t>", (void*)&m_tofData, "m_tofData.", false);
6414 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_emcData", (void*)&m_emcData);
6415 R__insp.InspectMember("vector<Int_t>", (void*)&m_emcData, "m_emcData.", false);
6416 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mucData", (void*)&m_mucData);
6417 R__insp.InspectMember("vector<Int_t>", (void*)&m_mucData, "m_mucData.", false);
6418 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conData", (void*)&m_conData);
6419 R__insp.InspectMember("vector<Int_t>", (void*)&m_conData, "m_conData.", false);
6420 TObject::ShowMembers(R__insp);
6421}
6422
6423namespace ROOT {
6424 // Wrappers around operator new
6425 static void *new_THltInf(void *p) {
6426 return p ? new(p) ::THltInf : new ::THltInf;
6427 }
6428 static void *newArray_THltInf(Long_t nElements, void *p) {
6429 return p ? new(p) ::THltInf[nElements] : new ::THltInf[nElements];
6430 }
6431 // Wrapper around operator delete
6432 static void delete_THltInf(void *p) {
6433 delete ((::THltInf*)p);
6434 }
6435 static void deleteArray_THltInf(void *p) {
6436 delete [] ((::THltInf*)p);
6437 }
6438 static void destruct_THltInf(void *p) {
6439 typedef ::THltInf current_t;
6440 ((current_t*)p)->~current_t();
6441 }
6442} // end of namespace ROOT for class ::THltInf
6443
6444//______________________________________________________________________________
6445void TDstHltInf::Streamer(TBuffer &R__b)
6446{
6447 // Stream an object of class TDstHltInf.
6448
6449 if (R__b.IsReading()) {
6450 R__b.ReadClassBuffer(TDstHltInf::Class(),this);
6451 } else {
6452 R__b.WriteClassBuffer(TDstHltInf::Class(),this);
6453 }
6454}
6455
6456//______________________________________________________________________________
6457void TDstHltInf::ShowMembers(TMemberInspector &R__insp)
6458{
6459 // Inspect the data members of an object of class TDstHltInf.
6460 TClass *R__cl = ::TDstHltInf::IsA();
6461 if (R__cl || R__insp.IsA()) { }
6462 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_evtType", &m_evtType);
6463 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_algProcess", &m_algProcess);
6464 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_criTable", &m_criTable);
6465 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_verNumber", &m_verNumber);
6466 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eTotal", &m_eTotal);
6467 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_subNumber", &m_subNumber);
6468 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conNumber", &m_conNumber);
6469 TObject::ShowMembers(R__insp);
6470}
6471
6472namespace ROOT {
6473 // Wrappers around operator new
6474 static void *new_TDstHltInf(void *p) {
6475 return p ? new(p) ::TDstHltInf : new ::TDstHltInf;
6476 }
6477 static void *newArray_TDstHltInf(Long_t nElements, void *p) {
6478 return p ? new(p) ::TDstHltInf[nElements] : new ::TDstHltInf[nElements];
6479 }
6480 // Wrapper around operator delete
6481 static void delete_TDstHltInf(void *p) {
6482 delete ((::TDstHltInf*)p);
6483 }
6484 static void deleteArray_TDstHltInf(void *p) {
6485 delete [] ((::TDstHltInf*)p);
6486 }
6487 static void destruct_TDstHltInf(void *p) {
6488 typedef ::TDstHltInf current_t;
6489 ((current_t*)p)->~current_t();
6490 }
6491} // end of namespace ROOT for class ::TDstHltInf
6492
6493//______________________________________________________________________________
6494void TDisTrack::Streamer(TBuffer &R__b)
6495{
6496 // Stream an object of class TDisTrack.
6497
6498 UInt_t R__s, R__c;
6499 if (R__b.IsReading()) {
6500 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
6501 TObject::Streamer(R__b);
6502 R__b >> m_recMdcTrackCol;
6503 R__b >> m_recTofTrackCol;
6504 R__b >> m_recMdcHitCol;
6505 R__b >> m_recMucTrackCol;
6506 R__b >> m_recEmcShowerCol;
6507 R__b.CheckByteCount(R__s, R__c, TDisTrack::IsA());
6508 } else {
6509 R__c = R__b.WriteVersion(TDisTrack::IsA(), kTRUE);
6510 TObject::Streamer(R__b);
6511 R__b << m_recMdcTrackCol;
6512 R__b << m_recTofTrackCol;
6513 R__b << m_recMdcHitCol;
6514 R__b << m_recMucTrackCol;
6515 R__b << m_recEmcShowerCol;
6516 R__b.SetByteCount(R__c, kTRUE);
6517 }
6518}
6519
6520//______________________________________________________________________________
6521void TDisTrack::ShowMembers(TMemberInspector &R__insp)
6522{
6523 // Inspect the data members of an object of class TDisTrack.
6524 TClass *R__cl = ::TDisTrack::IsA();
6525 if (R__cl || R__insp.IsA()) { }
6526 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcTrackCol", &m_recMdcTrackCol);
6527 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recTofTrackCol", &m_recTofTrackCol);
6528 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcHitCol", &m_recMdcHitCol);
6529 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMucTrackCol", &m_recMucTrackCol);
6530 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcShowerCol", &m_recEmcShowerCol);
6531 TObject::ShowMembers(R__insp);
6532}
6533
6534namespace ROOT {
6535 // Wrappers around operator new
6536 static void *new_TDisTrack(void *p) {
6537 return p ? new(p) ::TDisTrack : new ::TDisTrack;
6538 }
6539 static void *newArray_TDisTrack(Long_t nElements, void *p) {
6540 return p ? new(p) ::TDisTrack[nElements] : new ::TDisTrack[nElements];
6541 }
6542 // Wrapper around operator delete
6543 static void delete_TDisTrack(void *p) {
6544 delete ((::TDisTrack*)p);
6545 }
6546 static void deleteArray_TDisTrack(void *p) {
6547 delete [] ((::TDisTrack*)p);
6548 }
6549 static void destruct_TDisTrack(void *p) {
6550 typedef ::TDisTrack current_t;
6551 ((current_t*)p)->~current_t();
6552 }
6553 // Wrapper around a custom streamer member function.
6554 static void streamer_TDisTrack(TBuffer &buf, void *obj) {
6555 ((::TDisTrack*)obj)->::TDisTrack::Streamer(buf);
6556 }
6557} // end of namespace ROOT for class ::TDisTrack
6558
6559//______________________________________________________________________________
6560void TEvtRecObject::Streamer(TBuffer &R__b)
6561{
6562 // Stream an object of class TEvtRecObject.
6563
6564 if (R__b.IsReading()) {
6565 R__b.ReadClassBuffer(TEvtRecObject::Class(),this);
6566 } else {
6567 R__b.WriteClassBuffer(TEvtRecObject::Class(),this);
6568 }
6569}
6570
6571//______________________________________________________________________________
6572void TEvtRecObject::ShowMembers(TMemberInspector &R__insp)
6573{
6574 // Inspect the data members of an object of class TEvtRecObject.
6575 TClass *R__cl = ::TEvtRecObject::IsA();
6576 if (R__cl || R__insp.IsA()) { }
6577 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecEvent", &m_evtRecEvent);
6578 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecTrackCol", &m_evtRecTrackCol);
6579 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecPrimaryVertex", &m_evtRecPrimaryVertex);
6580 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecVeeVertexCol", &m_evtRecVeeVertexCol);
6581 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecPi0Col", &m_evtRecPi0Col);
6582 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecEtaToGGCol", &m_evtRecEtaToGGCol);
6583 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecDTagCol", &m_evtRecDTagCol);
6584 TObject::ShowMembers(R__insp);
6585}
6586
6587namespace ROOT {
6588 // Wrappers around operator new
6589 static void *new_TEvtRecObject(void *p) {
6590 return p ? new(p) ::TEvtRecObject : new ::TEvtRecObject;
6591 }
6592 static void *newArray_TEvtRecObject(Long_t nElements, void *p) {
6593 return p ? new(p) ::TEvtRecObject[nElements] : new ::TEvtRecObject[nElements];
6594 }
6595 // Wrapper around operator delete
6596 static void delete_TEvtRecObject(void *p) {
6597 delete ((::TEvtRecObject*)p);
6598 }
6599 static void deleteArray_TEvtRecObject(void *p) {
6600 delete [] ((::TEvtRecObject*)p);
6601 }
6602 static void destruct_TEvtRecObject(void *p) {
6603 typedef ::TEvtRecObject current_t;
6604 ((current_t*)p)->~current_t();
6605 }
6606} // end of namespace ROOT for class ::TEvtRecObject
6607
6608//______________________________________________________________________________
6609void TEvtRecEvent::Streamer(TBuffer &R__b)
6610{
6611 // Stream an object of class TEvtRecEvent.
6612
6613 if (R__b.IsReading()) {
6614 R__b.ReadClassBuffer(TEvtRecEvent::Class(),this);
6615 } else {
6616 R__b.WriteClassBuffer(TEvtRecEvent::Class(),this);
6617 }
6618}
6619
6620//______________________________________________________________________________
6621void TEvtRecEvent::ShowMembers(TMemberInspector &R__insp)
6622{
6623 // Inspect the data members of an object of class TEvtRecEvent.
6624 TClass *R__cl = ::TEvtRecEvent::IsA();
6625 if (R__cl || R__insp.IsA()) { }
6626 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tottks", &m_tottks);
6627 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nchrg", &m_nchrg);
6628 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nneu", &m_nneu);
6629 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nvee", &m_nvee);
6630 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_npi0", &m_npi0);
6631 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_neta", &m_neta);
6632 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndtag", &m_ndtag);
6633 TObject::ShowMembers(R__insp);
6634}
6635
6636namespace ROOT {
6637 // Wrappers around operator new
6638 static void *new_TEvtRecEvent(void *p) {
6639 return p ? new(p) ::TEvtRecEvent : new ::TEvtRecEvent;
6640 }
6641 static void *newArray_TEvtRecEvent(Long_t nElements, void *p) {
6642 return p ? new(p) ::TEvtRecEvent[nElements] : new ::TEvtRecEvent[nElements];
6643 }
6644 // Wrapper around operator delete
6645 static void delete_TEvtRecEvent(void *p) {
6646 delete ((::TEvtRecEvent*)p);
6647 }
6648 static void deleteArray_TEvtRecEvent(void *p) {
6649 delete [] ((::TEvtRecEvent*)p);
6650 }
6651 static void destruct_TEvtRecEvent(void *p) {
6652 typedef ::TEvtRecEvent current_t;
6653 ((current_t*)p)->~current_t();
6654 }
6655} // end of namespace ROOT for class ::TEvtRecEvent
6656
6657//______________________________________________________________________________
6658void TEvtRecTrack::Streamer(TBuffer &R__b)
6659{
6660 // Stream an object of class TEvtRecTrack.
6661
6662 if (R__b.IsReading()) {
6663 R__b.ReadClassBuffer(TEvtRecTrack::Class(),this);
6664 } else {
6665 R__b.WriteClassBuffer(TEvtRecTrack::Class(),this);
6666 }
6667}
6668
6669//______________________________________________________________________________
6670void TEvtRecTrack::ShowMembers(TMemberInspector &R__insp)
6671{
6672 // Inspect the data members of an object of class TEvtRecTrack.
6673 TClass *R__cl = ::TEvtRecTrack::IsA();
6674 if (R__cl || R__insp.IsA()) { }
6675 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
6676 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
6677 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
6678 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcTrackId", &m_mdcTrackId);
6679 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalTrackId", &m_mdcKalTrackId);
6680 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcDedxId", &m_mdcDedxId);
6681 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_extTrackId", &m_extTrackId);
6682 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_emcShowerId", &m_emcShowerId);
6683 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mucTrackId", &m_mucTrackId);
6684 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackIds", (void*)&m_tofTrackIds);
6685 R__insp.InspectMember("vector<Int_t>", (void*)&m_tofTrackIds, "m_tofTrackIds.", false);
6686 TObject::ShowMembers(R__insp);
6687}
6688
6689namespace ROOT {
6690 // Wrappers around operator new
6691 static void *new_TEvtRecTrack(void *p) {
6692 return p ? new(p) ::TEvtRecTrack : new ::TEvtRecTrack;
6693 }
6694 static void *newArray_TEvtRecTrack(Long_t nElements, void *p) {
6695 return p ? new(p) ::TEvtRecTrack[nElements] : new ::TEvtRecTrack[nElements];
6696 }
6697 // Wrapper around operator delete
6698 static void delete_TEvtRecTrack(void *p) {
6699 delete ((::TEvtRecTrack*)p);
6700 }
6701 static void deleteArray_TEvtRecTrack(void *p) {
6702 delete [] ((::TEvtRecTrack*)p);
6703 }
6704 static void destruct_TEvtRecTrack(void *p) {
6705 typedef ::TEvtRecTrack current_t;
6706 ((current_t*)p)->~current_t();
6707 }
6708} // end of namespace ROOT for class ::TEvtRecTrack
6709
6710//______________________________________________________________________________
6711void TEvtRecPrimaryVertex::Streamer(TBuffer &R__b)
6712{
6713 // Stream an object of class TEvtRecPrimaryVertex.
6714
6715 if (R__b.IsReading()) {
6716 R__b.ReadClassBuffer(TEvtRecPrimaryVertex::Class(),this);
6717 } else {
6718 R__b.WriteClassBuffer(TEvtRecPrimaryVertex::Class(),this);
6719 }
6720}
6721
6722//______________________________________________________________________________
6723void TEvtRecPrimaryVertex::ShowMembers(TMemberInspector &R__insp)
6724{
6725 // Inspect the data members of an object of class TEvtRecPrimaryVertex.
6726 TClass *R__cl = ::TEvtRecPrimaryVertex::IsA();
6727 if (R__cl || R__insp.IsA()) { }
6728 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isValid", &m_isValid);
6729 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTracks", &m_nTracks);
6730 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIdList", (void*)&m_trackIdList);
6731 R__insp.InspectMember("vector<Int_t>", (void*)&m_trackIdList, "m_trackIdList.", false);
6732 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
6733 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
6734 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fitMethod", &m_fitMethod);
6735 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vtx[3]", m_vtx);
6736 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Evtx[6]", m_Evtx);
6737 TObject::ShowMembers(R__insp);
6738}
6739
6740namespace ROOT {
6741 // Wrappers around operator new
6742 static void *new_TEvtRecPrimaryVertex(void *p) {
6743 return p ? new(p) ::TEvtRecPrimaryVertex : new ::TEvtRecPrimaryVertex;
6744 }
6745 static void *newArray_TEvtRecPrimaryVertex(Long_t nElements, void *p) {
6746 return p ? new(p) ::TEvtRecPrimaryVertex[nElements] : new ::TEvtRecPrimaryVertex[nElements];
6747 }
6748 // Wrapper around operator delete
6749 static void delete_TEvtRecPrimaryVertex(void *p) {
6750 delete ((::TEvtRecPrimaryVertex*)p);
6751 }
6752 static void deleteArray_TEvtRecPrimaryVertex(void *p) {
6753 delete [] ((::TEvtRecPrimaryVertex*)p);
6754 }
6755 static void destruct_TEvtRecPrimaryVertex(void *p) {
6756 typedef ::TEvtRecPrimaryVertex current_t;
6757 ((current_t*)p)->~current_t();
6758 }
6759} // end of namespace ROOT for class ::TEvtRecPrimaryVertex
6760
6761//______________________________________________________________________________
6762void TEvtRecVeeVertex::Streamer(TBuffer &R__b)
6763{
6764 // Stream an object of class TEvtRecVeeVertex.
6765
6766 if (R__b.IsReading()) {
6767 R__b.ReadClassBuffer(TEvtRecVeeVertex::Class(),this);
6768 } else {
6769 R__b.WriteClassBuffer(TEvtRecVeeVertex::Class(),this);
6770 }
6771}
6772
6773//______________________________________________________________________________
6774void TEvtRecVeeVertex::ShowMembers(TMemberInspector &R__insp)
6775{
6776 // Inspect the data members of an object of class TEvtRecVeeVertex.
6777 TClass *R__cl = ::TEvtRecVeeVertex::IsA();
6778 if (R__cl || R__insp.IsA()) { }
6779 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexId", &m_vertexId);
6780 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexType", &m_vertexType);
6781 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
6782 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
6783 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass", &m_mass);
6784 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_w[7]", m_w);
6785 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Ew[28]", m_Ew);
6786 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pair[2]", m_pair);
6787 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nCharge", &m_nCharge);
6788 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTracks", &m_nTracks);
6789 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_daughter[2]", m_daughter);
6790 TObject::ShowMembers(R__insp);
6791}
6792
6793namespace ROOT {
6794 // Wrappers around operator new
6795 static void *new_TEvtRecVeeVertex(void *p) {
6796 return p ? new(p) ::TEvtRecVeeVertex : new ::TEvtRecVeeVertex;
6797 }
6798 static void *newArray_TEvtRecVeeVertex(Long_t nElements, void *p) {
6799 return p ? new(p) ::TEvtRecVeeVertex[nElements] : new ::TEvtRecVeeVertex[nElements];
6800 }
6801 // Wrapper around operator delete
6802 static void delete_TEvtRecVeeVertex(void *p) {
6803 delete ((::TEvtRecVeeVertex*)p);
6804 }
6805 static void deleteArray_TEvtRecVeeVertex(void *p) {
6806 delete [] ((::TEvtRecVeeVertex*)p);
6807 }
6808 static void destruct_TEvtRecVeeVertex(void *p) {
6809 typedef ::TEvtRecVeeVertex current_t;
6810 ((current_t*)p)->~current_t();
6811 }
6812} // end of namespace ROOT for class ::TEvtRecVeeVertex
6813
6814//______________________________________________________________________________
6815void TEvtRecPi0::Streamer(TBuffer &R__b)
6816{
6817 // Stream an object of class TEvtRecPi0.
6818
6819 if (R__b.IsReading()) {
6820 R__b.ReadClassBuffer(TEvtRecPi0::Class(),this);
6821 } else {
6822 R__b.WriteClassBuffer(TEvtRecPi0::Class(),this);
6823 }
6824}
6825
6826//______________________________________________________________________________
6827void TEvtRecPi0::ShowMembers(TMemberInspector &R__insp)
6828{
6829 // Inspect the data members of an object of class TEvtRecPi0.
6830 TClass *R__cl = ::TEvtRecPi0::IsA();
6831 if (R__cl || R__insp.IsA()) { }
6832 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_unconMass", &m_unconMass);
6833 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq", &m_chisq);
6834 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPx", &m_hiPx);
6835 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPy", &m_hiPy);
6836 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPz", &m_hiPz);
6837 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPe", &m_hiPe);
6838 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPx", &m_loPx);
6839 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPy", &m_loPy);
6840 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPz", &m_loPz);
6841 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPe", &m_loPe);
6842 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiEnGamma", &m_hiEnGamma);
6843 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loEnGamma", &m_loEnGamma);
6844 TObject::ShowMembers(R__insp);
6845}
6846
6847namespace ROOT {
6848 // Wrappers around operator new
6849 static void *new_TEvtRecPi0(void *p) {
6850 return p ? new(p) ::TEvtRecPi0 : new ::TEvtRecPi0;
6851 }
6852 static void *newArray_TEvtRecPi0(Long_t nElements, void *p) {
6853 return p ? new(p) ::TEvtRecPi0[nElements] : new ::TEvtRecPi0[nElements];
6854 }
6855 // Wrapper around operator delete
6856 static void delete_TEvtRecPi0(void *p) {
6857 delete ((::TEvtRecPi0*)p);
6858 }
6859 static void deleteArray_TEvtRecPi0(void *p) {
6860 delete [] ((::TEvtRecPi0*)p);
6861 }
6862 static void destruct_TEvtRecPi0(void *p) {
6863 typedef ::TEvtRecPi0 current_t;
6864 ((current_t*)p)->~current_t();
6865 }
6866} // end of namespace ROOT for class ::TEvtRecPi0
6867
6868//______________________________________________________________________________
6869void TEvtRecEtaToGG::Streamer(TBuffer &R__b)
6870{
6871 // Stream an object of class TEvtRecEtaToGG.
6872
6873 if (R__b.IsReading()) {
6874 R__b.ReadClassBuffer(TEvtRecEtaToGG::Class(),this);
6875 } else {
6876 R__b.WriteClassBuffer(TEvtRecEtaToGG::Class(),this);
6877 }
6878}
6879
6880//______________________________________________________________________________
6881void TEvtRecEtaToGG::ShowMembers(TMemberInspector &R__insp)
6882{
6883 // Inspect the data members of an object of class TEvtRecEtaToGG.
6884 TClass *R__cl = ::TEvtRecEtaToGG::IsA();
6885 if (R__cl || R__insp.IsA()) { }
6886 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_unconMass", &m_unconMass);
6887 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq", &m_chisq);
6888 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPx", &m_hiPx);
6889 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPy", &m_hiPy);
6890 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPz", &m_hiPz);
6891 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPe", &m_hiPe);
6892 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPx", &m_loPx);
6893 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPy", &m_loPy);
6894 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPz", &m_loPz);
6895 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPe", &m_loPe);
6896 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiEnGamma", &m_hiEnGamma);
6897 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loEnGamma", &m_loEnGamma);
6898 TObject::ShowMembers(R__insp);
6899}
6900
6901namespace ROOT {
6902 // Wrappers around operator new
6903 static void *new_TEvtRecEtaToGG(void *p) {
6904 return p ? new(p) ::TEvtRecEtaToGG : new ::TEvtRecEtaToGG;
6905 }
6906 static void *newArray_TEvtRecEtaToGG(Long_t nElements, void *p) {
6907 return p ? new(p) ::TEvtRecEtaToGG[nElements] : new ::TEvtRecEtaToGG[nElements];
6908 }
6909 // Wrapper around operator delete
6910 static void delete_TEvtRecEtaToGG(void *p) {
6911 delete ((::TEvtRecEtaToGG*)p);
6912 }
6913 static void deleteArray_TEvtRecEtaToGG(void *p) {
6914 delete [] ((::TEvtRecEtaToGG*)p);
6915 }
6916 static void destruct_TEvtRecEtaToGG(void *p) {
6917 typedef ::TEvtRecEtaToGG current_t;
6918 ((current_t*)p)->~current_t();
6919 }
6920} // end of namespace ROOT for class ::TEvtRecEtaToGG
6921
6922//______________________________________________________________________________
6923void TEvtRecDTag::Streamer(TBuffer &R__b)
6924{
6925 // Stream an object of class TEvtRecDTag.
6926
6927 if (R__b.IsReading()) {
6928 R__b.ReadClassBuffer(TEvtRecDTag::Class(),this);
6929 } else {
6930 R__b.WriteClassBuffer(TEvtRecDTag::Class(),this);
6931 }
6932}
6933
6934//______________________________________________________________________________
6935void TEvtRecDTag::ShowMembers(TMemberInspector &R__insp)
6936{
6937 // Inspect the data members of an object of class TEvtRecDTag.
6938 TClass *R__cl = ::TEvtRecDTag::IsA();
6939 if (R__cl || R__insp.IsA()) { }
6940 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_decayMode", &m_decayMode);
6941 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
6942 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beamE", &m_beamE);
6943 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass", &m_mass);
6944 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mBC", &m_mBC);
6945 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaE", &m_deltaE);
6946 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charge", &m_charge);
6947 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charm", &m_charm);
6948 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numOfChildren", &m_numOfChildren);
6949 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
6950 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
6951 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
6952 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pe", &m_pe);
6953 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tracks", (void*)&m_tracks);
6954 R__insp.InspectMember("vector<Int_t>", (void*)&m_tracks, "m_tracks.", false);
6955 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_showers", (void*)&m_showers);
6956 R__insp.InspectMember("vector<Int_t>", (void*)&m_showers, "m_showers.", false);
6957 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_otherTracks", (void*)&m_otherTracks);
6958 R__insp.InspectMember("vector<Int_t>", (void*)&m_otherTracks, "m_otherTracks.", false);
6959 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_otherShowers", (void*)&m_otherShowers);
6960 R__insp.InspectMember("vector<Int_t>", (void*)&m_otherShowers, "m_otherShowers.", false);
6961 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pionId", (void*)&m_pionId);
6962 R__insp.InspectMember("vector<Int_t>", (void*)&m_pionId, "m_pionId.", false);
6963 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaonId", (void*)&m_kaonId);
6964 R__insp.InspectMember("vector<Int_t>", (void*)&m_kaonId, "m_kaonId.", false);
6965 TObject::ShowMembers(R__insp);
6966}
6967
6968namespace ROOT {
6969 // Wrappers around operator new
6970 static void *new_TEvtRecDTag(void *p) {
6971 return p ? new(p) ::TEvtRecDTag : new ::TEvtRecDTag;
6972 }
6973 static void *newArray_TEvtRecDTag(Long_t nElements, void *p) {
6974 return p ? new(p) ::TEvtRecDTag[nElements] : new ::TEvtRecDTag[nElements];
6975 }
6976 // Wrapper around operator delete
6977 static void delete_TEvtRecDTag(void *p) {
6978 delete ((::TEvtRecDTag*)p);
6979 }
6980 static void deleteArray_TEvtRecDTag(void *p) {
6981 delete [] ((::TEvtRecDTag*)p);
6982 }
6983 static void destruct_TEvtRecDTag(void *p) {
6984 typedef ::TEvtRecDTag current_t;
6985 ((current_t*)p)->~current_t();
6986 }
6987} // end of namespace ROOT for class ::TEvtRecDTag
6988
6989//______________________________________________________________________________
6990void TMcHitEvent::Streamer(TBuffer &R__b)
6991{
6992 // Stream an object of class TMcHitEvent.
6993
6994 if (R__b.IsReading()) {
6995 R__b.ReadClassBuffer(TMcHitEvent::Class(),this);
6996 } else {
6997 R__b.WriteClassBuffer(TMcHitEvent::Class(),this);
6998 }
6999}
7000
7001//______________________________________________________________________________
7002void TMcHitEvent::ShowMembers(TMemberInspector &R__insp)
7003{
7004 // Inspect the data members of an object of class TMcHitEvent.
7005 TClass *R__cl = ::TMcHitEvent::IsA();
7006 if (R__cl || R__insp.IsA()) { }
7007 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tTofMcHitCol", &m_tTofMcHitCol);
7008 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tMdcMcHitCol", &m_tMdcMcHitCol);
7009 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tEmcMcDigiCol", &m_tEmcMcDigiCol);
7010 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beamTime", &m_beamTime);
7011 TObject::ShowMembers(R__insp);
7012}
7013
7014namespace ROOT {
7015 // Wrappers around operator new
7016 static void *new_TMcHitEvent(void *p) {
7017 return p ? new(p) ::TMcHitEvent : new ::TMcHitEvent;
7018 }
7019 static void *newArray_TMcHitEvent(Long_t nElements, void *p) {
7020 return p ? new(p) ::TMcHitEvent[nElements] : new ::TMcHitEvent[nElements];
7021 }
7022 // Wrapper around operator delete
7023 static void delete_TMcHitEvent(void *p) {
7024 delete ((::TMcHitEvent*)p);
7025 }
7026 static void deleteArray_TMcHitEvent(void *p) {
7027 delete [] ((::TMcHitEvent*)p);
7028 }
7029 static void destruct_TMcHitEvent(void *p) {
7030 typedef ::TMcHitEvent current_t;
7031 ((current_t*)p)->~current_t();
7032 }
7033} // end of namespace ROOT for class ::TMcHitEvent
7034
7035//______________________________________________________________________________
7036void TMcDigiEmc::Streamer(TBuffer &R__b)
7037{
7038 // Stream an object of class TMcDigiEmc.
7039
7040 if (R__b.IsReading()) {
7041 R__b.ReadClassBuffer(TMcDigiEmc::Class(),this);
7042 } else {
7043 R__b.WriteClassBuffer(TMcDigiEmc::Class(),this);
7044 }
7045}
7046
7047//______________________________________________________________________________
7048void TMcDigiEmc::ShowMembers(TMemberInspector &R__insp)
7049{
7050 // Inspect the data members of an object of class TMcDigiEmc.
7051 TClass *R__cl = ::TMcDigiEmc::IsA();
7052 if (R__cl || R__insp.IsA()) { }
7053 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
7054 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTheta", &m_nTheta);
7055 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nPhi", &m_nPhi);
7056 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
7057 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
7058 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
7059 TObject::ShowMembers(R__insp);
7060}
7061
7062namespace ROOT {
7063 // Wrappers around operator new
7064 static void *new_TMcDigiEmc(void *p) {
7065 return p ? new(p) ::TMcDigiEmc : new ::TMcDigiEmc;
7066 }
7067 static void *newArray_TMcDigiEmc(Long_t nElements, void *p) {
7068 return p ? new(p) ::TMcDigiEmc[nElements] : new ::TMcDigiEmc[nElements];
7069 }
7070 // Wrapper around operator delete
7071 static void delete_TMcDigiEmc(void *p) {
7072 delete ((::TMcDigiEmc*)p);
7073 }
7074 static void deleteArray_TMcDigiEmc(void *p) {
7075 delete [] ((::TMcDigiEmc*)p);
7076 }
7077 static void destruct_TMcDigiEmc(void *p) {
7078 typedef ::TMcDigiEmc current_t;
7079 ((current_t*)p)->~current_t();
7080 }
7081} // end of namespace ROOT for class ::TMcDigiEmc
7082
7083//______________________________________________________________________________
7084void TMcHitTof::Streamer(TBuffer &R__b)
7085{
7086 // Stream an object of class TMcHitTof.
7087
7088 if (R__b.IsReading()) {
7089 R__b.ReadClassBuffer(TMcHitTof::Class(),this);
7090 } else {
7091 R__b.WriteClassBuffer(TMcHitTof::Class(),this);
7092 }
7093}
7094
7095//______________________________________________________________________________
7096void TMcHitTof::ShowMembers(TMemberInspector &R__insp)
7097{
7098 // Inspect the data members of an object of class TMcHitTof.
7099 TClass *R__cl = ::TMcHitTof::IsA();
7100 if (R__cl || R__insp.IsA()) { }
7101 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
7102 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_g4Index", &m_g4Index);
7103 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
7104 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_scinNb", &m_scinNb);
7105 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_edep", &m_edep);
7106 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stepL", &m_stepL);
7107 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackL", &m_trackL);
7108 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pos", &m_pos);
7109 R__insp.InspectMember(m_pos, "m_pos.");
7110 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
7111 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaT", &m_deltaT);
7112 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pDirection", &m_pDirection);
7113 R__insp.InspectMember(m_pDirection, "m_pDirection.");
7114 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_momentum", &m_momentum);
7115 R__insp.InspectMember(m_momentum, "m_momentum.");
7116 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charge", &m_charge);
7117 TObject::ShowMembers(R__insp);
7118}
7119
7120namespace ROOT {
7121 // Wrappers around operator new
7122 static void *new_TMcHitTof(void *p) {
7123 return p ? new(p) ::TMcHitTof : new ::TMcHitTof;
7124 }
7125 static void *newArray_TMcHitTof(Long_t nElements, void *p) {
7126 return p ? new(p) ::TMcHitTof[nElements] : new ::TMcHitTof[nElements];
7127 }
7128 // Wrapper around operator delete
7129 static void delete_TMcHitTof(void *p) {
7130 delete ((::TMcHitTof*)p);
7131 }
7132 static void deleteArray_TMcHitTof(void *p) {
7133 delete [] ((::TMcHitTof*)p);
7134 }
7135 static void destruct_TMcHitTof(void *p) {
7136 typedef ::TMcHitTof current_t;
7137 ((current_t*)p)->~current_t();
7138 }
7139} // end of namespace ROOT for class ::TMcHitTof
7140
7141//______________________________________________________________________________
7142void TMcHitMdc::Streamer(TBuffer &R__b)
7143{
7144 // Stream an object of class TMcHitMdc.
7145
7146 if (R__b.IsReading()) {
7147 R__b.ReadClassBuffer(TMcHitMdc::Class(),this);
7148 } else {
7149 R__b.WriteClassBuffer(TMcHitMdc::Class(),this);
7150 }
7151}
7152
7153//______________________________________________________________________________
7154void TMcHitMdc::ShowMembers(TMemberInspector &R__insp)
7155{
7156 // Inspect the data members of an object of class TMcHitMdc.
7157 TClass *R__cl = ::TMcHitMdc::IsA();
7158 if (R__cl || R__insp.IsA()) { }
7159 R__insp.Inspect(R__cl, R__insp.GetParent(), "trackID", &trackID);
7160 R__insp.Inspect(R__cl, R__insp.GetParent(), "layerNo", &layerNo);
7161 R__insp.Inspect(R__cl, R__insp.GetParent(), "cellNo", &cellNo);
7162 R__insp.Inspect(R__cl, R__insp.GetParent(), "edep", &edep);
7163 R__insp.Inspect(R__cl, R__insp.GetParent(), "pos", &pos);
7164 R__insp.InspectMember(pos, "pos.");
7165 R__insp.Inspect(R__cl, R__insp.GetParent(), "driftD", &driftD);
7166 R__insp.Inspect(R__cl, R__insp.GetParent(), "driftT", &driftT);
7167 R__insp.Inspect(R__cl, R__insp.GetParent(), "globalT", &globalT);
7168 R__insp.Inspect(R__cl, R__insp.GetParent(), "theta", &theta);
7169 R__insp.Inspect(R__cl, R__insp.GetParent(), "enterAngle", &enterAngle);
7170 R__insp.Inspect(R__cl, R__insp.GetParent(), "posFlag", &posFlag);
7171 TObject::ShowMembers(R__insp);
7172}
7173
7174namespace ROOT {
7175 // Wrappers around operator new
7176 static void *new_TMcHitMdc(void *p) {
7177 return p ? new(p) ::TMcHitMdc : new ::TMcHitMdc;
7178 }
7179 static void *newArray_TMcHitMdc(Long_t nElements, void *p) {
7180 return p ? new(p) ::TMcHitMdc[nElements] : new ::TMcHitMdc[nElements];
7181 }
7182 // Wrapper around operator delete
7183 static void delete_TMcHitMdc(void *p) {
7184 delete ((::TMcHitMdc*)p);
7185 }
7186 static void deleteArray_TMcHitMdc(void *p) {
7187 delete [] ((::TMcHitMdc*)p);
7188 }
7189 static void destruct_TMcHitMdc(void *p) {
7190 typedef ::TMcHitMdc current_t;
7191 ((current_t*)p)->~current_t();
7192 }
7193} // end of namespace ROOT for class ::TMcHitMdc
7194
7195//______________________________________________________________________________
7196void TJobInfo::Streamer(TBuffer &R__b)
7197{
7198 // Stream an object of class TJobInfo.
7199
7200 if (R__b.IsReading()) {
7201 R__b.ReadClassBuffer(TJobInfo::Class(),this);
7202 } else {
7203 R__b.WriteClassBuffer(TJobInfo::Class(),this);
7204 }
7205}
7206
7207//______________________________________________________________________________
7208void TJobInfo::ShowMembers(TMemberInspector &R__insp)
7209{
7210 // Inspect the data members of an object of class TJobInfo.
7211 TClass *R__cl = ::TJobInfo::IsA();
7212 if (R__cl || R__insp.IsA()) { }
7213 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_decayOptions", (void*)&m_decayOptions);
7214 R__insp.InspectMember("string", (void*)&m_decayOptions, "m_decayOptions.", false);
7215 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_bossVer", (void*)&m_bossVer);
7216 R__insp.InspectMember("string", (void*)&m_bossVer, "m_bossVer.", false);
7217 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_jobOptions", (void*)&m_jobOptions);
7218 R__insp.InspectMember("vector<string>", (void*)&m_jobOptions, "m_jobOptions.", false);
7219 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_totEvtNo", (void*)&m_totEvtNo);
7220 R__insp.InspectMember("vector<int>", (void*)&m_totEvtNo, "m_totEvtNo.", false);
7221 TObject::ShowMembers(R__insp);
7222}
7223
7224namespace ROOT {
7225 // Wrappers around operator new
7226 static void *new_TJobInfo(void *p) {
7227 return p ? new(p) ::TJobInfo : new ::TJobInfo;
7228 }
7229 static void *newArray_TJobInfo(Long_t nElements, void *p) {
7230 return p ? new(p) ::TJobInfo[nElements] : new ::TJobInfo[nElements];
7231 }
7232 // Wrapper around operator delete
7233 static void delete_TJobInfo(void *p) {
7234 delete ((::TJobInfo*)p);
7235 }
7236 static void deleteArray_TJobInfo(void *p) {
7237 delete [] ((::TJobInfo*)p);
7238 }
7239 static void destruct_TJobInfo(void *p) {
7240 typedef ::TJobInfo current_t;
7241 ((current_t*)p)->~current_t();
7242 }
7243} // end of namespace ROOT for class ::TJobInfo
7244
7245//______________________________________________________________________________
7246void TBossFullEvent::ShowMembers(TMemberInspector &R__insp)
7247{
7248 // Inspect the data members of an object of class TBossFullEvent.
7249 TClass *R__cl = ::TBossFullEvent::IsA();
7250 if (R__cl || R__insp.IsA()) { }
7251 R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mask", &m_mask);
7252 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EvtHeader", &m_EvtHeader);
7253 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_digiEvt", &m_digiEvt);
7254 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_dstEvt", &m_dstEvt);
7255 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mcEvt", &m_mcEvt);
7256 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_trigEvt", &m_trigEvt);
7257 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltEvt", &m_hltEvt);
7258 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_rectrackEvt", &m_rectrackEvt);
7259 R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecObject", &m_evtRecObject);
7260 TObject::ShowMembers(R__insp);
7261}
7262
7263namespace ROOT {
7264 // Wrappers around operator new
7265 static void *new_TBossFullEvent(void *p) {
7266 return p ? new(p) ::TBossFullEvent : new ::TBossFullEvent;
7267 }
7268 static void *newArray_TBossFullEvent(Long_t nElements, void *p) {
7269 return p ? new(p) ::TBossFullEvent[nElements] : new ::TBossFullEvent[nElements];
7270 }
7271 // Wrapper around operator delete
7272 static void delete_TBossFullEvent(void *p) {
7273 delete ((::TBossFullEvent*)p);
7274 }
7275 static void deleteArray_TBossFullEvent(void *p) {
7276 delete [] ((::TBossFullEvent*)p);
7277 }
7278 static void destruct_TBossFullEvent(void *p) {
7279 typedef ::TBossFullEvent current_t;
7280 ((current_t*)p)->~current_t();
7281 }
7282 // Wrapper around a custom streamer member function.
7283 static void streamer_TBossFullEvent(TBuffer &buf, void *obj) {
7284 ((::TBossFullEvent*)obj)->::TBossFullEvent::Streamer(buf);
7285 }
7286} // end of namespace ROOT for class ::TBossFullEvent
7287
7288namespace ROOT {
7289 void maplEintcOdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
7290 static void maplEintcOdoublegR_Dictionary();
7291 static void *new_maplEintcOdoublegR(void *p = 0);
7292 static void *newArray_maplEintcOdoublegR(Long_t size, void *p);
7293 static void delete_maplEintcOdoublegR(void *p);
7294 static void deleteArray_maplEintcOdoublegR(void *p);
7295 static void destruct_maplEintcOdoublegR(void *p);
7296
7297 // Function generating the singleton type initializer
7298 static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,double>*)
7299 {
7300 map<int,double> *ptr = 0;
7301 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,double>),0);
7302 static ::ROOT::TGenericClassInfo
7303 instance("map<int,double>", -2, "prec_stl/map", 63,
7304 typeid(map<int,double>), DefineBehavior(ptr, ptr),
7305 0, &maplEintcOdoublegR_Dictionary, isa_proxy, 0,
7306 sizeof(map<int,double>) );
7307 instance.SetNew(&new_maplEintcOdoublegR);
7308 instance.SetNewArray(&newArray_maplEintcOdoublegR);
7309 instance.SetDelete(&delete_maplEintcOdoublegR);
7310 instance.SetDeleteArray(&deleteArray_maplEintcOdoublegR);
7311 instance.SetDestructor(&destruct_maplEintcOdoublegR);
7312 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,double> >()));
7313 return &instance;
7314 }
7315 // Static variable to force the class initialization
7316 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7317
7318 // Dictionary for non-ClassDef classes
7319 static void maplEintcOdoublegR_Dictionary() {
7320 ::ROOT::GenerateInitInstanceLocal((const map<int,double>*)0x0)->GetClass();
7321 }
7322
7323} // end of namespace ROOT
7324
7325namespace ROOT {
7326 // Wrappers around operator new
7327 static void *new_maplEintcOdoublegR(void *p) {
7328 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,double> : new map<int,double>;
7329 }
7330 static void *newArray_maplEintcOdoublegR(Long_t nElements, void *p) {
7331 return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,double>[nElements] : new map<int,double>[nElements];
7332 }
7333 // Wrapper around operator delete
7334 static void delete_maplEintcOdoublegR(void *p) {
7335 delete ((map<int,double>*)p);
7336 }
7337 static void deleteArray_maplEintcOdoublegR(void *p) {
7338 delete [] ((map<int,double>*)p);
7339 }
7340 static void destruct_maplEintcOdoublegR(void *p) {
7341 typedef map<int,double> current_t;
7342 ((current_t*)p)->~current_t();
7343 }
7344} // end of namespace ROOT for class map<int,double>
7345
7346namespace ROOT {
7347 void multimaplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7348 static void multimaplEintcOintgR_Dictionary();
7349 static void *new_multimaplEintcOintgR(void *p = 0);
7350 static void *newArray_multimaplEintcOintgR(Long_t size, void *p);
7351 static void delete_multimaplEintcOintgR(void *p);
7352 static void deleteArray_multimaplEintcOintgR(void *p);
7353 static void destruct_multimaplEintcOintgR(void *p);
7354
7355 // Function generating the singleton type initializer
7356 static TGenericClassInfo *GenerateInitInstanceLocal(const multimap<int,int>*)
7357 {
7358 multimap<int,int> *ptr = 0;
7359 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,int>),0);
7360 static ::ROOT::TGenericClassInfo
7361 instance("multimap<int,int>", -2, "prec_stl/multimap", 63,
7362 typeid(multimap<int,int>), DefineBehavior(ptr, ptr),
7363 0, &multimaplEintcOintgR_Dictionary, isa_proxy, 0,
7364 sizeof(multimap<int,int>) );
7365 instance.SetNew(&new_multimaplEintcOintgR);
7366 instance.SetNewArray(&newArray_multimaplEintcOintgR);
7367 instance.SetDelete(&delete_multimaplEintcOintgR);
7368 instance.SetDeleteArray(&deleteArray_multimaplEintcOintgR);
7369 instance.SetDestructor(&destruct_multimaplEintcOintgR);
7370 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< multimap<int,int> >()));
7371 return &instance;
7372 }
7373 // Static variable to force the class initialization
7374 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multimap<int,int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7375
7376 // Dictionary for non-ClassDef classes
7377 static void multimaplEintcOintgR_Dictionary() {
7378 ::ROOT::GenerateInitInstanceLocal((const multimap<int,int>*)0x0)->GetClass();
7379 }
7380
7381} // end of namespace ROOT
7382
7383namespace ROOT {
7384 // Wrappers around operator new
7385 static void *new_multimaplEintcOintgR(void *p) {
7386 return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,int> : new multimap<int,int>;
7387 }
7388 static void *newArray_multimaplEintcOintgR(Long_t nElements, void *p) {
7389 return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,int>[nElements] : new multimap<int,int>[nElements];
7390 }
7391 // Wrapper around operator delete
7392 static void delete_multimaplEintcOintgR(void *p) {
7393 delete ((multimap<int,int>*)p);
7394 }
7395 static void deleteArray_multimaplEintcOintgR(void *p) {
7396 delete [] ((multimap<int,int>*)p);
7397 }
7398 static void destruct_multimaplEintcOintgR(void *p) {
7399 typedef multimap<int,int> current_t;
7400 ((current_t*)p)->~current_t();
7401 }
7402} // end of namespace ROOT for class multimap<int,int>
7403
7404namespace ROOT {
7405 void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7406 static void vectorlETStringgR_Dictionary();
7407 static void *new_vectorlETStringgR(void *p = 0);
7408 static void *newArray_vectorlETStringgR(Long_t size, void *p);
7409 static void delete_vectorlETStringgR(void *p);
7410 static void deleteArray_vectorlETStringgR(void *p);
7411 static void destruct_vectorlETStringgR(void *p);
7412
7413 // Function generating the singleton type initializer
7414 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
7415 {
7416 vector<TString> *ptr = 0;
7417 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
7418 static ::ROOT::TGenericClassInfo
7419 instance("vector<TString>", -2, "prec_stl/vector", 49,
7420 typeid(vector<TString>), DefineBehavior(ptr, ptr),
7421 0, &vectorlETStringgR_Dictionary, isa_proxy, 0,
7422 sizeof(vector<TString>) );
7423 instance.SetNew(&new_vectorlETStringgR);
7424 instance.SetNewArray(&newArray_vectorlETStringgR);
7425 instance.SetDelete(&delete_vectorlETStringgR);
7426 instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
7427 instance.SetDestructor(&destruct_vectorlETStringgR);
7428 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
7429 return &instance;
7430 }
7431 // Static variable to force the class initialization
7432 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7433
7434 // Dictionary for non-ClassDef classes
7435 static void vectorlETStringgR_Dictionary() {
7436 ::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
7437 }
7438
7439} // end of namespace ROOT
7440
7441namespace ROOT {
7442 // Wrappers around operator new
7443 static void *new_vectorlETStringgR(void *p) {
7444 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
7445 }
7446 static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
7447 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
7448 }
7449 // Wrapper around operator delete
7450 static void delete_vectorlETStringgR(void *p) {
7451 delete ((vector<TString>*)p);
7452 }
7453 static void deleteArray_vectorlETStringgR(void *p) {
7454 delete [] ((vector<TString>*)p);
7455 }
7456 static void destruct_vectorlETStringgR(void *p) {
7457 typedef vector<TString> current_t;
7458 ((current_t*)p)->~current_t();
7459 }
7460} // end of namespace ROOT for class vector<TString>
7461
7462namespace ROOT {
7463 void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
7464 static void vectorlEdoublegR_Dictionary();
7465 static void *new_vectorlEdoublegR(void *p = 0);
7466 static void *newArray_vectorlEdoublegR(Long_t size, void *p);
7467 static void delete_vectorlEdoublegR(void *p);
7468 static void deleteArray_vectorlEdoublegR(void *p);
7469 static void destruct_vectorlEdoublegR(void *p);
7470
7471 // Function generating the singleton type initializer
7472 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
7473 {
7474 vector<double> *ptr = 0;
7475 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
7476 static ::ROOT::TGenericClassInfo
7477 instance("vector<double>", -2, "vector.dll", 0,
7478 typeid(vector<double>), DefineBehavior(ptr, ptr),
7479 0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
7480 sizeof(vector<double>) );
7481 instance.SetNew(&new_vectorlEdoublegR);
7482 instance.SetNewArray(&newArray_vectorlEdoublegR);
7483 instance.SetDelete(&delete_vectorlEdoublegR);
7484 instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
7485 instance.SetDestructor(&destruct_vectorlEdoublegR);
7486 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
7487 return &instance;
7488 }
7489 // Static variable to force the class initialization
7490 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7491
7492 // Dictionary for non-ClassDef classes
7493 static void vectorlEdoublegR_Dictionary() {
7494 ::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
7495 }
7496
7497} // end of namespace ROOT
7498
7499namespace ROOT {
7500 // Wrappers around operator new
7501 static void *new_vectorlEdoublegR(void *p) {
7502 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
7503 }
7504 static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
7505 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
7506 }
7507 // Wrapper around operator delete
7508 static void delete_vectorlEdoublegR(void *p) {
7509 delete ((vector<double>*)p);
7510 }
7511 static void deleteArray_vectorlEdoublegR(void *p) {
7512 delete [] ((vector<double>*)p);
7513 }
7514 static void destruct_vectorlEdoublegR(void *p) {
7515 typedef vector<double> current_t;
7516 ((current_t*)p)->~current_t();
7517 }
7518} // end of namespace ROOT for class vector<double>
7519
7520namespace ROOT {
7521 void vectorlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7522 static void vectorlEfloatgR_Dictionary();
7523 static void *new_vectorlEfloatgR(void *p = 0);
7524 static void *newArray_vectorlEfloatgR(Long_t size, void *p);
7525 static void delete_vectorlEfloatgR(void *p);
7526 static void deleteArray_vectorlEfloatgR(void *p);
7527 static void destruct_vectorlEfloatgR(void *p);
7528
7529 // Function generating the singleton type initializer
7530 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<float>*)
7531 {
7532 vector<float> *ptr = 0;
7533 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>),0);
7534 static ::ROOT::TGenericClassInfo
7535 instance("vector<float>", -2, "vector.dll", 0,
7536 typeid(vector<float>), DefineBehavior(ptr, ptr),
7537 0, &vectorlEfloatgR_Dictionary, isa_proxy, 0,
7538 sizeof(vector<float>) );
7539 instance.SetNew(&new_vectorlEfloatgR);
7540 instance.SetNewArray(&newArray_vectorlEfloatgR);
7541 instance.SetDelete(&delete_vectorlEfloatgR);
7542 instance.SetDeleteArray(&deleteArray_vectorlEfloatgR);
7543 instance.SetDestructor(&destruct_vectorlEfloatgR);
7544 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<float> >()));
7545 return &instance;
7546 }
7547 // Static variable to force the class initialization
7548 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7549
7550 // Dictionary for non-ClassDef classes
7551 static void vectorlEfloatgR_Dictionary() {
7552 ::ROOT::GenerateInitInstanceLocal((const vector<float>*)0x0)->GetClass();
7553 }
7554
7555} // end of namespace ROOT
7556
7557namespace ROOT {
7558 // Wrappers around operator new
7559 static void *new_vectorlEfloatgR(void *p) {
7560 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float> : new vector<float>;
7561 }
7562 static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
7563 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float>[nElements] : new vector<float>[nElements];
7564 }
7565 // Wrapper around operator delete
7566 static void delete_vectorlEfloatgR(void *p) {
7567 delete ((vector<float>*)p);
7568 }
7569 static void deleteArray_vectorlEfloatgR(void *p) {
7570 delete [] ((vector<float>*)p);
7571 }
7572 static void destruct_vectorlEfloatgR(void *p) {
7573 typedef vector<float> current_t;
7574 ((current_t*)p)->~current_t();
7575 }
7576} // end of namespace ROOT for class vector<float>
7577
7578namespace ROOT {
7579 void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7580 static void vectorlEintgR_Dictionary();
7581 static void *new_vectorlEintgR(void *p = 0);
7582 static void *newArray_vectorlEintgR(Long_t size, void *p);
7583 static void delete_vectorlEintgR(void *p);
7584 static void deleteArray_vectorlEintgR(void *p);
7585 static void destruct_vectorlEintgR(void *p);
7586
7587 // Function generating the singleton type initializer
7588 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
7589 {
7590 vector<int> *ptr = 0;
7591 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
7592 static ::ROOT::TGenericClassInfo
7593 instance("vector<int>", -2, "prec_stl/vector", 49,
7594 typeid(vector<int>), DefineBehavior(ptr, ptr),
7595 0, &vectorlEintgR_Dictionary, isa_proxy, 0,
7596 sizeof(vector<int>) );
7597 instance.SetNew(&new_vectorlEintgR);
7598 instance.SetNewArray(&newArray_vectorlEintgR);
7599 instance.SetDelete(&delete_vectorlEintgR);
7600 instance.SetDeleteArray(&deleteArray_vectorlEintgR);
7601 instance.SetDestructor(&destruct_vectorlEintgR);
7602 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
7603 return &instance;
7604 }
7605 // Static variable to force the class initialization
7606 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7607
7608 // Dictionary for non-ClassDef classes
7609 static void vectorlEintgR_Dictionary() {
7610 ::ROOT::GenerateInitInstanceLocal((const vector<int>*)0x0)->GetClass();
7611 }
7612
7613} // end of namespace ROOT
7614
7615namespace ROOT {
7616 // Wrappers around operator new
7617 static void *new_vectorlEintgR(void *p) {
7618 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int> : new vector<int>;
7619 }
7620 static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
7621 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
7622 }
7623 // Wrapper around operator delete
7624 static void delete_vectorlEintgR(void *p) {
7625 delete ((vector<int>*)p);
7626 }
7627 static void deleteArray_vectorlEintgR(void *p) {
7628 delete [] ((vector<int>*)p);
7629 }
7630 static void destruct_vectorlEintgR(void *p) {
7631 typedef vector<int> current_t;
7632 ((current_t*)p)->~current_t();
7633 }
7634} // end of namespace ROOT for class vector<int>
7635
7636namespace ROOT {
7637 void vectorlEpairlEintcOfloatgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7638 static void vectorlEpairlEintcOfloatgRsPgR_Dictionary();
7639 static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p = 0);
7640 static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t size, void *p);
7641 static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p);
7642 static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p);
7643 static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p);
7644
7645 // Function generating the singleton type initializer
7646 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<int,float> >*)
7647 {
7648 vector<pair<int,float> > *ptr = 0;
7649 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<int,float> >),0);
7650 static ::ROOT::TGenericClassInfo
7651 instance("vector<pair<int,float> >", -2, "prec_stl/vector", 49,
7652 typeid(vector<pair<int,float> >), DefineBehavior(ptr, ptr),
7653 0, &vectorlEpairlEintcOfloatgRsPgR_Dictionary, isa_proxy, 0,
7654 sizeof(vector<pair<int,float> >) );
7655 instance.SetNew(&new_vectorlEpairlEintcOfloatgRsPgR);
7656 instance.SetNewArray(&newArray_vectorlEpairlEintcOfloatgRsPgR);
7657 instance.SetDelete(&delete_vectorlEpairlEintcOfloatgRsPgR);
7658 instance.SetDeleteArray(&deleteArray_vectorlEpairlEintcOfloatgRsPgR);
7659 instance.SetDestructor(&destruct_vectorlEpairlEintcOfloatgRsPgR);
7660 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<int,float> > >()));
7661 return &instance;
7662 }
7663 // Static variable to force the class initialization
7664 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7665
7666 // Dictionary for non-ClassDef classes
7667 static void vectorlEpairlEintcOfloatgRsPgR_Dictionary() {
7668 ::ROOT::GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0)->GetClass();
7669 }
7670
7671} // end of namespace ROOT
7672
7673namespace ROOT {
7674 // Wrappers around operator new
7675 static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7676 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,float> > : new vector<pair<int,float> >;
7677 }
7678 static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t nElements, void *p) {
7679 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,float> >[nElements] : new vector<pair<int,float> >[nElements];
7680 }
7681 // Wrapper around operator delete
7682 static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7683 delete ((vector<pair<int,float> >*)p);
7684 }
7685 static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7686 delete [] ((vector<pair<int,float> >*)p);
7687 }
7688 static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p) {
7689 typedef vector<pair<int,float> > current_t;
7690 ((current_t*)p)->~current_t();
7691 }
7692} // end of namespace ROOT for class vector<pair<int,float> >
7693
7694namespace ROOT {
7695 void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7696 static void vectorlEstringgR_Dictionary();
7697 static void *new_vectorlEstringgR(void *p = 0);
7698 static void *newArray_vectorlEstringgR(Long_t size, void *p);
7699 static void delete_vectorlEstringgR(void *p);
7700 static void deleteArray_vectorlEstringgR(void *p);
7701 static void destruct_vectorlEstringgR(void *p);
7702
7703 // Function generating the singleton type initializer
7704 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
7705 {
7706 vector<string> *ptr = 0;
7707 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
7708 static ::ROOT::TGenericClassInfo
7709 instance("vector<string>", -2, "prec_stl/vector", 49,
7710 typeid(vector<string>), DefineBehavior(ptr, ptr),
7711 0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
7712 sizeof(vector<string>) );
7713 instance.SetNew(&new_vectorlEstringgR);
7714 instance.SetNewArray(&newArray_vectorlEstringgR);
7715 instance.SetDelete(&delete_vectorlEstringgR);
7716 instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
7717 instance.SetDestructor(&destruct_vectorlEstringgR);
7718 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
7719 return &instance;
7720 }
7721 // Static variable to force the class initialization
7722 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7723
7724 // Dictionary for non-ClassDef classes
7725 static void vectorlEstringgR_Dictionary() {
7726 ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
7727 }
7728
7729} // end of namespace ROOT
7730
7731namespace ROOT {
7732 // Wrappers around operator new
7733 static void *new_vectorlEstringgR(void *p) {
7734 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
7735 }
7736 static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
7737 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
7738 }
7739 // Wrapper around operator delete
7740 static void delete_vectorlEstringgR(void *p) {
7741 delete ((vector<string>*)p);
7742 }
7743 static void deleteArray_vectorlEstringgR(void *p) {
7744 delete [] ((vector<string>*)p);
7745 }
7746 static void destruct_vectorlEstringgR(void *p) {
7747 typedef vector<string> current_t;
7748 ((current_t*)p)->~current_t();
7749 }
7750} // end of namespace ROOT for class vector<string>
7751
7752namespace ROOT {
7753 void vectorlEvectorlEdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
7754 static void vectorlEvectorlEdoublegRsPgR_Dictionary();
7755 static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0);
7756 static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p);
7757 static void delete_vectorlEvectorlEdoublegRsPgR(void *p);
7758 static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p);
7759 static void destruct_vectorlEvectorlEdoublegRsPgR(void *p);
7760
7761 // Function generating the singleton type initializer
7762 static TGenericClassInfo *GenerateInitInstanceLocal(const vector<vector<double> >*)
7763 {
7764 vector<vector<double> > *ptr = 0;
7765 static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >),0);
7766 static ::ROOT::TGenericClassInfo
7767 instance("vector<vector<double> >", -2, "prec_stl/vector", 49,
7768 typeid(vector<vector<double> >), DefineBehavior(ptr, ptr),
7769 0, &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0,
7770 sizeof(vector<vector<double> >) );
7771 instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR);
7772 instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR);
7773 instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR);
7774 instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR);
7775 instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR);
7776 instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<vector<double> > >()));
7777 return &instance;
7778 }
7779 // Static variable to force the class initialization
7780 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<vector<double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
7781
7782 // Dictionary for non-ClassDef classes
7783 static void vectorlEvectorlEdoublegRsPgR_Dictionary() {
7784 ::ROOT::GenerateInitInstanceLocal((const vector<vector<double> >*)0x0)->GetClass();
7785 }
7786
7787} // end of namespace ROOT
7788
7789namespace ROOT {
7790 // Wrappers around operator new
7791 static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
7792 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<vector<double> > : new vector<vector<double> >;
7793 }
7794 static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
7795 return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
7796 }
7797 // Wrapper around operator delete
7798 static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
7799 delete ((vector<vector<double> >*)p);
7800 }
7801 static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
7802 delete [] ((vector<vector<double> >*)p);
7803 }
7804 static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
7805 typedef vector<vector<double> > current_t;
7806 ((current_t*)p)->~current_t();
7807 }
7808} // end of namespace ROOT for class vector<vector<double> >
7809
7810/********************************************************
7811* ../RootEventData/RootEventData_rootcint.cxx
7812* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
7813* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
7814* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
7815********************************************************/
7816
7817#ifdef G__MEMTEST
7818#undef malloc
7819#undef free
7820#endif
7821
7822#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
7823#pragma GCC diagnostic ignored "-Wstrict-aliasing"
7824#endif
7825
7826extern "C" void G__cpp_reset_tagtableRootEventData_rootcint();
7827
7828extern "C" void G__set_cpp_environmentRootEventData_rootcint() {
7829 G__add_compiledheader("TObject.h");
7830 G__add_compiledheader("TMemberInspector.h");
7831 G__add_compiledheader("../RootEventData/TJobInfo.h");
7832 G__add_compiledheader("../RootEventData/TDigiEvent.h");
7833 G__add_compiledheader("../RootEventData/TRecTrackEvent.h");
7834 G__add_compiledheader("../RootEventData/TMdcDigi.h");
7835 G__add_compiledheader("../RootEventData/TEmcDigi.h");
7836 G__add_compiledheader("../RootEventData/TTofDigi.h");
7837 G__add_compiledheader("../RootEventData/TMucDigi.h");
7838 G__add_compiledheader("../RootEventData/TLumiDigi.h");
7839 G__add_compiledheader("../RootEventData/TDstEvent.h");
7840 G__add_compiledheader("../RootEventData/TEmcTrack.h");
7841 G__add_compiledheader("../RootEventData/TMdcTrack.h");
7842 G__add_compiledheader("../RootEventData/TRecMdcHit.h");
7843 G__add_compiledheader("../RootEventData/TRecMdcTrack.h");
7844 G__add_compiledheader("../RootEventData/TRecMucTrack.h");
7845 G__add_compiledheader("../RootEventData/TTofTrack.h");
7846 G__add_compiledheader("../RootEventData/TMucTrack.h");
7847 G__add_compiledheader("../RootEventData/TExtTrack.h");
7848 G__add_compiledheader("../RootEventData/TRecExtTrack.h");
7849 G__add_compiledheader("../RootEventData/TMdcKalTrack.h");
7850 G__add_compiledheader("../RootEventData/TRecMdcKalTrack.h");
7851 G__add_compiledheader("../RootEventData/TRecMdcKalHelixSeg.h");
7852 G__add_compiledheader("../RootEventData/TMdcDedx.h");
7853 G__add_compiledheader("../RootEventData/TRecMdcDedx.h");
7854 G__add_compiledheader("../RootEventData/TRecMdcDedxHit.h");
7855 G__add_compiledheader("../RootEventData/TMcEvent.h");
7856 G__add_compiledheader("../RootEventData/TEmcMc.h");
7857 G__add_compiledheader("../RootEventData/TMdcMc.h");
7858 G__add_compiledheader("../RootEventData/TTofMc.h");
7859 G__add_compiledheader("../RootEventData/TMucMc.h");
7860 G__add_compiledheader("../RootEventData/TMcParticle.h");
7861 G__add_compiledheader("../RootEventData/TRecEmcHit.h");
7862 G__add_compiledheader("../RootEventData/TRecEmcCluster.h");
7863 G__add_compiledheader("../RootEventData/TRecEmcShower.h");
7864 G__add_compiledheader("../RootEventData/TRecMucTrack.h");
7865 G__add_compiledheader("../RootEventData/TRecEvTime.h");
7866 G__add_compiledheader("../RootEventData/TRecZddChannel.h");
7867 G__add_compiledheader("../RootEventData/TEvtHeader.h");
7868 G__add_compiledheader("../RootEventData/TEvtNavigator.h");
7869 G__add_compiledheader("../RootEventData/TTrigEvent.h");
7870 G__add_compiledheader("../RootEventData/TTrigData.h");
7871 G__add_compiledheader("../RootEventData/THltEvent.h");
7872 G__add_compiledheader("../RootEventData/THltRaw.h");
7873 G__add_compiledheader("../RootEventData/THltInf.h");
7874 G__add_compiledheader("../RootEventData/TDstHltInf.h");
7875 G__add_compiledheader("../RootEventData/TDisTrack.h");
7876 G__add_compiledheader("../RootEventData/TEvtRecObject.h");
7877 G__add_compiledheader("../RootEventData/TEvtRecEvent.h");
7878 G__add_compiledheader("../RootEventData/TEvtRecTrack.h");
7879 G__add_compiledheader("../RootEventData/TMcHitEvent.h");
7880 G__add_compiledheader("../RootEventData/TMcHitTof.h");
7881 G__add_compiledheader("../RootEventData/TMcHitMdc.h");
7882 G__add_compiledheader("../RootEventData/TMcDigiEmc.h");
7883 G__add_compiledheader("../RootEventData/TEvtRecPrimaryVertex.h");
7884 G__add_compiledheader("../RootEventData/TEvtRecVeeVertex.h");
7885 G__add_compiledheader("../RootEventData/TEvtRecDTag.h");
7886 G__add_compiledheader("../RootEventData/TEvtRecPi0.h");
7887 G__add_compiledheader("../RootEventData/TBossFullEvent.h");
7888 G__cpp_reset_tagtableRootEventData_rootcint();
7889}
7890#include <new>
7891extern "C" int G__cpp_dllrevRootEventData_rootcint() { return(30051515); }
7892
7893/*********************************************************
7894* Member function Interface Method
7895*********************************************************/
7896
7897/* TJobInfo */
7898static int G__RootEventData_rootcint_168_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7899{
7900 TJobInfo* p = NULL;
7901 char* gvp = (char*) G__getgvp();
7902 int n = G__getaryconstruct();
7903 if (n) {
7904 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7905 p = new TJobInfo[n];
7906 } else {
7907 p = new((void*) gvp) TJobInfo[n];
7908 }
7909 } else {
7910 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
7911 p = new TJobInfo;
7912 } else {
7913 p = new((void*) gvp) TJobInfo;
7914 }
7915 }
7916 result7->obj.i = (long) p;
7917 result7->ref = (long) p;
7918 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
7919 return(1 || funcname || hash || result7 || libp) ;
7920}
7921
7922static int G__RootEventData_rootcint_168_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7923{
7924 {
7925 const string* pobj;
7926 const string xobj = ((const TJobInfo*) G__getstructoffset())->getBossVer();
7927 pobj = new string(xobj);
7928 result7->obj.i = (long) ((void*) pobj);
7929 result7->ref = result7->obj.i;
7930 G__store_tempobject(*result7);
7931 }
7932 return(1 || funcname || hash || result7 || libp) ;
7933}
7934
7935static int G__RootEventData_rootcint_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7936{
7937 {
7938 const vector<string>* pobj;
7939 const vector<string> xobj = ((const TJobInfo*) G__getstructoffset())->getJobOptions();
7940 pobj = new vector<string>(xobj);
7941 result7->obj.i = (long) ((void*) pobj);
7942 result7->ref = result7->obj.i;
7943 G__store_tempobject(*result7);
7944 }
7945 return(1 || funcname || hash || result7 || libp) ;
7946}
7947
7948static int G__RootEventData_rootcint_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7949{
7950 {
7951 const string* pobj;
7952 const string xobj = ((const TJobInfo*) G__getstructoffset())->getDecayOptions();
7953 pobj = new string(xobj);
7954 result7->obj.i = (long) ((void*) pobj);
7955 result7->ref = result7->obj.i;
7956 G__store_tempobject(*result7);
7957 }
7958 return(1 || funcname || hash || result7 || libp) ;
7959}
7960
7961static int G__RootEventData_rootcint_168_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7962{
7963 {
7964 const vector<int>* pobj;
7965 const vector<int> xobj = ((const TJobInfo*) G__getstructoffset())->getTotEvtNo();
7966 pobj = new vector<int>(xobj);
7967 result7->obj.i = (long) ((void*) pobj);
7968 result7->ref = result7->obj.i;
7969 G__store_tempobject(*result7);
7970 }
7971 return(1 || funcname || hash || result7 || libp) ;
7972}
7973
7974static int G__RootEventData_rootcint_168_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7975{
7976 ((TJobInfo*) G__getstructoffset())->setBossVer(*((string*) G__int(libp->para[0])));
7977 G__setnull(result7);
7978 return(1 || funcname || hash || result7 || libp) ;
7979}
7980
7981static int G__RootEventData_rootcint_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7982{
7983 ((TJobInfo*) G__getstructoffset())->addJobOptions(*((string*) G__int(libp->para[0])));
7984 G__setnull(result7);
7985 return(1 || funcname || hash || result7 || libp) ;
7986}
7987
7988static int G__RootEventData_rootcint_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7989{
7990 ((TJobInfo*) G__getstructoffset())->setJobOptions(*((vector<string>*) G__int(libp->para[0])));
7991 G__setnull(result7);
7992 return(1 || funcname || hash || result7 || libp) ;
7993}
7994
7995static int G__RootEventData_rootcint_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
7996{
7997 ((TJobInfo*) G__getstructoffset())->setDecayOptions(*((string*) G__int(libp->para[0])));
7998 G__setnull(result7);
7999 return(1 || funcname || hash || result7 || libp) ;
8000}
8001
8002static int G__RootEventData_rootcint_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8003{
8004 ((TJobInfo*) G__getstructoffset())->setTotEvtNo(*((vector<int>*) G__int(libp->para[0])));
8005 G__setnull(result7);
8006 return(1 || funcname || hash || result7 || libp) ;
8007}
8008
8009static int G__RootEventData_rootcint_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8010{
8011 G__letint(result7, 85, (long) TJobInfo::Class());
8012 return(1 || funcname || hash || result7 || libp) ;
8013}
8014
8015static int G__RootEventData_rootcint_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8016{
8017 G__letint(result7, 67, (long) TJobInfo::Class_Name());
8018 return(1 || funcname || hash || result7 || libp) ;
8019}
8020
8021static int G__RootEventData_rootcint_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8022{
8023 G__letint(result7, 115, (long) TJobInfo::Class_Version());
8024 return(1 || funcname || hash || result7 || libp) ;
8025}
8026
8027static int G__RootEventData_rootcint_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8028{
8029 TJobInfo::Dictionary();
8030 G__setnull(result7);
8031 return(1 || funcname || hash || result7 || libp) ;
8032}
8033
8034static int G__RootEventData_rootcint_168_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8035{
8036 ((TJobInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8037 G__setnull(result7);
8038 return(1 || funcname || hash || result7 || libp) ;
8039}
8040
8041static int G__RootEventData_rootcint_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8042{
8043 G__letint(result7, 67, (long) TJobInfo::DeclFileName());
8044 return(1 || funcname || hash || result7 || libp) ;
8045}
8046
8047static int G__RootEventData_rootcint_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8048{
8049 G__letint(result7, 105, (long) TJobInfo::ImplFileLine());
8050 return(1 || funcname || hash || result7 || libp) ;
8051}
8052
8053static int G__RootEventData_rootcint_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8054{
8055 G__letint(result7, 67, (long) TJobInfo::ImplFileName());
8056 return(1 || funcname || hash || result7 || libp) ;
8057}
8058
8059static int G__RootEventData_rootcint_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8060{
8061 G__letint(result7, 105, (long) TJobInfo::DeclFileLine());
8062 return(1 || funcname || hash || result7 || libp) ;
8063}
8064
8065// automatic copy constructor
8066static int G__RootEventData_rootcint_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8067
8068{
8069 TJobInfo* p;
8070 void* tmp = (void*) G__int(libp->para[0]);
8071 p = new TJobInfo(*(TJobInfo*) tmp);
8072 result7->obj.i = (long) p;
8073 result7->ref = (long) p;
8074 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
8075 return(1 || funcname || hash || result7 || libp) ;
8076}
8077
8078// automatic destructor
8079typedef TJobInfo G__TTJobInfo;
8080static int G__RootEventData_rootcint_168_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8081{
8082 char* gvp = (char*) G__getgvp();
8083 long soff = G__getstructoffset();
8084 int n = G__getaryconstruct();
8085 //
8086 //has_a_delete: 1
8087 //has_own_delete1arg: 0
8088 //has_own_delete2arg: 0
8089 //
8090 if (!soff) {
8091 return(1);
8092 }
8093 if (n) {
8094 if (gvp == (char*)G__PVOID) {
8095 delete[] (TJobInfo*) soff;
8096 } else {
8097 G__setgvp((long) G__PVOID);
8098 for (int i = n - 1; i >= 0; --i) {
8099 ((TJobInfo*) (soff+(sizeof(TJobInfo)*i)))->~G__TTJobInfo();
8100 }
8101 G__setgvp((long)gvp);
8102 }
8103 } else {
8104 if (gvp == (char*)G__PVOID) {
8105 delete (TJobInfo*) soff;
8106 } else {
8107 G__setgvp((long) G__PVOID);
8108 ((TJobInfo*) (soff))->~G__TTJobInfo();
8109 G__setgvp((long)gvp);
8110 }
8111 }
8112 G__setnull(result7);
8113 return(1 || funcname || hash || result7 || libp) ;
8114}
8115
8116// automatic assignment operator
8117static int G__RootEventData_rootcint_168_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8118{
8119 TJobInfo* dest = (TJobInfo*) G__getstructoffset();
8120 *dest = *(TJobInfo*) libp->para[0].ref;
8121 const TJobInfo& obj = *dest;
8122 result7->ref = (long) (&obj);
8123 result7->obj.i = (long) (&obj);
8124 return(1 || funcname || hash || result7 || libp) ;
8125}
8126
8127
8128/* TRawData */
8129static int G__RootEventData_rootcint_200_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8130{
8131 TRawData* p = NULL;
8132 char* gvp = (char*) G__getgvp();
8133 int n = G__getaryconstruct();
8134 if (n) {
8135 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8136 p = new TRawData[n];
8137 } else {
8138 p = new((void*) gvp) TRawData[n];
8139 }
8140 } else {
8141 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8142 p = new TRawData;
8143 } else {
8144 p = new((void*) gvp) TRawData;
8145 }
8146 }
8147 result7->obj.i = (long) p;
8148 result7->ref = (long) p;
8149 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
8150 return(1 || funcname || hash || result7 || libp) ;
8151}
8152
8153static int G__RootEventData_rootcint_200_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8154{
8155 switch (libp->paran) {
8156 case 3:
8157 ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
8158, (UInt_t) G__int(libp->para[2]));
8159 G__setnull(result7);
8160 break;
8161 case 2:
8162 ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
8163 G__setnull(result7);
8164 break;
8165 case 1:
8166 ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]));
8167 G__setnull(result7);
8168 break;
8169 }
8170 return(1 || funcname || hash || result7 || libp) ;
8171}
8172
8173static int G__RootEventData_rootcint_200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8174{
8175 ((TRawData*) G__getstructoffset())->setTrackIndex((const int) G__int(libp->para[0]));
8176 G__setnull(result7);
8177 return(1 || funcname || hash || result7 || libp) ;
8178}
8179
8180static int G__RootEventData_rootcint_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8181{
8182 G__letint(result7, 104, (long) ((const TRawData*) G__getstructoffset())->getIntId());
8183 return(1 || funcname || hash || result7 || libp) ;
8184}
8185
8186static int G__RootEventData_rootcint_200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8187{
8188 G__letint(result7, 104, (long) ((const TRawData*) G__getstructoffset())->getTimeChannel());
8189 return(1 || funcname || hash || result7 || libp) ;
8190}
8191
8192static int G__RootEventData_rootcint_200_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8193{
8194 G__letint(result7, 104, (long) ((const TRawData*) G__getstructoffset())->getChargeChannel());
8195 return(1 || funcname || hash || result7 || libp) ;
8196}
8197
8198static int G__RootEventData_rootcint_200_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8199{
8200 G__letint(result7, 105, (long) ((const TRawData*) G__getstructoffset())->getTrackIndex());
8201 return(1 || funcname || hash || result7 || libp) ;
8202}
8203
8204static int G__RootEventData_rootcint_200_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8205{
8206 G__letint(result7, 85, (long) TRawData::Class());
8207 return(1 || funcname || hash || result7 || libp) ;
8208}
8209
8210static int G__RootEventData_rootcint_200_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8211{
8212 G__letint(result7, 67, (long) TRawData::Class_Name());
8213 return(1 || funcname || hash || result7 || libp) ;
8214}
8215
8216static int G__RootEventData_rootcint_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8217{
8218 G__letint(result7, 115, (long) TRawData::Class_Version());
8219 return(1 || funcname || hash || result7 || libp) ;
8220}
8221
8222static int G__RootEventData_rootcint_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8223{
8224 TRawData::Dictionary();
8225 G__setnull(result7);
8226 return(1 || funcname || hash || result7 || libp) ;
8227}
8228
8229static int G__RootEventData_rootcint_200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8230{
8231 ((TRawData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8232 G__setnull(result7);
8233 return(1 || funcname || hash || result7 || libp) ;
8234}
8235
8236static int G__RootEventData_rootcint_200_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8237{
8238 G__letint(result7, 67, (long) TRawData::DeclFileName());
8239 return(1 || funcname || hash || result7 || libp) ;
8240}
8241
8242static int G__RootEventData_rootcint_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8243{
8244 G__letint(result7, 105, (long) TRawData::ImplFileLine());
8245 return(1 || funcname || hash || result7 || libp) ;
8246}
8247
8248static int G__RootEventData_rootcint_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8249{
8250 G__letint(result7, 67, (long) TRawData::ImplFileName());
8251 return(1 || funcname || hash || result7 || libp) ;
8252}
8253
8254static int G__RootEventData_rootcint_200_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8255{
8256 G__letint(result7, 105, (long) TRawData::DeclFileLine());
8257 return(1 || funcname || hash || result7 || libp) ;
8258}
8259
8260// automatic copy constructor
8261static int G__RootEventData_rootcint_200_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8262
8263{
8264 TRawData* p;
8265 void* tmp = (void*) G__int(libp->para[0]);
8266 p = new TRawData(*(TRawData*) tmp);
8267 result7->obj.i = (long) p;
8268 result7->ref = (long) p;
8269 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
8270 return(1 || funcname || hash || result7 || libp) ;
8271}
8272
8273// automatic destructor
8274typedef TRawData G__TTRawData;
8275static int G__RootEventData_rootcint_200_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8276{
8277 char* gvp = (char*) G__getgvp();
8278 long soff = G__getstructoffset();
8279 int n = G__getaryconstruct();
8280 //
8281 //has_a_delete: 1
8282 //has_own_delete1arg: 0
8283 //has_own_delete2arg: 0
8284 //
8285 if (!soff) {
8286 return(1);
8287 }
8288 if (n) {
8289 if (gvp == (char*)G__PVOID) {
8290 delete[] (TRawData*) soff;
8291 } else {
8292 G__setgvp((long) G__PVOID);
8293 for (int i = n - 1; i >= 0; --i) {
8294 ((TRawData*) (soff+(sizeof(TRawData)*i)))->~G__TTRawData();
8295 }
8296 G__setgvp((long)gvp);
8297 }
8298 } else {
8299 if (gvp == (char*)G__PVOID) {
8300 delete (TRawData*) soff;
8301 } else {
8302 G__setgvp((long) G__PVOID);
8303 ((TRawData*) (soff))->~G__TTRawData();
8304 G__setgvp((long)gvp);
8305 }
8306 }
8307 G__setnull(result7);
8308 return(1 || funcname || hash || result7 || libp) ;
8309}
8310
8311// automatic assignment operator
8312static int G__RootEventData_rootcint_200_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8313{
8314 TRawData* dest = (TRawData*) G__getstructoffset();
8315 *dest = *(TRawData*) libp->para[0].ref;
8316 const TRawData& obj = *dest;
8317 result7->ref = (long) (&obj);
8318 result7->obj.i = (long) (&obj);
8319 return(1 || funcname || hash || result7 || libp) ;
8320}
8321
8322
8323/* TMdcDigi */
8324static int G__RootEventData_rootcint_201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8325{
8326 TMdcDigi* p = NULL;
8327 char* gvp = (char*) G__getgvp();
8328 int n = G__getaryconstruct();
8329 if (n) {
8330 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8331 p = new TMdcDigi[n];
8332 } else {
8333 p = new((void*) gvp) TMdcDigi[n];
8334 }
8335 } else {
8336 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8337 p = new TMdcDigi;
8338 } else {
8339 p = new((void*) gvp) TMdcDigi;
8340 }
8341 }
8342 result7->obj.i = (long) p;
8343 result7->ref = (long) p;
8344 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
8345 return(1 || funcname || hash || result7 || libp) ;
8346}
8347
8348static int G__RootEventData_rootcint_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8349{
8350 ((TMdcDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
8351 G__setnull(result7);
8352 return(1 || funcname || hash || result7 || libp) ;
8353}
8354
8355static int G__RootEventData_rootcint_201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8356{
8357 G__letint(result7, 104, (long) ((const TMdcDigi*) G__getstructoffset())->getOverflow());
8358 return(1 || funcname || hash || result7 || libp) ;
8359}
8360
8361static int G__RootEventData_rootcint_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8362{
8363 G__letint(result7, 85, (long) TMdcDigi::Class());
8364 return(1 || funcname || hash || result7 || libp) ;
8365}
8366
8367static int G__RootEventData_rootcint_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8368{
8369 G__letint(result7, 67, (long) TMdcDigi::Class_Name());
8370 return(1 || funcname || hash || result7 || libp) ;
8371}
8372
8373static int G__RootEventData_rootcint_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8374{
8375 G__letint(result7, 115, (long) TMdcDigi::Class_Version());
8376 return(1 || funcname || hash || result7 || libp) ;
8377}
8378
8379static int G__RootEventData_rootcint_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8380{
8381 TMdcDigi::Dictionary();
8382 G__setnull(result7);
8383 return(1 || funcname || hash || result7 || libp) ;
8384}
8385
8386static int G__RootEventData_rootcint_201_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8387{
8388 ((TMdcDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8389 G__setnull(result7);
8390 return(1 || funcname || hash || result7 || libp) ;
8391}
8392
8393static int G__RootEventData_rootcint_201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8394{
8395 G__letint(result7, 67, (long) TMdcDigi::DeclFileName());
8396 return(1 || funcname || hash || result7 || libp) ;
8397}
8398
8399static int G__RootEventData_rootcint_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8400{
8401 G__letint(result7, 105, (long) TMdcDigi::ImplFileLine());
8402 return(1 || funcname || hash || result7 || libp) ;
8403}
8404
8405static int G__RootEventData_rootcint_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8406{
8407 G__letint(result7, 67, (long) TMdcDigi::ImplFileName());
8408 return(1 || funcname || hash || result7 || libp) ;
8409}
8410
8411static int G__RootEventData_rootcint_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8412{
8413 G__letint(result7, 105, (long) TMdcDigi::DeclFileLine());
8414 return(1 || funcname || hash || result7 || libp) ;
8415}
8416
8417// automatic copy constructor
8418static int G__RootEventData_rootcint_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8419
8420{
8421 TMdcDigi* p;
8422 void* tmp = (void*) G__int(libp->para[0]);
8423 p = new TMdcDigi(*(TMdcDigi*) tmp);
8424 result7->obj.i = (long) p;
8425 result7->ref = (long) p;
8426 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
8427 return(1 || funcname || hash || result7 || libp) ;
8428}
8429
8430// automatic destructor
8431typedef TMdcDigi G__TTMdcDigi;
8432static int G__RootEventData_rootcint_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8433{
8434 char* gvp = (char*) G__getgvp();
8435 long soff = G__getstructoffset();
8436 int n = G__getaryconstruct();
8437 //
8438 //has_a_delete: 1
8439 //has_own_delete1arg: 0
8440 //has_own_delete2arg: 0
8441 //
8442 if (!soff) {
8443 return(1);
8444 }
8445 if (n) {
8446 if (gvp == (char*)G__PVOID) {
8447 delete[] (TMdcDigi*) soff;
8448 } else {
8449 G__setgvp((long) G__PVOID);
8450 for (int i = n - 1; i >= 0; --i) {
8451 ((TMdcDigi*) (soff+(sizeof(TMdcDigi)*i)))->~G__TTMdcDigi();
8452 }
8453 G__setgvp((long)gvp);
8454 }
8455 } else {
8456 if (gvp == (char*)G__PVOID) {
8457 delete (TMdcDigi*) soff;
8458 } else {
8459 G__setgvp((long) G__PVOID);
8460 ((TMdcDigi*) (soff))->~G__TTMdcDigi();
8461 G__setgvp((long)gvp);
8462 }
8463 }
8464 G__setnull(result7);
8465 return(1 || funcname || hash || result7 || libp) ;
8466}
8467
8468// automatic assignment operator
8469static int G__RootEventData_rootcint_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8470{
8471 TMdcDigi* dest = (TMdcDigi*) G__getstructoffset();
8472 *dest = *(TMdcDigi*) libp->para[0].ref;
8473 const TMdcDigi& obj = *dest;
8474 result7->ref = (long) (&obj);
8475 result7->obj.i = (long) (&obj);
8476 return(1 || funcname || hash || result7 || libp) ;
8477}
8478
8479
8480/* TEmcDigi */
8481static int G__RootEventData_rootcint_202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8482{
8483 TEmcDigi* p = NULL;
8484 char* gvp = (char*) G__getgvp();
8485 int n = G__getaryconstruct();
8486 if (n) {
8487 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8488 p = new TEmcDigi[n];
8489 } else {
8490 p = new((void*) gvp) TEmcDigi[n];
8491 }
8492 } else {
8493 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8494 p = new TEmcDigi;
8495 } else {
8496 p = new((void*) gvp) TEmcDigi;
8497 }
8498 }
8499 result7->obj.i = (long) p;
8500 result7->ref = (long) p;
8501 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
8502 return(1 || funcname || hash || result7 || libp) ;
8503}
8504
8505static int G__RootEventData_rootcint_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8506{
8507 ((TEmcDigi*) G__getstructoffset())->setMeasure((const UInt_t) G__int(libp->para[0]));
8508 G__setnull(result7);
8509 return(1 || funcname || hash || result7 || libp) ;
8510}
8511
8512static int G__RootEventData_rootcint_202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8513{
8514 G__letint(result7, 104, (long) ((const TEmcDigi*) G__getstructoffset())->getMeasure());
8515 return(1 || funcname || hash || result7 || libp) ;
8516}
8517
8518static int G__RootEventData_rootcint_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8519{
8520 G__letint(result7, 85, (long) TEmcDigi::Class());
8521 return(1 || funcname || hash || result7 || libp) ;
8522}
8523
8524static int G__RootEventData_rootcint_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8525{
8526 G__letint(result7, 67, (long) TEmcDigi::Class_Name());
8527 return(1 || funcname || hash || result7 || libp) ;
8528}
8529
8530static int G__RootEventData_rootcint_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8531{
8532 G__letint(result7, 115, (long) TEmcDigi::Class_Version());
8533 return(1 || funcname || hash || result7 || libp) ;
8534}
8535
8536static int G__RootEventData_rootcint_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8537{
8538 TEmcDigi::Dictionary();
8539 G__setnull(result7);
8540 return(1 || funcname || hash || result7 || libp) ;
8541}
8542
8543static int G__RootEventData_rootcint_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8544{
8545 ((TEmcDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8546 G__setnull(result7);
8547 return(1 || funcname || hash || result7 || libp) ;
8548}
8549
8550static int G__RootEventData_rootcint_202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8551{
8552 G__letint(result7, 67, (long) TEmcDigi::DeclFileName());
8553 return(1 || funcname || hash || result7 || libp) ;
8554}
8555
8556static int G__RootEventData_rootcint_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8557{
8558 G__letint(result7, 105, (long) TEmcDigi::ImplFileLine());
8559 return(1 || funcname || hash || result7 || libp) ;
8560}
8561
8562static int G__RootEventData_rootcint_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8563{
8564 G__letint(result7, 67, (long) TEmcDigi::ImplFileName());
8565 return(1 || funcname || hash || result7 || libp) ;
8566}
8567
8568static int G__RootEventData_rootcint_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8569{
8570 G__letint(result7, 105, (long) TEmcDigi::DeclFileLine());
8571 return(1 || funcname || hash || result7 || libp) ;
8572}
8573
8574// automatic copy constructor
8575static int G__RootEventData_rootcint_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8576
8577{
8578 TEmcDigi* p;
8579 void* tmp = (void*) G__int(libp->para[0]);
8580 p = new TEmcDigi(*(TEmcDigi*) tmp);
8581 result7->obj.i = (long) p;
8582 result7->ref = (long) p;
8583 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
8584 return(1 || funcname || hash || result7 || libp) ;
8585}
8586
8587// automatic destructor
8588typedef TEmcDigi G__TTEmcDigi;
8589static int G__RootEventData_rootcint_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8590{
8591 char* gvp = (char*) G__getgvp();
8592 long soff = G__getstructoffset();
8593 int n = G__getaryconstruct();
8594 //
8595 //has_a_delete: 1
8596 //has_own_delete1arg: 0
8597 //has_own_delete2arg: 0
8598 //
8599 if (!soff) {
8600 return(1);
8601 }
8602 if (n) {
8603 if (gvp == (char*)G__PVOID) {
8604 delete[] (TEmcDigi*) soff;
8605 } else {
8606 G__setgvp((long) G__PVOID);
8607 for (int i = n - 1; i >= 0; --i) {
8608 ((TEmcDigi*) (soff+(sizeof(TEmcDigi)*i)))->~G__TTEmcDigi();
8609 }
8610 G__setgvp((long)gvp);
8611 }
8612 } else {
8613 if (gvp == (char*)G__PVOID) {
8614 delete (TEmcDigi*) soff;
8615 } else {
8616 G__setgvp((long) G__PVOID);
8617 ((TEmcDigi*) (soff))->~G__TTEmcDigi();
8618 G__setgvp((long)gvp);
8619 }
8620 }
8621 G__setnull(result7);
8622 return(1 || funcname || hash || result7 || libp) ;
8623}
8624
8625// automatic assignment operator
8626static int G__RootEventData_rootcint_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8627{
8628 TEmcDigi* dest = (TEmcDigi*) G__getstructoffset();
8629 *dest = *(TEmcDigi*) libp->para[0].ref;
8630 const TEmcDigi& obj = *dest;
8631 result7->ref = (long) (&obj);
8632 result7->obj.i = (long) (&obj);
8633 return(1 || funcname || hash || result7 || libp) ;
8634}
8635
8636
8637/* TTofDigi */
8638static int G__RootEventData_rootcint_203_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8639{
8640 TTofDigi* p = NULL;
8641 char* gvp = (char*) G__getgvp();
8642 int n = G__getaryconstruct();
8643 if (n) {
8644 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8645 p = new TTofDigi[n];
8646 } else {
8647 p = new((void*) gvp) TTofDigi[n];
8648 }
8649 } else {
8650 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8651 p = new TTofDigi;
8652 } else {
8653 p = new((void*) gvp) TTofDigi;
8654 }
8655 }
8656 result7->obj.i = (long) p;
8657 result7->ref = (long) p;
8658 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
8659 return(1 || funcname || hash || result7 || libp) ;
8660}
8661
8662static int G__RootEventData_rootcint_203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8663{
8664 ((TTofDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
8665 G__setnull(result7);
8666 return(1 || funcname || hash || result7 || libp) ;
8667}
8668
8669static int G__RootEventData_rootcint_203_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8670{
8671 G__letint(result7, 104, (long) ((const TTofDigi*) G__getstructoffset())->getOverflow());
8672 return(1 || funcname || hash || result7 || libp) ;
8673}
8674
8675static int G__RootEventData_rootcint_203_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8676{
8677 G__letint(result7, 85, (long) TTofDigi::Class());
8678 return(1 || funcname || hash || result7 || libp) ;
8679}
8680
8681static int G__RootEventData_rootcint_203_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8682{
8683 G__letint(result7, 67, (long) TTofDigi::Class_Name());
8684 return(1 || funcname || hash || result7 || libp) ;
8685}
8686
8687static int G__RootEventData_rootcint_203_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8688{
8689 G__letint(result7, 115, (long) TTofDigi::Class_Version());
8690 return(1 || funcname || hash || result7 || libp) ;
8691}
8692
8693static int G__RootEventData_rootcint_203_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8694{
8695 TTofDigi::Dictionary();
8696 G__setnull(result7);
8697 return(1 || funcname || hash || result7 || libp) ;
8698}
8699
8700static int G__RootEventData_rootcint_203_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8701{
8702 ((TTofDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8703 G__setnull(result7);
8704 return(1 || funcname || hash || result7 || libp) ;
8705}
8706
8707static int G__RootEventData_rootcint_203_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8708{
8709 G__letint(result7, 67, (long) TTofDigi::DeclFileName());
8710 return(1 || funcname || hash || result7 || libp) ;
8711}
8712
8713static int G__RootEventData_rootcint_203_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8714{
8715 G__letint(result7, 105, (long) TTofDigi::ImplFileLine());
8716 return(1 || funcname || hash || result7 || libp) ;
8717}
8718
8719static int G__RootEventData_rootcint_203_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8720{
8721 G__letint(result7, 67, (long) TTofDigi::ImplFileName());
8722 return(1 || funcname || hash || result7 || libp) ;
8723}
8724
8725static int G__RootEventData_rootcint_203_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8726{
8727 G__letint(result7, 105, (long) TTofDigi::DeclFileLine());
8728 return(1 || funcname || hash || result7 || libp) ;
8729}
8730
8731// automatic copy constructor
8732static int G__RootEventData_rootcint_203_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8733
8734{
8735 TTofDigi* p;
8736 void* tmp = (void*) G__int(libp->para[0]);
8737 p = new TTofDigi(*(TTofDigi*) tmp);
8738 result7->obj.i = (long) p;
8739 result7->ref = (long) p;
8740 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
8741 return(1 || funcname || hash || result7 || libp) ;
8742}
8743
8744// automatic destructor
8745typedef TTofDigi G__TTTofDigi;
8746static int G__RootEventData_rootcint_203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8747{
8748 char* gvp = (char*) G__getgvp();
8749 long soff = G__getstructoffset();
8750 int n = G__getaryconstruct();
8751 //
8752 //has_a_delete: 1
8753 //has_own_delete1arg: 0
8754 //has_own_delete2arg: 0
8755 //
8756 if (!soff) {
8757 return(1);
8758 }
8759 if (n) {
8760 if (gvp == (char*)G__PVOID) {
8761 delete[] (TTofDigi*) soff;
8762 } else {
8763 G__setgvp((long) G__PVOID);
8764 for (int i = n - 1; i >= 0; --i) {
8765 ((TTofDigi*) (soff+(sizeof(TTofDigi)*i)))->~G__TTTofDigi();
8766 }
8767 G__setgvp((long)gvp);
8768 }
8769 } else {
8770 if (gvp == (char*)G__PVOID) {
8771 delete (TTofDigi*) soff;
8772 } else {
8773 G__setgvp((long) G__PVOID);
8774 ((TTofDigi*) (soff))->~G__TTTofDigi();
8775 G__setgvp((long)gvp);
8776 }
8777 }
8778 G__setnull(result7);
8779 return(1 || funcname || hash || result7 || libp) ;
8780}
8781
8782// automatic assignment operator
8783static int G__RootEventData_rootcint_203_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8784{
8785 TTofDigi* dest = (TTofDigi*) G__getstructoffset();
8786 *dest = *(TTofDigi*) libp->para[0].ref;
8787 const TTofDigi& obj = *dest;
8788 result7->ref = (long) (&obj);
8789 result7->obj.i = (long) (&obj);
8790 return(1 || funcname || hash || result7 || libp) ;
8791}
8792
8793
8794/* TMucDigi */
8795static int G__RootEventData_rootcint_204_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8796{
8797 TMucDigi* p = NULL;
8798 char* gvp = (char*) G__getgvp();
8799 int n = G__getaryconstruct();
8800 if (n) {
8801 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8802 p = new TMucDigi[n];
8803 } else {
8804 p = new((void*) gvp) TMucDigi[n];
8805 }
8806 } else {
8807 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8808 p = new TMucDigi;
8809 } else {
8810 p = new((void*) gvp) TMucDigi;
8811 }
8812 }
8813 result7->obj.i = (long) p;
8814 result7->ref = (long) p;
8815 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
8816 return(1 || funcname || hash || result7 || libp) ;
8817}
8818
8819static int G__RootEventData_rootcint_204_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8820{
8821 G__letint(result7, 85, (long) TMucDigi::Class());
8822 return(1 || funcname || hash || result7 || libp) ;
8823}
8824
8825static int G__RootEventData_rootcint_204_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8826{
8827 G__letint(result7, 67, (long) TMucDigi::Class_Name());
8828 return(1 || funcname || hash || result7 || libp) ;
8829}
8830
8831static int G__RootEventData_rootcint_204_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8832{
8833 G__letint(result7, 115, (long) TMucDigi::Class_Version());
8834 return(1 || funcname || hash || result7 || libp) ;
8835}
8836
8837static int G__RootEventData_rootcint_204_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8838{
8839 TMucDigi::Dictionary();
8840 G__setnull(result7);
8841 return(1 || funcname || hash || result7 || libp) ;
8842}
8843
8844static int G__RootEventData_rootcint_204_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8845{
8846 ((TMucDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
8847 G__setnull(result7);
8848 return(1 || funcname || hash || result7 || libp) ;
8849}
8850
8851static int G__RootEventData_rootcint_204_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8852{
8853 G__letint(result7, 67, (long) TMucDigi::DeclFileName());
8854 return(1 || funcname || hash || result7 || libp) ;
8855}
8856
8857static int G__RootEventData_rootcint_204_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8858{
8859 G__letint(result7, 105, (long) TMucDigi::ImplFileLine());
8860 return(1 || funcname || hash || result7 || libp) ;
8861}
8862
8863static int G__RootEventData_rootcint_204_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8864{
8865 G__letint(result7, 67, (long) TMucDigi::ImplFileName());
8866 return(1 || funcname || hash || result7 || libp) ;
8867}
8868
8869static int G__RootEventData_rootcint_204_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8870{
8871 G__letint(result7, 105, (long) TMucDigi::DeclFileLine());
8872 return(1 || funcname || hash || result7 || libp) ;
8873}
8874
8875// automatic copy constructor
8876static int G__RootEventData_rootcint_204_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8877
8878{
8879 TMucDigi* p;
8880 void* tmp = (void*) G__int(libp->para[0]);
8881 p = new TMucDigi(*(TMucDigi*) tmp);
8882 result7->obj.i = (long) p;
8883 result7->ref = (long) p;
8884 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
8885 return(1 || funcname || hash || result7 || libp) ;
8886}
8887
8888// automatic destructor
8889typedef TMucDigi G__TTMucDigi;
8890static int G__RootEventData_rootcint_204_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8891{
8892 char* gvp = (char*) G__getgvp();
8893 long soff = G__getstructoffset();
8894 int n = G__getaryconstruct();
8895 //
8896 //has_a_delete: 1
8897 //has_own_delete1arg: 0
8898 //has_own_delete2arg: 0
8899 //
8900 if (!soff) {
8901 return(1);
8902 }
8903 if (n) {
8904 if (gvp == (char*)G__PVOID) {
8905 delete[] (TMucDigi*) soff;
8906 } else {
8907 G__setgvp((long) G__PVOID);
8908 for (int i = n - 1; i >= 0; --i) {
8909 ((TMucDigi*) (soff+(sizeof(TMucDigi)*i)))->~G__TTMucDigi();
8910 }
8911 G__setgvp((long)gvp);
8912 }
8913 } else {
8914 if (gvp == (char*)G__PVOID) {
8915 delete (TMucDigi*) soff;
8916 } else {
8917 G__setgvp((long) G__PVOID);
8918 ((TMucDigi*) (soff))->~G__TTMucDigi();
8919 G__setgvp((long)gvp);
8920 }
8921 }
8922 G__setnull(result7);
8923 return(1 || funcname || hash || result7 || libp) ;
8924}
8925
8926// automatic assignment operator
8927static int G__RootEventData_rootcint_204_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8928{
8929 TMucDigi* dest = (TMucDigi*) G__getstructoffset();
8930 *dest = *(TMucDigi*) libp->para[0].ref;
8931 const TMucDigi& obj = *dest;
8932 result7->ref = (long) (&obj);
8933 result7->obj.i = (long) (&obj);
8934 return(1 || funcname || hash || result7 || libp) ;
8935}
8936
8937
8938/* TLumiDigi */
8939static int G__RootEventData_rootcint_205_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8940{
8941 TLumiDigi* p = NULL;
8942 char* gvp = (char*) G__getgvp();
8943 int n = G__getaryconstruct();
8944 if (n) {
8945 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8946 p = new TLumiDigi[n];
8947 } else {
8948 p = new((void*) gvp) TLumiDigi[n];
8949 }
8950 } else {
8951 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
8952 p = new TLumiDigi;
8953 } else {
8954 p = new((void*) gvp) TLumiDigi;
8955 }
8956 }
8957 result7->obj.i = (long) p;
8958 result7->ref = (long) p;
8959 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
8960 return(1 || funcname || hash || result7 || libp) ;
8961}
8962
8963static int G__RootEventData_rootcint_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8964{
8965 ((TLumiDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
8966 G__setnull(result7);
8967 return(1 || funcname || hash || result7 || libp) ;
8968}
8969
8970static int G__RootEventData_rootcint_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8971{
8972 G__letint(result7, 104, (long) ((const TLumiDigi*) G__getstructoffset())->getOverflow());
8973 return(1 || funcname || hash || result7 || libp) ;
8974}
8975
8976static int G__RootEventData_rootcint_205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8977{
8978 G__letint(result7, 85, (long) TLumiDigi::Class());
8979 return(1 || funcname || hash || result7 || libp) ;
8980}
8981
8982static int G__RootEventData_rootcint_205_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8983{
8984 G__letint(result7, 67, (long) TLumiDigi::Class_Name());
8985 return(1 || funcname || hash || result7 || libp) ;
8986}
8987
8988static int G__RootEventData_rootcint_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8989{
8990 G__letint(result7, 115, (long) TLumiDigi::Class_Version());
8991 return(1 || funcname || hash || result7 || libp) ;
8992}
8993
8994static int G__RootEventData_rootcint_205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
8995{
8996 TLumiDigi::Dictionary();
8997 G__setnull(result7);
8998 return(1 || funcname || hash || result7 || libp) ;
8999}
9000
9001static int G__RootEventData_rootcint_205_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9002{
9003 ((TLumiDigi*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9004 G__setnull(result7);
9005 return(1 || funcname || hash || result7 || libp) ;
9006}
9007
9008static int G__RootEventData_rootcint_205_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9009{
9010 G__letint(result7, 67, (long) TLumiDigi::DeclFileName());
9011 return(1 || funcname || hash || result7 || libp) ;
9012}
9013
9014static int G__RootEventData_rootcint_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9015{
9016 G__letint(result7, 105, (long) TLumiDigi::ImplFileLine());
9017 return(1 || funcname || hash || result7 || libp) ;
9018}
9019
9020static int G__RootEventData_rootcint_205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9021{
9022 G__letint(result7, 67, (long) TLumiDigi::ImplFileName());
9023 return(1 || funcname || hash || result7 || libp) ;
9024}
9025
9026static int G__RootEventData_rootcint_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9027{
9028 G__letint(result7, 105, (long) TLumiDigi::DeclFileLine());
9029 return(1 || funcname || hash || result7 || libp) ;
9030}
9031
9032// automatic copy constructor
9033static int G__RootEventData_rootcint_205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9034
9035{
9036 TLumiDigi* p;
9037 void* tmp = (void*) G__int(libp->para[0]);
9038 p = new TLumiDigi(*(TLumiDigi*) tmp);
9039 result7->obj.i = (long) p;
9040 result7->ref = (long) p;
9041 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
9042 return(1 || funcname || hash || result7 || libp) ;
9043}
9044
9045// automatic destructor
9046typedef TLumiDigi G__TTLumiDigi;
9047static int G__RootEventData_rootcint_205_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9048{
9049 char* gvp = (char*) G__getgvp();
9050 long soff = G__getstructoffset();
9051 int n = G__getaryconstruct();
9052 //
9053 //has_a_delete: 1
9054 //has_own_delete1arg: 0
9055 //has_own_delete2arg: 0
9056 //
9057 if (!soff) {
9058 return(1);
9059 }
9060 if (n) {
9061 if (gvp == (char*)G__PVOID) {
9062 delete[] (TLumiDigi*) soff;
9063 } else {
9064 G__setgvp((long) G__PVOID);
9065 for (int i = n - 1; i >= 0; --i) {
9066 ((TLumiDigi*) (soff+(sizeof(TLumiDigi)*i)))->~G__TTLumiDigi();
9067 }
9068 G__setgvp((long)gvp);
9069 }
9070 } else {
9071 if (gvp == (char*)G__PVOID) {
9072 delete (TLumiDigi*) soff;
9073 } else {
9074 G__setgvp((long) G__PVOID);
9075 ((TLumiDigi*) (soff))->~G__TTLumiDigi();
9076 G__setgvp((long)gvp);
9077 }
9078 }
9079 G__setnull(result7);
9080 return(1 || funcname || hash || result7 || libp) ;
9081}
9082
9083// automatic assignment operator
9084static int G__RootEventData_rootcint_205_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9085{
9086 TLumiDigi* dest = (TLumiDigi*) G__getstructoffset();
9087 *dest = *(TLumiDigi*) libp->para[0].ref;
9088 const TLumiDigi& obj = *dest;
9089 result7->ref = (long) (&obj);
9090 result7->obj.i = (long) (&obj);
9091 return(1 || funcname || hash || result7 || libp) ;
9092}
9093
9094
9095/* TDigiEvent */
9096static int G__RootEventData_rootcint_206_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9097{
9098 TDigiEvent* p = NULL;
9099 char* gvp = (char*) G__getgvp();
9100 int n = G__getaryconstruct();
9101 if (n) {
9102 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9103 p = new TDigiEvent[n];
9104 } else {
9105 p = new((void*) gvp) TDigiEvent[n];
9106 }
9107 } else {
9108 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9109 p = new TDigiEvent;
9110 } else {
9111 p = new((void*) gvp) TDigiEvent;
9112 }
9113 }
9114 result7->obj.i = (long) p;
9115 result7->ref = (long) p;
9116 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
9117 return(1 || funcname || hash || result7 || libp) ;
9118}
9119
9120static int G__RootEventData_rootcint_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9121{
9122 switch (libp->paran) {
9123 case 1:
9124 ((TDigiEvent*) G__getstructoffset())->initialize((Bool_t) G__int(libp->para[0]));
9125 G__setnull(result7);
9126 break;
9127 case 0:
9128 ((TDigiEvent*) G__getstructoffset())->initialize();
9129 G__setnull(result7);
9130 break;
9131 }
9132 return(1 || funcname || hash || result7 || libp) ;
9133}
9134
9135static int G__RootEventData_rootcint_206_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9136{
9137 G__letint(result7, 103, (long) ((TDigiEvent*) G__getstructoffset())->getFromMc());
9138 return(1 || funcname || hash || result7 || libp) ;
9139}
9140
9141static int G__RootEventData_rootcint_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9142{
9143 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMdcDigiCol());
9144 return(1 || funcname || hash || result7 || libp) ;
9145}
9146
9147static int G__RootEventData_rootcint_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9148{
9149 ((TDigiEvent*) G__getstructoffset())->addMdcDigi((TMdcDigi*) G__int(libp->para[0]));
9150 G__setnull(result7);
9151 return(1 || funcname || hash || result7 || libp) ;
9152}
9153
9154static int G__RootEventData_rootcint_206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9155{
9156 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMdcDigi((Int_t) G__int(libp->para[0])));
9157 return(1 || funcname || hash || result7 || libp) ;
9158}
9159
9160static int G__RootEventData_rootcint_206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9161{
9162 ((TDigiEvent*) G__getstructoffset())->clearMdcDigiCol();
9163 G__setnull(result7);
9164 return(1 || funcname || hash || result7 || libp) ;
9165}
9166
9167static int G__RootEventData_rootcint_206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9168{
9169 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getEmcDigiCol());
9170 return(1 || funcname || hash || result7 || libp) ;
9171}
9172
9173static int G__RootEventData_rootcint_206_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9174{
9175 ((TDigiEvent*) G__getstructoffset())->addEmcDigi((TEmcDigi*) G__int(libp->para[0]));
9176 G__setnull(result7);
9177 return(1 || funcname || hash || result7 || libp) ;
9178}
9179
9180static int G__RootEventData_rootcint_206_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9181{
9182 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getEmcDigi((Int_t) G__int(libp->para[0])));
9183 return(1 || funcname || hash || result7 || libp) ;
9184}
9185
9186static int G__RootEventData_rootcint_206_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9187{
9188 ((TDigiEvent*) G__getstructoffset())->clearEmcDigiCol();
9189 G__setnull(result7);
9190 return(1 || funcname || hash || result7 || libp) ;
9191}
9192
9193static int G__RootEventData_rootcint_206_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9194{
9195 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getTofDigiCol());
9196 return(1 || funcname || hash || result7 || libp) ;
9197}
9198
9199static int G__RootEventData_rootcint_206_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9200{
9201 ((TDigiEvent*) G__getstructoffset())->addTofDigi((TTofDigi*) G__int(libp->para[0]));
9202 G__setnull(result7);
9203 return(1 || funcname || hash || result7 || libp) ;
9204}
9205
9206static int G__RootEventData_rootcint_206_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9207{
9208 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getTofDigi((Int_t) G__int(libp->para[0])));
9209 return(1 || funcname || hash || result7 || libp) ;
9210}
9211
9212static int G__RootEventData_rootcint_206_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9213{
9214 ((TDigiEvent*) G__getstructoffset())->clearTofDigiCol();
9215 G__setnull(result7);
9216 return(1 || funcname || hash || result7 || libp) ;
9217}
9218
9219static int G__RootEventData_rootcint_206_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9220{
9221 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMucDigiCol());
9222 return(1 || funcname || hash || result7 || libp) ;
9223}
9224
9225static int G__RootEventData_rootcint_206_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9226{
9227 ((TDigiEvent*) G__getstructoffset())->addMucDigi((TMucDigi*) G__int(libp->para[0]));
9228 G__setnull(result7);
9229 return(1 || funcname || hash || result7 || libp) ;
9230}
9231
9232static int G__RootEventData_rootcint_206_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9233{
9234 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMucDigi((Int_t) G__int(libp->para[0])));
9235 return(1 || funcname || hash || result7 || libp) ;
9236}
9237
9238static int G__RootEventData_rootcint_206_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9239{
9240 ((TDigiEvent*) G__getstructoffset())->clearMucDigiCol();
9241 G__setnull(result7);
9242 return(1 || funcname || hash || result7 || libp) ;
9243}
9244
9245static int G__RootEventData_rootcint_206_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9246{
9247 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getLumiDigiCol());
9248 return(1 || funcname || hash || result7 || libp) ;
9249}
9250
9251static int G__RootEventData_rootcint_206_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9252{
9253 ((TDigiEvent*) G__getstructoffset())->addLumiDigi((TLumiDigi*) G__int(libp->para[0]));
9254 G__setnull(result7);
9255 return(1 || funcname || hash || result7 || libp) ;
9256}
9257
9258static int G__RootEventData_rootcint_206_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9259{
9260 G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getLumiDigi((Int_t) G__int(libp->para[0])));
9261 return(1 || funcname || hash || result7 || libp) ;
9262}
9263
9264static int G__RootEventData_rootcint_206_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9265{
9266 ((TDigiEvent*) G__getstructoffset())->clearLumiDigiCol();
9267 G__setnull(result7);
9268 return(1 || funcname || hash || result7 || libp) ;
9269}
9270
9271static int G__RootEventData_rootcint_206_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9272{
9273 G__letint(result7, 85, (long) TDigiEvent::Class());
9274 return(1 || funcname || hash || result7 || libp) ;
9275}
9276
9277static int G__RootEventData_rootcint_206_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9278{
9279 G__letint(result7, 67, (long) TDigiEvent::Class_Name());
9280 return(1 || funcname || hash || result7 || libp) ;
9281}
9282
9283static int G__RootEventData_rootcint_206_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9284{
9285 G__letint(result7, 115, (long) TDigiEvent::Class_Version());
9286 return(1 || funcname || hash || result7 || libp) ;
9287}
9288
9289static int G__RootEventData_rootcint_206_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9290{
9291 TDigiEvent::Dictionary();
9292 G__setnull(result7);
9293 return(1 || funcname || hash || result7 || libp) ;
9294}
9295
9296static int G__RootEventData_rootcint_206_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9297{
9298 ((TDigiEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9299 G__setnull(result7);
9300 return(1 || funcname || hash || result7 || libp) ;
9301}
9302
9303static int G__RootEventData_rootcint_206_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9304{
9305 G__letint(result7, 67, (long) TDigiEvent::DeclFileName());
9306 return(1 || funcname || hash || result7 || libp) ;
9307}
9308
9309static int G__RootEventData_rootcint_206_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9310{
9311 G__letint(result7, 105, (long) TDigiEvent::ImplFileLine());
9312 return(1 || funcname || hash || result7 || libp) ;
9313}
9314
9315static int G__RootEventData_rootcint_206_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9316{
9317 G__letint(result7, 67, (long) TDigiEvent::ImplFileName());
9318 return(1 || funcname || hash || result7 || libp) ;
9319}
9320
9321static int G__RootEventData_rootcint_206_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9322{
9323 G__letint(result7, 105, (long) TDigiEvent::DeclFileLine());
9324 return(1 || funcname || hash || result7 || libp) ;
9325}
9326
9327// automatic copy constructor
9328static int G__RootEventData_rootcint_206_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9329
9330{
9331 TDigiEvent* p;
9332 void* tmp = (void*) G__int(libp->para[0]);
9333 p = new TDigiEvent(*(TDigiEvent*) tmp);
9334 result7->obj.i = (long) p;
9335 result7->ref = (long) p;
9336 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
9337 return(1 || funcname || hash || result7 || libp) ;
9338}
9339
9340// automatic destructor
9341typedef TDigiEvent G__TTDigiEvent;
9342static int G__RootEventData_rootcint_206_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9343{
9344 char* gvp = (char*) G__getgvp();
9345 long soff = G__getstructoffset();
9346 int n = G__getaryconstruct();
9347 //
9348 //has_a_delete: 1
9349 //has_own_delete1arg: 0
9350 //has_own_delete2arg: 0
9351 //
9352 if (!soff) {
9353 return(1);
9354 }
9355 if (n) {
9356 if (gvp == (char*)G__PVOID) {
9357 delete[] (TDigiEvent*) soff;
9358 } else {
9359 G__setgvp((long) G__PVOID);
9360 for (int i = n - 1; i >= 0; --i) {
9361 ((TDigiEvent*) (soff+(sizeof(TDigiEvent)*i)))->~G__TTDigiEvent();
9362 }
9363 G__setgvp((long)gvp);
9364 }
9365 } else {
9366 if (gvp == (char*)G__PVOID) {
9367 delete (TDigiEvent*) soff;
9368 } else {
9369 G__setgvp((long) G__PVOID);
9370 ((TDigiEvent*) (soff))->~G__TTDigiEvent();
9371 G__setgvp((long)gvp);
9372 }
9373 }
9374 G__setnull(result7);
9375 return(1 || funcname || hash || result7 || libp) ;
9376}
9377
9378// automatic assignment operator
9379static int G__RootEventData_rootcint_206_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9380{
9381 TDigiEvent* dest = (TDigiEvent*) G__getstructoffset();
9382 *dest = *(TDigiEvent*) libp->para[0].ref;
9383 const TDigiEvent& obj = *dest;
9384 result7->ref = (long) (&obj);
9385 result7->obj.i = (long) (&obj);
9386 return(1 || funcname || hash || result7 || libp) ;
9387}
9388
9389
9390/* TRecMdcTrack */
9391static int G__RootEventData_rootcint_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9392{
9393 TRecMdcTrack* p = NULL;
9394 char* gvp = (char*) G__getgvp();
9395 int n = G__getaryconstruct();
9396 if (n) {
9397 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9398 p = new TRecMdcTrack[n];
9399 } else {
9400 p = new((void*) gvp) TRecMdcTrack[n];
9401 }
9402 } else {
9403 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9404 p = new TRecMdcTrack;
9405 } else {
9406 p = new((void*) gvp) TRecMdcTrack;
9407 }
9408 }
9409 result7->obj.i = (long) p;
9410 result7->ref = (long) p;
9411 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
9412 return(1 || funcname || hash || result7 || libp) ;
9413}
9414
9415static int G__RootEventData_rootcint_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9416{
9417 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->trackId());
9418 return(1 || funcname || hash || result7 || libp) ;
9419}
9420
9421static int G__RootEventData_rootcint_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9422{
9423 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->helix((Int_t) G__int(libp->para[0])));
9424 return(1 || funcname || hash || result7 || libp) ;
9425}
9426
9427static int G__RootEventData_rootcint_207_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9428{
9429 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->charge());
9430 return(1 || funcname || hash || result7 || libp) ;
9431}
9432
9433static int G__RootEventData_rootcint_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9434{
9435 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->pxy());
9436 return(1 || funcname || hash || result7 || libp) ;
9437}
9438
9439static int G__RootEventData_rootcint_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9440{
9441 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->px());
9442 return(1 || funcname || hash || result7 || libp) ;
9443}
9444
9445static int G__RootEventData_rootcint_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9446{
9447 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->py());
9448 return(1 || funcname || hash || result7 || libp) ;
9449}
9450
9451static int G__RootEventData_rootcint_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9452{
9453 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->pz());
9454 return(1 || funcname || hash || result7 || libp) ;
9455}
9456
9457static int G__RootEventData_rootcint_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9458{
9459 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->p());
9460 return(1 || funcname || hash || result7 || libp) ;
9461}
9462
9463static int G__RootEventData_rootcint_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9464{
9465 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->theta());
9466 return(1 || funcname || hash || result7 || libp) ;
9467}
9468
9469static int G__RootEventData_rootcint_207_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9470{
9471 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->phi());
9472 return(1 || funcname || hash || result7 || libp) ;
9473}
9474
9475static int G__RootEventData_rootcint_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9476{
9477 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->x());
9478 return(1 || funcname || hash || result7 || libp) ;
9479}
9480
9481static int G__RootEventData_rootcint_207_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9482{
9483 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->y());
9484 return(1 || funcname || hash || result7 || libp) ;
9485}
9486
9487static int G__RootEventData_rootcint_207_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9488{
9489 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->z());
9490 return(1 || funcname || hash || result7 || libp) ;
9491}
9492
9493static int G__RootEventData_rootcint_207_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9494{
9495 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->r());
9496 return(1 || funcname || hash || result7 || libp) ;
9497}
9498
9499static int G__RootEventData_rootcint_207_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9500{
9501 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->stat());
9502 return(1 || funcname || hash || result7 || libp) ;
9503}
9504
9505static int G__RootEventData_rootcint_207_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9506{
9507 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->chi2());
9508 return(1 || funcname || hash || result7 || libp) ;
9509}
9510
9511static int G__RootEventData_rootcint_207_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9512{
9513 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->ndof());
9514 return(1 || funcname || hash || result7 || libp) ;
9515}
9516
9517static int G__RootEventData_rootcint_207_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9518{
9519 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
9520 return(1 || funcname || hash || result7 || libp) ;
9521}
9522
9523static int G__RootEventData_rootcint_207_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9524{
9525 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->nhits());
9526 return(1 || funcname || hash || result7 || libp) ;
9527}
9528
9529static int G__RootEventData_rootcint_207_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9530{
9531 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->nster());
9532 return(1 || funcname || hash || result7 || libp) ;
9533}
9534
9535static int G__RootEventData_rootcint_207_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9536{
9537 G__letint(result7, 105, (long) ((const TRecMdcTrack*) G__getstructoffset())->nlayer());
9538 return(1 || funcname || hash || result7 || libp) ;
9539}
9540
9541static int G__RootEventData_rootcint_207_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9542{
9543 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vx0());
9544 return(1 || funcname || hash || result7 || libp) ;
9545}
9546
9547static int G__RootEventData_rootcint_207_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9548{
9549 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vy0());
9550 return(1 || funcname || hash || result7 || libp) ;
9551}
9552
9553static int G__RootEventData_rootcint_207_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9554{
9555 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vz0());
9556 return(1 || funcname || hash || result7 || libp) ;
9557}
9558
9559static int G__RootEventData_rootcint_207_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9560{
9561 G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->fiTerm());
9562 return(1 || funcname || hash || result7 || libp) ;
9563}
9564
9565static int G__RootEventData_rootcint_207_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9566{
9567 ((TRecMdcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
9568 G__setnull(result7);
9569 return(1 || funcname || hash || result7 || libp) ;
9570}
9571
9572static int G__RootEventData_rootcint_207_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9573{
9574 ((TRecMdcTrack*) G__getstructoffset())->setHelix((Double_t*) G__int(libp->para[0]));
9575 G__setnull(result7);
9576 return(1 || funcname || hash || result7 || libp) ;
9577}
9578
9579static int G__RootEventData_rootcint_207_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9580{
9581 ((TRecMdcTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]));
9582 G__setnull(result7);
9583 return(1 || funcname || hash || result7 || libp) ;
9584}
9585
9586static int G__RootEventData_rootcint_207_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9587{
9588 ((TRecMdcTrack*) G__getstructoffset())->setChi2((const Double_t) G__double(libp->para[0]));
9589 G__setnull(result7);
9590 return(1 || funcname || hash || result7 || libp) ;
9591}
9592
9593static int G__RootEventData_rootcint_207_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9594{
9595 ((TRecMdcTrack*) G__getstructoffset())->setNdof((const Int_t) G__int(libp->para[0]));
9596 G__setnull(result7);
9597 return(1 || funcname || hash || result7 || libp) ;
9598}
9599
9600static int G__RootEventData_rootcint_207_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9601{
9602 ((TRecMdcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
9603 G__setnull(result7);
9604 return(1 || funcname || hash || result7 || libp) ;
9605}
9606
9607static int G__RootEventData_rootcint_207_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9608{
9609 ((TRecMdcTrack*) G__getstructoffset())->setNhits((const Int_t) G__int(libp->para[0]));
9610 G__setnull(result7);
9611 return(1 || funcname || hash || result7 || libp) ;
9612}
9613
9614static int G__RootEventData_rootcint_207_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9615{
9616 ((TRecMdcTrack*) G__getstructoffset())->setNster((const Int_t) G__int(libp->para[0]));
9617 G__setnull(result7);
9618 return(1 || funcname || hash || result7 || libp) ;
9619}
9620
9621static int G__RootEventData_rootcint_207_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9622{
9623 ((TRecMdcTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]));
9624 G__setnull(result7);
9625 return(1 || funcname || hash || result7 || libp) ;
9626}
9627
9628static int G__RootEventData_rootcint_207_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9629{
9630 ((TRecMdcTrack*) G__getstructoffset())->setVX0((Double_t) G__double(libp->para[0]));
9631 G__setnull(result7);
9632 return(1 || funcname || hash || result7 || libp) ;
9633}
9634
9635static int G__RootEventData_rootcint_207_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9636{
9637 ((TRecMdcTrack*) G__getstructoffset())->setVY0((Double_t) G__double(libp->para[0]));
9638 G__setnull(result7);
9639 return(1 || funcname || hash || result7 || libp) ;
9640}
9641
9642static int G__RootEventData_rootcint_207_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9643{
9644 ((TRecMdcTrack*) G__getstructoffset())->setVZ0((Double_t) G__double(libp->para[0]));
9645 G__setnull(result7);
9646 return(1 || funcname || hash || result7 || libp) ;
9647}
9648
9649static int G__RootEventData_rootcint_207_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9650{
9651 ((TRecMdcTrack*) G__getstructoffset())->setFiTerm((Double_t) G__double(libp->para[0]));
9652 G__setnull(result7);
9653 return(1 || funcname || hash || result7 || libp) ;
9654}
9655
9656static int G__RootEventData_rootcint_207_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9657{
9658 ((TRecMdcTrack*) G__getstructoffset())->setTRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
9659 G__setnull(result7);
9660 return(1 || funcname || hash || result7 || libp) ;
9661}
9662
9663static int G__RootEventData_rootcint_207_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9664{
9665 G__letint(result7, 85, (long) TRecMdcTrack::Class());
9666 return(1 || funcname || hash || result7 || libp) ;
9667}
9668
9669static int G__RootEventData_rootcint_207_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9670{
9671 G__letint(result7, 67, (long) TRecMdcTrack::Class_Name());
9672 return(1 || funcname || hash || result7 || libp) ;
9673}
9674
9675static int G__RootEventData_rootcint_207_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9676{
9677 G__letint(result7, 115, (long) TRecMdcTrack::Class_Version());
9678 return(1 || funcname || hash || result7 || libp) ;
9679}
9680
9681static int G__RootEventData_rootcint_207_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9682{
9683 TRecMdcTrack::Dictionary();
9684 G__setnull(result7);
9685 return(1 || funcname || hash || result7 || libp) ;
9686}
9687
9688static int G__RootEventData_rootcint_207_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9689{
9690 ((TRecMdcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
9691 G__setnull(result7);
9692 return(1 || funcname || hash || result7 || libp) ;
9693}
9694
9695static int G__RootEventData_rootcint_207_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9696{
9697 G__letint(result7, 67, (long) TRecMdcTrack::DeclFileName());
9698 return(1 || funcname || hash || result7 || libp) ;
9699}
9700
9701static int G__RootEventData_rootcint_207_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9702{
9703 G__letint(result7, 105, (long) TRecMdcTrack::ImplFileLine());
9704 return(1 || funcname || hash || result7 || libp) ;
9705}
9706
9707static int G__RootEventData_rootcint_207_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9708{
9709 G__letint(result7, 67, (long) TRecMdcTrack::ImplFileName());
9710 return(1 || funcname || hash || result7 || libp) ;
9711}
9712
9713static int G__RootEventData_rootcint_207_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9714{
9715 G__letint(result7, 105, (long) TRecMdcTrack::DeclFileLine());
9716 return(1 || funcname || hash || result7 || libp) ;
9717}
9718
9719// automatic copy constructor
9720static int G__RootEventData_rootcint_207_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9721
9722{
9723 TRecMdcTrack* p;
9724 void* tmp = (void*) G__int(libp->para[0]);
9725 p = new TRecMdcTrack(*(TRecMdcTrack*) tmp);
9726 result7->obj.i = (long) p;
9727 result7->ref = (long) p;
9728 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
9729 return(1 || funcname || hash || result7 || libp) ;
9730}
9731
9732// automatic destructor
9733typedef TRecMdcTrack G__TTRecMdcTrack;
9734static int G__RootEventData_rootcint_207_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9735{
9736 char* gvp = (char*) G__getgvp();
9737 long soff = G__getstructoffset();
9738 int n = G__getaryconstruct();
9739 //
9740 //has_a_delete: 1
9741 //has_own_delete1arg: 0
9742 //has_own_delete2arg: 0
9743 //
9744 if (!soff) {
9745 return(1);
9746 }
9747 if (n) {
9748 if (gvp == (char*)G__PVOID) {
9749 delete[] (TRecMdcTrack*) soff;
9750 } else {
9751 G__setgvp((long) G__PVOID);
9752 for (int i = n - 1; i >= 0; --i) {
9753 ((TRecMdcTrack*) (soff+(sizeof(TRecMdcTrack)*i)))->~G__TTRecMdcTrack();
9754 }
9755 G__setgvp((long)gvp);
9756 }
9757 } else {
9758 if (gvp == (char*)G__PVOID) {
9759 delete (TRecMdcTrack*) soff;
9760 } else {
9761 G__setgvp((long) G__PVOID);
9762 ((TRecMdcTrack*) (soff))->~G__TTRecMdcTrack();
9763 G__setgvp((long)gvp);
9764 }
9765 }
9766 G__setnull(result7);
9767 return(1 || funcname || hash || result7 || libp) ;
9768}
9769
9770// automatic assignment operator
9771static int G__RootEventData_rootcint_207_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9772{
9773 TRecMdcTrack* dest = (TRecMdcTrack*) G__getstructoffset();
9774 *dest = *(TRecMdcTrack*) libp->para[0].ref;
9775 const TRecMdcTrack& obj = *dest;
9776 result7->ref = (long) (&obj);
9777 result7->obj.i = (long) (&obj);
9778 return(1 || funcname || hash || result7 || libp) ;
9779}
9780
9781
9782/* TRecMdcKalTrack */
9783static int G__RootEventData_rootcint_208_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9784{
9785 TRecMdcKalTrack* p = NULL;
9786 char* gvp = (char*) G__getgvp();
9787 int n = G__getaryconstruct();
9788 if (n) {
9789 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9790 p = new TRecMdcKalTrack[n];
9791 } else {
9792 p = new((void*) gvp) TRecMdcKalTrack[n];
9793 }
9794 } else {
9795 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
9796 p = new TRecMdcKalTrack;
9797 } else {
9798 p = new((void*) gvp) TRecMdcKalTrack;
9799 }
9800 }
9801 result7->obj.i = (long) p;
9802 result7->ref = (long) p;
9803 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
9804 return(1 || funcname || hash || result7 || libp) ;
9805}
9806
9807static int G__RootEventData_rootcint_208_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9808{
9809 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getTrackId());
9810 return(1 || funcname || hash || result7 || libp) ;
9811}
9812
9813static int G__RootEventData_rootcint_208_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9814{
9815 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getMass((Int_t) G__int(libp->para[0])));
9816 return(1 || funcname || hash || result7 || libp) ;
9817}
9818
9819static int G__RootEventData_rootcint_208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9820{
9821 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLength((Int_t) G__int(libp->para[0])));
9822 return(1 || funcname || hash || result7 || libp) ;
9823}
9824
9825static int G__RootEventData_rootcint_208_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9826{
9827 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTof((Int_t) G__int(libp->para[0])));
9828 return(1 || funcname || hash || result7 || libp) ;
9829}
9830
9831static int G__RootEventData_rootcint_208_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9832{
9833 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getfiTerm((Int_t) G__int(libp->para[0])));
9834 return(1 || funcname || hash || result7 || libp) ;
9835}
9836
9837static int G__RootEventData_rootcint_208_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9838{
9839 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPathSM((Int_t) G__int(libp->para[0])));
9840 return(1 || funcname || hash || result7 || libp) ;
9841}
9842
9843static int G__RootEventData_rootcint_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9844{
9845 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNhits((Int_t) G__int(libp->para[0])));
9846 return(1 || funcname || hash || result7 || libp) ;
9847}
9848
9849static int G__RootEventData_rootcint_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9850{
9851 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNlayer((Int_t) G__int(libp->para[0])));
9852 return(1 || funcname || hash || result7 || libp) ;
9853}
9854
9855static int G__RootEventData_rootcint_208_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9856{
9857 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getStat((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9858 return(1 || funcname || hash || result7 || libp) ;
9859}
9860
9861static int G__RootEventData_rootcint_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9862{
9863 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getChisq((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9864 return(1 || funcname || hash || result7 || libp) ;
9865}
9866
9867static int G__RootEventData_rootcint_208_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9868{
9869 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNdf((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9870 return(1 || funcname || hash || result7 || libp) ;
9871}
9872
9873static int G__RootEventData_rootcint_208_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9874{
9875 G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNseg((Int_t) G__int(libp->para[0])));
9876 return(1 || funcname || hash || result7 || libp) ;
9877}
9878
9879static int G__RootEventData_rootcint_208_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9880{
9881 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelix((Int_t) G__int(libp->para[0])));
9882 return(1 || funcname || hash || result7 || libp) ;
9883}
9884
9885static int G__RootEventData_rootcint_208_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9886{
9887 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9888 return(1 || funcname || hash || result7 || libp) ;
9889}
9890
9891static int G__RootEventData_rootcint_208_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9892{
9893 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixE((Int_t) G__int(libp->para[0])));
9894 return(1 || funcname || hash || result7 || libp) ;
9895}
9896
9897static int G__RootEventData_rootcint_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9898{
9899 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9900 return(1 || funcname || hash || result7 || libp) ;
9901}
9902
9903static int G__RootEventData_rootcint_208_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9904{
9905 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixMu((Int_t) G__int(libp->para[0])));
9906 return(1 || funcname || hash || result7 || libp) ;
9907}
9908
9909static int G__RootEventData_rootcint_208_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9910{
9911 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9912 return(1 || funcname || hash || result7 || libp) ;
9913}
9914
9915static int G__RootEventData_rootcint_208_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9916{
9917 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixK((Int_t) G__int(libp->para[0])));
9918 return(1 || funcname || hash || result7 || libp) ;
9919}
9920
9921static int G__RootEventData_rootcint_208_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9922{
9923 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9924 return(1 || funcname || hash || result7 || libp) ;
9925}
9926
9927static int G__RootEventData_rootcint_208_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9928{
9929 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixP((Int_t) G__int(libp->para[0])));
9930 return(1 || funcname || hash || result7 || libp) ;
9931}
9932
9933static int G__RootEventData_rootcint_208_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9934{
9935 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9936 return(1 || funcname || hash || result7 || libp) ;
9937}
9938
9939static int G__RootEventData_rootcint_208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9940{
9941 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelix((Int_t) G__int(libp->para[0])));
9942 return(1 || funcname || hash || result7 || libp) ;
9943}
9944
9945static int G__RootEventData_rootcint_208_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9946{
9947 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9948 return(1 || funcname || hash || result7 || libp) ;
9949}
9950
9951static int G__RootEventData_rootcint_208_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9952{
9953 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixE((Int_t) G__int(libp->para[0])));
9954 return(1 || funcname || hash || result7 || libp) ;
9955}
9956
9957static int G__RootEventData_rootcint_208_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9958{
9959 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9960 return(1 || funcname || hash || result7 || libp) ;
9961}
9962
9963static int G__RootEventData_rootcint_208_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9964{
9965 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixMu((Int_t) G__int(libp->para[0])));
9966 return(1 || funcname || hash || result7 || libp) ;
9967}
9968
9969static int G__RootEventData_rootcint_208_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9970{
9971 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9972 return(1 || funcname || hash || result7 || libp) ;
9973}
9974
9975static int G__RootEventData_rootcint_208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9976{
9977 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixK((Int_t) G__int(libp->para[0])));
9978 return(1 || funcname || hash || result7 || libp) ;
9979}
9980
9981static int G__RootEventData_rootcint_208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9982{
9983 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9984 return(1 || funcname || hash || result7 || libp) ;
9985}
9986
9987static int G__RootEventData_rootcint_208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9988{
9989 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixP((Int_t) G__int(libp->para[0])));
9990 return(1 || funcname || hash || result7 || libp) ;
9991}
9992
9993static int G__RootEventData_rootcint_208_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
9994{
9995 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
9996 return(1 || funcname || hash || result7 || libp) ;
9997}
9998
9999static int G__RootEventData_rootcint_208_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10000{
10001 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelix((Int_t) G__int(libp->para[0])));
10002 return(1 || funcname || hash || result7 || libp) ;
10003}
10004
10005static int G__RootEventData_rootcint_208_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10006{
10007 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10008 return(1 || funcname || hash || result7 || libp) ;
10009}
10010
10011static int G__RootEventData_rootcint_208_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10012{
10013 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixE((Int_t) G__int(libp->para[0])));
10014 return(1 || funcname || hash || result7 || libp) ;
10015}
10016
10017static int G__RootEventData_rootcint_208_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10018{
10019 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10020 return(1 || funcname || hash || result7 || libp) ;
10021}
10022
10023static int G__RootEventData_rootcint_208_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10024{
10025 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixMu((Int_t) G__int(libp->para[0])));
10026 return(1 || funcname || hash || result7 || libp) ;
10027}
10028
10029static int G__RootEventData_rootcint_208_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10030{
10031 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10032 return(1 || funcname || hash || result7 || libp) ;
10033}
10034
10035static int G__RootEventData_rootcint_208_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10036{
10037 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixK((Int_t) G__int(libp->para[0])));
10038 return(1 || funcname || hash || result7 || libp) ;
10039}
10040
10041static int G__RootEventData_rootcint_208_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10042{
10043 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10044 return(1 || funcname || hash || result7 || libp) ;
10045}
10046
10047static int G__RootEventData_rootcint_208_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10048{
10049 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixP((Int_t) G__int(libp->para[0])));
10050 return(1 || funcname || hash || result7 || libp) ;
10051}
10052
10053static int G__RootEventData_rootcint_208_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10054{
10055 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10056 return(1 || funcname || hash || result7 || libp) ;
10057}
10058
10059static int G__RootEventData_rootcint_208_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10060{
10061 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTHelix((Int_t) G__int(libp->para[0])));
10062 return(1 || funcname || hash || result7 || libp) ;
10063}
10064
10065static int G__RootEventData_rootcint_208_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10066{
10067 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTError((Int_t) G__int(libp->para[0])));
10068 return(1 || funcname || hash || result7 || libp) ;
10069}
10070
10071static int G__RootEventData_rootcint_208_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10072{
10073 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaE((Int_t) G__int(libp->para[0])));
10074 return(1 || funcname || hash || result7 || libp) ;
10075}
10076
10077static int G__RootEventData_rootcint_208_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10078{
10079 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaMu((Int_t) G__int(libp->para[0])));
10080 return(1 || funcname || hash || result7 || libp) ;
10081}
10082
10083static int G__RootEventData_rootcint_208_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10084{
10085 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPoca((Int_t) G__int(libp->para[0])));
10086 return(1 || funcname || hash || result7 || libp) ;
10087}
10088
10089static int G__RootEventData_rootcint_208_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10090{
10091 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaK((Int_t) G__int(libp->para[0])));
10092 return(1 || funcname || hash || result7 || libp) ;
10093}
10094
10095static int G__RootEventData_rootcint_208_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10096{
10097 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaP((Int_t) G__int(libp->para[0])));
10098 return(1 || funcname || hash || result7 || libp) ;
10099}
10100
10101static int G__RootEventData_rootcint_208_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10102{
10103 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointE((Int_t) G__int(libp->para[0])));
10104 return(1 || funcname || hash || result7 || libp) ;
10105}
10106
10107static int G__RootEventData_rootcint_208_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10108{
10109 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointMu((Int_t) G__int(libp->para[0])));
10110 return(1 || funcname || hash || result7 || libp) ;
10111}
10112
10113static int G__RootEventData_rootcint_208_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10114{
10115 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPoint((Int_t) G__int(libp->para[0])));
10116 return(1 || funcname || hash || result7 || libp) ;
10117}
10118
10119static int G__RootEventData_rootcint_208_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10120{
10121 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointK((Int_t) G__int(libp->para[0])));
10122 return(1 || funcname || hash || result7 || libp) ;
10123}
10124
10125static int G__RootEventData_rootcint_208_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10126{
10127 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointP((Int_t) G__int(libp->para[0])));
10128 return(1 || funcname || hash || result7 || libp) ;
10129}
10130
10131static int G__RootEventData_rootcint_208_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10132{
10133 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotE((Int_t) G__int(libp->para[0])));
10134 return(1 || funcname || hash || result7 || libp) ;
10135}
10136
10137static int G__RootEventData_rootcint_208_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10138{
10139 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotMu((Int_t) G__int(libp->para[0])));
10140 return(1 || funcname || hash || result7 || libp) ;
10141}
10142
10143static int G__RootEventData_rootcint_208_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10144{
10145 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivot((Int_t) G__int(libp->para[0])));
10146 return(1 || funcname || hash || result7 || libp) ;
10147}
10148
10149static int G__RootEventData_rootcint_208_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10150{
10151 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotK((Int_t) G__int(libp->para[0])));
10152 return(1 || funcname || hash || result7 || libp) ;
10153}
10154
10155static int G__RootEventData_rootcint_208_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10156{
10157 G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotP((Int_t) G__int(libp->para[0])));
10158 return(1 || funcname || hash || result7 || libp) ;
10159}
10160
10161static int G__RootEventData_rootcint_208_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10162{
10163 ((TRecMdcKalTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
10164 G__setnull(result7);
10165 return(1 || funcname || hash || result7 || libp) ;
10166}
10167
10168static int G__RootEventData_rootcint_208_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10169{
10170 ((TRecMdcKalTrack*) G__getstructoffset())->setMass((Double_t*) G__int(libp->para[0]));
10171 G__setnull(result7);
10172 return(1 || funcname || hash || result7 || libp) ;
10173}
10174
10175static int G__RootEventData_rootcint_208_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10176{
10177 ((TRecMdcKalTrack*) G__getstructoffset())->setLength((Double_t*) G__int(libp->para[0]));
10178 G__setnull(result7);
10179 return(1 || funcname || hash || result7 || libp) ;
10180}
10181
10182static int G__RootEventData_rootcint_208_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10183{
10184 ((TRecMdcKalTrack*) G__getstructoffset())->setFiTerm((Double_t*) G__int(libp->para[0]));
10185 G__setnull(result7);
10186 return(1 || funcname || hash || result7 || libp) ;
10187}
10188
10189static int G__RootEventData_rootcint_208_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10190{
10191 ((TRecMdcKalTrack*) G__getstructoffset())->setPathSM((Double_t*) G__int(libp->para[0]));
10192 G__setnull(result7);
10193 return(1 || funcname || hash || result7 || libp) ;
10194}
10195
10196static int G__RootEventData_rootcint_208_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10197{
10198 ((TRecMdcKalTrack*) G__getstructoffset())->setTof((Double_t*) G__int(libp->para[0]));
10199 G__setnull(result7);
10200 return(1 || funcname || hash || result7 || libp) ;
10201}
10202
10203static int G__RootEventData_rootcint_208_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10204{
10205 ((TRecMdcKalTrack*) G__getstructoffset())->setNhits((const Int_t*) G__int(libp->para[0]));
10206 G__setnull(result7);
10207 return(1 || funcname || hash || result7 || libp) ;
10208}
10209
10210static int G__RootEventData_rootcint_208_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10211{
10212 ((TRecMdcKalTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10213, (Int_t) G__int(libp->para[2]));
10214 G__setnull(result7);
10215 return(1 || funcname || hash || result7 || libp) ;
10216}
10217
10218static int G__RootEventData_rootcint_208_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10219{
10220 ((TRecMdcKalTrack*) G__getstructoffset())->setChisq((const Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
10221, (Int_t) G__int(libp->para[2]));
10222 G__setnull(result7);
10223 return(1 || funcname || hash || result7 || libp) ;
10224}
10225
10226static int G__RootEventData_rootcint_208_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10227{
10228 ((TRecMdcKalTrack*) G__getstructoffset())->setNdf((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10229, (Int_t) G__int(libp->para[2]));
10230 G__setnull(result7);
10231 return(1 || funcname || hash || result7 || libp) ;
10232}
10233
10234static int G__RootEventData_rootcint_208_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10235{
10236 ((TRecMdcKalTrack*) G__getstructoffset())->setNseg((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10237 G__setnull(result7);
10238 return(1 || funcname || hash || result7 || libp) ;
10239}
10240
10241static int G__RootEventData_rootcint_208_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10242{
10243 ((TRecMdcKalTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10244 G__setnull(result7);
10245 return(1 || funcname || hash || result7 || libp) ;
10246}
10247
10248static int G__RootEventData_rootcint_208_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10249{
10250 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelix((Double_t*) G__int(libp->para[0]));
10251 G__setnull(result7);
10252 return(1 || funcname || hash || result7 || libp) ;
10253}
10254
10255static int G__RootEventData_rootcint_208_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10256{
10257 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10258 ((TRecMdcKalTrack*) G__getstructoffset())->setZError(G__Ap0->a);
10259 G__setnull(result7);
10260 return(1 || funcname || hash || result7 || libp) ;
10261}
10262
10263static int G__RootEventData_rootcint_208_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10264{
10265 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixE((Double_t*) G__int(libp->para[0]));
10266 G__setnull(result7);
10267 return(1 || funcname || hash || result7 || libp) ;
10268}
10269
10270static int G__RootEventData_rootcint_208_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10271{
10272 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10273 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorE(G__Ap0->a);
10274 G__setnull(result7);
10275 return(1 || funcname || hash || result7 || libp) ;
10276}
10277
10278static int G__RootEventData_rootcint_208_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10279{
10280 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixMu((Double_t*) G__int(libp->para[0]));
10281 G__setnull(result7);
10282 return(1 || funcname || hash || result7 || libp) ;
10283}
10284
10285static int G__RootEventData_rootcint_208_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10286{
10287 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10288 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorMu(G__Ap0->a);
10289 G__setnull(result7);
10290 return(1 || funcname || hash || result7 || libp) ;
10291}
10292
10293static int G__RootEventData_rootcint_208_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10294{
10295 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixK((Double_t*) G__int(libp->para[0]));
10296 G__setnull(result7);
10297 return(1 || funcname || hash || result7 || libp) ;
10298}
10299
10300static int G__RootEventData_rootcint_208_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10301{
10302 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10303 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorK(G__Ap0->a);
10304 G__setnull(result7);
10305 return(1 || funcname || hash || result7 || libp) ;
10306}
10307
10308static int G__RootEventData_rootcint_208_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10309{
10310 ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixP((Double_t*) G__int(libp->para[0]));
10311 G__setnull(result7);
10312 return(1 || funcname || hash || result7 || libp) ;
10313}
10314
10315static int G__RootEventData_rootcint_208_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10316{
10317 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10318 ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorP(G__Ap0->a);
10319 G__setnull(result7);
10320 return(1 || funcname || hash || result7 || libp) ;
10321}
10322
10323static int G__RootEventData_rootcint_208_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10324{
10325 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelix((Double_t*) G__int(libp->para[0]));
10326 G__setnull(result7);
10327 return(1 || funcname || hash || result7 || libp) ;
10328}
10329
10330static int G__RootEventData_rootcint_208_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10331{
10332 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10333 ((TRecMdcKalTrack*) G__getstructoffset())->setFError(G__Ap0->a);
10334 G__setnull(result7);
10335 return(1 || funcname || hash || result7 || libp) ;
10336}
10337
10338static int G__RootEventData_rootcint_208_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10339{
10340 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixE((Double_t*) G__int(libp->para[0]));
10341 G__setnull(result7);
10342 return(1 || funcname || hash || result7 || libp) ;
10343}
10344
10345static int G__RootEventData_rootcint_208_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10346{
10347 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10348 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorE(G__Ap0->a);
10349 G__setnull(result7);
10350 return(1 || funcname || hash || result7 || libp) ;
10351}
10352
10353static int G__RootEventData_rootcint_208_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10354{
10355 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixMu((Double_t*) G__int(libp->para[0]));
10356 G__setnull(result7);
10357 return(1 || funcname || hash || result7 || libp) ;
10358}
10359
10360static int G__RootEventData_rootcint_208_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10361{
10362 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10363 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorMu(G__Ap0->a);
10364 G__setnull(result7);
10365 return(1 || funcname || hash || result7 || libp) ;
10366}
10367
10368static int G__RootEventData_rootcint_208_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10369{
10370 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixK((Double_t*) G__int(libp->para[0]));
10371 G__setnull(result7);
10372 return(1 || funcname || hash || result7 || libp) ;
10373}
10374
10375static int G__RootEventData_rootcint_208_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10376{
10377 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10378 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorK(G__Ap0->a);
10379 G__setnull(result7);
10380 return(1 || funcname || hash || result7 || libp) ;
10381}
10382
10383static int G__RootEventData_rootcint_208_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10384{
10385 ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixP((Double_t*) G__int(libp->para[0]));
10386 G__setnull(result7);
10387 return(1 || funcname || hash || result7 || libp) ;
10388}
10389
10390static int G__RootEventData_rootcint_208_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10391{
10392 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10393 ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorP(G__Ap0->a);
10394 G__setnull(result7);
10395 return(1 || funcname || hash || result7 || libp) ;
10396}
10397
10398static int G__RootEventData_rootcint_208_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10399{
10400 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelix((Double_t*) G__int(libp->para[0]));
10401 G__setnull(result7);
10402 return(1 || funcname || hash || result7 || libp) ;
10403}
10404
10405static int G__RootEventData_rootcint_208_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10406{
10407 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10408 ((TRecMdcKalTrack*) G__getstructoffset())->setLError(G__Ap0->a);
10409 G__setnull(result7);
10410 return(1 || funcname || hash || result7 || libp) ;
10411}
10412
10413static int G__RootEventData_rootcint_208_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10414{
10415 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixE((Double_t*) G__int(libp->para[0]));
10416 G__setnull(result7);
10417 return(1 || funcname || hash || result7 || libp) ;
10418}
10419
10420static int G__RootEventData_rootcint_208_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10421{
10422 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10423 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorE(G__Ap0->a);
10424 G__setnull(result7);
10425 return(1 || funcname || hash || result7 || libp) ;
10426}
10427
10428static int G__RootEventData_rootcint_208_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10429{
10430 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixMu((Double_t*) G__int(libp->para[0]));
10431 G__setnull(result7);
10432 return(1 || funcname || hash || result7 || libp) ;
10433}
10434
10435static int G__RootEventData_rootcint_208_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10436{
10437 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10438 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorMu(G__Ap0->a);
10439 G__setnull(result7);
10440 return(1 || funcname || hash || result7 || libp) ;
10441}
10442
10443static int G__RootEventData_rootcint_208_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10444{
10445 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixK((Double_t*) G__int(libp->para[0]));
10446 G__setnull(result7);
10447 return(1 || funcname || hash || result7 || libp) ;
10448}
10449
10450static int G__RootEventData_rootcint_208_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10451{
10452 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10453 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorK(G__Ap0->a);
10454 G__setnull(result7);
10455 return(1 || funcname || hash || result7 || libp) ;
10456}
10457
10458static int G__RootEventData_rootcint_208_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10459{
10460 ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixP((Double_t*) G__int(libp->para[0]));
10461 G__setnull(result7);
10462 return(1 || funcname || hash || result7 || libp) ;
10463}
10464
10465static int G__RootEventData_rootcint_208_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10466{
10467 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
10468 ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorP(G__Ap0->a);
10469 G__setnull(result7);
10470 return(1 || funcname || hash || result7 || libp) ;
10471}
10472
10473static int G__RootEventData_rootcint_208_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10474{
10475 ((TRecMdcKalTrack*) G__getstructoffset())->setTHelix((Double_t*) G__int(libp->para[0]));
10476 G__setnull(result7);
10477 return(1 || funcname || hash || result7 || libp) ;
10478}
10479
10480static int G__RootEventData_rootcint_208_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10481{
10482 ((TRecMdcKalTrack*) G__getstructoffset())->setTError((Double_t*) G__int(libp->para[0]));
10483 G__setnull(result7);
10484 return(1 || funcname || hash || result7 || libp) ;
10485}
10486
10487static int G__RootEventData_rootcint_208_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10488{
10489 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaE((Double_t*) G__int(libp->para[0]));
10490 G__setnull(result7);
10491 return(1 || funcname || hash || result7 || libp) ;
10492}
10493
10494static int G__RootEventData_rootcint_208_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10495{
10496 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaMu((Double_t*) G__int(libp->para[0]));
10497 G__setnull(result7);
10498 return(1 || funcname || hash || result7 || libp) ;
10499}
10500
10501static int G__RootEventData_rootcint_208_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10502{
10503 ((TRecMdcKalTrack*) G__getstructoffset())->setPoca((Double_t*) G__int(libp->para[0]));
10504 G__setnull(result7);
10505 return(1 || funcname || hash || result7 || libp) ;
10506}
10507
10508static int G__RootEventData_rootcint_208_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10509{
10510 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaK((Double_t*) G__int(libp->para[0]));
10511 G__setnull(result7);
10512 return(1 || funcname || hash || result7 || libp) ;
10513}
10514
10515static int G__RootEventData_rootcint_208_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10516{
10517 ((TRecMdcKalTrack*) G__getstructoffset())->setPocaP((Double_t*) G__int(libp->para[0]));
10518 G__setnull(result7);
10519 return(1 || funcname || hash || result7 || libp) ;
10520}
10521
10522static int G__RootEventData_rootcint_208_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10523{
10524 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointE((Double_t*) G__int(libp->para[0]));
10525 G__setnull(result7);
10526 return(1 || funcname || hash || result7 || libp) ;
10527}
10528
10529static int G__RootEventData_rootcint_208_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10530{
10531 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointMu((Double_t*) G__int(libp->para[0]));
10532 G__setnull(result7);
10533 return(1 || funcname || hash || result7 || libp) ;
10534}
10535
10536static int G__RootEventData_rootcint_208_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10537{
10538 ((TRecMdcKalTrack*) G__getstructoffset())->setLPoint((Double_t*) G__int(libp->para[0]));
10539 G__setnull(result7);
10540 return(1 || funcname || hash || result7 || libp) ;
10541}
10542
10543static int G__RootEventData_rootcint_208_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10544{
10545 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointK((Double_t*) G__int(libp->para[0]));
10546 G__setnull(result7);
10547 return(1 || funcname || hash || result7 || libp) ;
10548}
10549
10550static int G__RootEventData_rootcint_208_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10551{
10552 ((TRecMdcKalTrack*) G__getstructoffset())->setLPointP((Double_t*) G__int(libp->para[0]));
10553 G__setnull(result7);
10554 return(1 || funcname || hash || result7 || libp) ;
10555}
10556
10557static int G__RootEventData_rootcint_208_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10558{
10559 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotE((Double_t*) G__int(libp->para[0]));
10560 G__setnull(result7);
10561 return(1 || funcname || hash || result7 || libp) ;
10562}
10563
10564static int G__RootEventData_rootcint_208_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10565{
10566 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotMu((Double_t*) G__int(libp->para[0]));
10567 G__setnull(result7);
10568 return(1 || funcname || hash || result7 || libp) ;
10569}
10570
10571static int G__RootEventData_rootcint_208_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10572{
10573 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivot((Double_t*) G__int(libp->para[0]));
10574 G__setnull(result7);
10575 return(1 || funcname || hash || result7 || libp) ;
10576}
10577
10578static int G__RootEventData_rootcint_208_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10579{
10580 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotK((Double_t*) G__int(libp->para[0]));
10581 G__setnull(result7);
10582 return(1 || funcname || hash || result7 || libp) ;
10583}
10584
10585static int G__RootEventData_rootcint_208_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10586{
10587 ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotP((Double_t*) G__int(libp->para[0]));
10588 G__setnull(result7);
10589 return(1 || funcname || hash || result7 || libp) ;
10590}
10591
10592static int G__RootEventData_rootcint_208_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10593{
10594 G__letint(result7, 85, (long) TRecMdcKalTrack::Class());
10595 return(1 || funcname || hash || result7 || libp) ;
10596}
10597
10598static int G__RootEventData_rootcint_208_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10599{
10600 G__letint(result7, 67, (long) TRecMdcKalTrack::Class_Name());
10601 return(1 || funcname || hash || result7 || libp) ;
10602}
10603
10604static int G__RootEventData_rootcint_208_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10605{
10606 G__letint(result7, 115, (long) TRecMdcKalTrack::Class_Version());
10607 return(1 || funcname || hash || result7 || libp) ;
10608}
10609
10610static int G__RootEventData_rootcint_208_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10611{
10612 TRecMdcKalTrack::Dictionary();
10613 G__setnull(result7);
10614 return(1 || funcname || hash || result7 || libp) ;
10615}
10616
10617static int G__RootEventData_rootcint_208_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10618{
10619 ((TRecMdcKalTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10620 G__setnull(result7);
10621 return(1 || funcname || hash || result7 || libp) ;
10622}
10623
10624static int G__RootEventData_rootcint_208_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10625{
10626 G__letint(result7, 67, (long) TRecMdcKalTrack::DeclFileName());
10627 return(1 || funcname || hash || result7 || libp) ;
10628}
10629
10630static int G__RootEventData_rootcint_208_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10631{
10632 G__letint(result7, 105, (long) TRecMdcKalTrack::ImplFileLine());
10633 return(1 || funcname || hash || result7 || libp) ;
10634}
10635
10636static int G__RootEventData_rootcint_208_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10637{
10638 G__letint(result7, 67, (long) TRecMdcKalTrack::ImplFileName());
10639 return(1 || funcname || hash || result7 || libp) ;
10640}
10641
10642static int G__RootEventData_rootcint_208_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10643{
10644 G__letint(result7, 105, (long) TRecMdcKalTrack::DeclFileLine());
10645 return(1 || funcname || hash || result7 || libp) ;
10646}
10647
10648// automatic copy constructor
10649static int G__RootEventData_rootcint_208_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10650
10651{
10652 TRecMdcKalTrack* p;
10653 void* tmp = (void*) G__int(libp->para[0]);
10654 p = new TRecMdcKalTrack(*(TRecMdcKalTrack*) tmp);
10655 result7->obj.i = (long) p;
10656 result7->ref = (long) p;
10657 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
10658 return(1 || funcname || hash || result7 || libp) ;
10659}
10660
10661// automatic destructor
10662typedef TRecMdcKalTrack G__TTRecMdcKalTrack;
10663static int G__RootEventData_rootcint_208_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10664{
10665 char* gvp = (char*) G__getgvp();
10666 long soff = G__getstructoffset();
10667 int n = G__getaryconstruct();
10668 //
10669 //has_a_delete: 1
10670 //has_own_delete1arg: 0
10671 //has_own_delete2arg: 0
10672 //
10673 if (!soff) {
10674 return(1);
10675 }
10676 if (n) {
10677 if (gvp == (char*)G__PVOID) {
10678 delete[] (TRecMdcKalTrack*) soff;
10679 } else {
10680 G__setgvp((long) G__PVOID);
10681 for (int i = n - 1; i >= 0; --i) {
10682 ((TRecMdcKalTrack*) (soff+(sizeof(TRecMdcKalTrack)*i)))->~G__TTRecMdcKalTrack();
10683 }
10684 G__setgvp((long)gvp);
10685 }
10686 } else {
10687 if (gvp == (char*)G__PVOID) {
10688 delete (TRecMdcKalTrack*) soff;
10689 } else {
10690 G__setgvp((long) G__PVOID);
10691 ((TRecMdcKalTrack*) (soff))->~G__TTRecMdcKalTrack();
10692 G__setgvp((long)gvp);
10693 }
10694 }
10695 G__setnull(result7);
10696 return(1 || funcname || hash || result7 || libp) ;
10697}
10698
10699// automatic assignment operator
10700static int G__RootEventData_rootcint_208_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10701{
10702 TRecMdcKalTrack* dest = (TRecMdcKalTrack*) G__getstructoffset();
10703 *dest = *(TRecMdcKalTrack*) libp->para[0].ref;
10704 const TRecMdcKalTrack& obj = *dest;
10705 result7->ref = (long) (&obj);
10706 result7->obj.i = (long) (&obj);
10707 return(1 || funcname || hash || result7 || libp) ;
10708}
10709
10710
10711/* TRecMdcHit */
10712static int G__RootEventData_rootcint_209_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10713{
10714 TRecMdcHit* p = NULL;
10715 char* gvp = (char*) G__getgvp();
10716 int n = G__getaryconstruct();
10717 if (n) {
10718 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10719 p = new TRecMdcHit[n];
10720 } else {
10721 p = new((void*) gvp) TRecMdcHit[n];
10722 }
10723 } else {
10724 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10725 p = new TRecMdcHit;
10726 } else {
10727 p = new((void*) gvp) TRecMdcHit;
10728 }
10729 }
10730 result7->obj.i = (long) p;
10731 result7->ref = (long) p;
10732 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
10733 return(1 || funcname || hash || result7 || libp) ;
10734}
10735
10736static int G__RootEventData_rootcint_209_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10737{
10738 G__letint(result7, 103, (long) ((const TRecMdcHit*) G__getstructoffset())->isGrouped());
10739 return(1 || funcname || hash || result7 || libp) ;
10740}
10741
10742static int G__RootEventData_rootcint_209_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10743{
10744 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getId());
10745 return(1 || funcname || hash || result7 || libp) ;
10746}
10747
10748static int G__RootEventData_rootcint_209_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10749{
10750 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getTrkId());
10751 return(1 || funcname || hash || result7 || libp) ;
10752}
10753
10754static int G__RootEventData_rootcint_209_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10755{
10756 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftDistLeft());
10757 return(1 || funcname || hash || result7 || libp) ;
10758}
10759
10760static int G__RootEventData_rootcint_209_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10761{
10762 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftDistRight());
10763 return(1 || funcname || hash || result7 || libp) ;
10764}
10765
10766static int G__RootEventData_rootcint_209_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10767{
10768 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getErrDriftDistLeft());
10769 return(1 || funcname || hash || result7 || libp) ;
10770}
10771
10772static int G__RootEventData_rootcint_209_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10773{
10774 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getErrDriftDistRight());
10775 return(1 || funcname || hash || result7 || libp) ;
10776}
10777
10778static int G__RootEventData_rootcint_209_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10779{
10780 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getChisqAdd());
10781 return(1 || funcname || hash || result7 || libp) ;
10782}
10783
10784static int G__RootEventData_rootcint_209_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10785{
10786 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getFlagLR());
10787 return(1 || funcname || hash || result7 || libp) ;
10788}
10789
10790static int G__RootEventData_rootcint_209_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10791{
10792 G__letint(result7, 105, (long) ((const TRecMdcHit*) G__getstructoffset())->getStat());
10793 return(1 || funcname || hash || result7 || libp) ;
10794}
10795
10796static int G__RootEventData_rootcint_209_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10797{
10798 G__letint(result7, 104, (long) ((const TRecMdcHit*) G__getstructoffset())->getMdcId());
10799 return(1 || funcname || hash || result7 || libp) ;
10800}
10801
10802static int G__RootEventData_rootcint_209_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10803{
10804 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getTdc());
10805 return(1 || funcname || hash || result7 || libp) ;
10806}
10807
10808static int G__RootEventData_rootcint_209_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10809{
10810 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getAdc());
10811 return(1 || funcname || hash || result7 || libp) ;
10812}
10813
10814static int G__RootEventData_rootcint_209_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10815{
10816 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftT());
10817 return(1 || funcname || hash || result7 || libp) ;
10818}
10819
10820static int G__RootEventData_rootcint_209_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10821{
10822 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDoca());
10823 return(1 || funcname || hash || result7 || libp) ;
10824}
10825
10826static int G__RootEventData_rootcint_209_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10827{
10828 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getEntra());
10829 return(1 || funcname || hash || result7 || libp) ;
10830}
10831
10832static int G__RootEventData_rootcint_209_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10833{
10834 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getZhit());
10835 return(1 || funcname || hash || result7 || libp) ;
10836}
10837
10838static int G__RootEventData_rootcint_209_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10839{
10840 G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getFltLen());
10841 return(1 || funcname || hash || result7 || libp) ;
10842}
10843
10844static int G__RootEventData_rootcint_209_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10845{
10846 ((TRecMdcHit*) G__getstructoffset())->setIsGrouped((Bool_t) G__int(libp->para[0]));
10847 G__setnull(result7);
10848 return(1 || funcname || hash || result7 || libp) ;
10849}
10850
10851static int G__RootEventData_rootcint_209_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10852{
10853 ((TRecMdcHit*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
10854 G__setnull(result7);
10855 return(1 || funcname || hash || result7 || libp) ;
10856}
10857
10858static int G__RootEventData_rootcint_209_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10859{
10860 ((TRecMdcHit*) G__getstructoffset())->setTrkId((Int_t) G__int(libp->para[0]));
10861 G__setnull(result7);
10862 return(1 || funcname || hash || result7 || libp) ;
10863}
10864
10865static int G__RootEventData_rootcint_209_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10866{
10867 ((TRecMdcHit*) G__getstructoffset())->setDriftDistLeft((Double_t) G__double(libp->para[0]));
10868 G__setnull(result7);
10869 return(1 || funcname || hash || result7 || libp) ;
10870}
10871
10872static int G__RootEventData_rootcint_209_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10873{
10874 ((TRecMdcHit*) G__getstructoffset())->setDriftDistRight((Double_t) G__double(libp->para[0]));
10875 G__setnull(result7);
10876 return(1 || funcname || hash || result7 || libp) ;
10877}
10878
10879static int G__RootEventData_rootcint_209_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10880{
10881 ((TRecMdcHit*) G__getstructoffset())->setErrDriftDistLeft((Double_t) G__double(libp->para[0]));
10882 G__setnull(result7);
10883 return(1 || funcname || hash || result7 || libp) ;
10884}
10885
10886static int G__RootEventData_rootcint_209_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10887{
10888 ((TRecMdcHit*) G__getstructoffset())->setErrDriftDistRight((Double_t) G__double(libp->para[0]));
10889 G__setnull(result7);
10890 return(1 || funcname || hash || result7 || libp) ;
10891}
10892
10893static int G__RootEventData_rootcint_209_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10894{
10895 ((TRecMdcHit*) G__getstructoffset())->setChisqAdd((Double_t) G__double(libp->para[0]));
10896 G__setnull(result7);
10897 return(1 || funcname || hash || result7 || libp) ;
10898}
10899
10900static int G__RootEventData_rootcint_209_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10901{
10902 ((TRecMdcHit*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
10903 G__setnull(result7);
10904 return(1 || funcname || hash || result7 || libp) ;
10905}
10906
10907static int G__RootEventData_rootcint_209_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10908{
10909 ((TRecMdcHit*) G__getstructoffset())->setStat((Int_t) G__int(libp->para[0]));
10910 G__setnull(result7);
10911 return(1 || funcname || hash || result7 || libp) ;
10912}
10913
10914static int G__RootEventData_rootcint_209_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10915{
10916 ((TRecMdcHit*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
10917 G__setnull(result7);
10918 return(1 || funcname || hash || result7 || libp) ;
10919}
10920
10921static int G__RootEventData_rootcint_209_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10922{
10923 ((TRecMdcHit*) G__getstructoffset())->setTdc((Double_t) G__double(libp->para[0]));
10924 G__setnull(result7);
10925 return(1 || funcname || hash || result7 || libp) ;
10926}
10927
10928static int G__RootEventData_rootcint_209_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10929{
10930 ((TRecMdcHit*) G__getstructoffset())->setAdc((Double_t) G__double(libp->para[0]));
10931 G__setnull(result7);
10932 return(1 || funcname || hash || result7 || libp) ;
10933}
10934
10935static int G__RootEventData_rootcint_209_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10936{
10937 ((TRecMdcHit*) G__getstructoffset())->setDriftT((Double_t) G__double(libp->para[0]));
10938 G__setnull(result7);
10939 return(1 || funcname || hash || result7 || libp) ;
10940}
10941
10942static int G__RootEventData_rootcint_209_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10943{
10944 ((TRecMdcHit*) G__getstructoffset())->setDoca((Double_t) G__double(libp->para[0]));
10945 G__setnull(result7);
10946 return(1 || funcname || hash || result7 || libp) ;
10947}
10948
10949static int G__RootEventData_rootcint_209_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10950{
10951 ((TRecMdcHit*) G__getstructoffset())->setEntra((Double_t) G__double(libp->para[0]));
10952 G__setnull(result7);
10953 return(1 || funcname || hash || result7 || libp) ;
10954}
10955
10956static int G__RootEventData_rootcint_209_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10957{
10958 ((TRecMdcHit*) G__getstructoffset())->setZhit((Double_t) G__double(libp->para[0]));
10959 G__setnull(result7);
10960 return(1 || funcname || hash || result7 || libp) ;
10961}
10962
10963static int G__RootEventData_rootcint_209_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10964{
10965 ((TRecMdcHit*) G__getstructoffset())->setFltLen((Double_t) G__double(libp->para[0]));
10966 G__setnull(result7);
10967 return(1 || funcname || hash || result7 || libp) ;
10968}
10969
10970static int G__RootEventData_rootcint_209_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10971{
10972 ((TRecMdcHit*) G__getstructoffset())->setTRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
10973 G__setnull(result7);
10974 return(1 || funcname || hash || result7 || libp) ;
10975}
10976
10977static int G__RootEventData_rootcint_209_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10978{
10979 G__letint(result7, 85, (long) TRecMdcHit::Class());
10980 return(1 || funcname || hash || result7 || libp) ;
10981}
10982
10983static int G__RootEventData_rootcint_209_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10984{
10985 G__letint(result7, 67, (long) TRecMdcHit::Class_Name());
10986 return(1 || funcname || hash || result7 || libp) ;
10987}
10988
10989static int G__RootEventData_rootcint_209_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10990{
10991 G__letint(result7, 115, (long) TRecMdcHit::Class_Version());
10992 return(1 || funcname || hash || result7 || libp) ;
10993}
10994
10995static int G__RootEventData_rootcint_209_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10996{
10997 TRecMdcHit::Dictionary();
10998 G__setnull(result7);
10999 return(1 || funcname || hash || result7 || libp) ;
11000}
11001
11002static int G__RootEventData_rootcint_209_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11003{
11004 ((TRecMdcHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11005 G__setnull(result7);
11006 return(1 || funcname || hash || result7 || libp) ;
11007}
11008
11009static int G__RootEventData_rootcint_209_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11010{
11011 G__letint(result7, 67, (long) TRecMdcHit::DeclFileName());
11012 return(1 || funcname || hash || result7 || libp) ;
11013}
11014
11015static int G__RootEventData_rootcint_209_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11016{
11017 G__letint(result7, 105, (long) TRecMdcHit::ImplFileLine());
11018 return(1 || funcname || hash || result7 || libp) ;
11019}
11020
11021static int G__RootEventData_rootcint_209_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11022{
11023 G__letint(result7, 67, (long) TRecMdcHit::ImplFileName());
11024 return(1 || funcname || hash || result7 || libp) ;
11025}
11026
11027static int G__RootEventData_rootcint_209_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11028{
11029 G__letint(result7, 105, (long) TRecMdcHit::DeclFileLine());
11030 return(1 || funcname || hash || result7 || libp) ;
11031}
11032
11033// automatic copy constructor
11034static int G__RootEventData_rootcint_209_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11035
11036{
11037 TRecMdcHit* p;
11038 void* tmp = (void*) G__int(libp->para[0]);
11039 p = new TRecMdcHit(*(TRecMdcHit*) tmp);
11040 result7->obj.i = (long) p;
11041 result7->ref = (long) p;
11042 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
11043 return(1 || funcname || hash || result7 || libp) ;
11044}
11045
11046// automatic destructor
11047typedef TRecMdcHit G__TTRecMdcHit;
11048static int G__RootEventData_rootcint_209_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11049{
11050 char* gvp = (char*) G__getgvp();
11051 long soff = G__getstructoffset();
11052 int n = G__getaryconstruct();
11053 //
11054 //has_a_delete: 1
11055 //has_own_delete1arg: 0
11056 //has_own_delete2arg: 0
11057 //
11058 if (!soff) {
11059 return(1);
11060 }
11061 if (n) {
11062 if (gvp == (char*)G__PVOID) {
11063 delete[] (TRecMdcHit*) soff;
11064 } else {
11065 G__setgvp((long) G__PVOID);
11066 for (int i = n - 1; i >= 0; --i) {
11067 ((TRecMdcHit*) (soff+(sizeof(TRecMdcHit)*i)))->~G__TTRecMdcHit();
11068 }
11069 G__setgvp((long)gvp);
11070 }
11071 } else {
11072 if (gvp == (char*)G__PVOID) {
11073 delete (TRecMdcHit*) soff;
11074 } else {
11075 G__setgvp((long) G__PVOID);
11076 ((TRecMdcHit*) (soff))->~G__TTRecMdcHit();
11077 G__setgvp((long)gvp);
11078 }
11079 }
11080 G__setnull(result7);
11081 return(1 || funcname || hash || result7 || libp) ;
11082}
11083
11084// automatic assignment operator
11085static int G__RootEventData_rootcint_209_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11086{
11087 TRecMdcHit* dest = (TRecMdcHit*) G__getstructoffset();
11088 *dest = *(TRecMdcHit*) libp->para[0].ref;
11089 const TRecMdcHit& obj = *dest;
11090 result7->ref = (long) (&obj);
11091 result7->obj.i = (long) (&obj);
11092 return(1 || funcname || hash || result7 || libp) ;
11093}
11094
11095
11096/* TTofTrack */
11097static int G__RootEventData_rootcint_210_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11098{
11099 TTofTrack* p = NULL;
11100 char* gvp = (char*) G__getgvp();
11101 int n = G__getaryconstruct();
11102 if (n) {
11103 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11104 p = new TTofTrack[n];
11105 } else {
11106 p = new((void*) gvp) TTofTrack[n];
11107 }
11108 } else {
11109 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11110 p = new TTofTrack;
11111 } else {
11112 p = new((void*) gvp) TTofTrack;
11113 }
11114 }
11115 result7->obj.i = (long) p;
11116 result7->ref = (long) p;
11117 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
11118 return(1 || funcname || hash || result7 || libp) ;
11119}
11120
11121static int G__RootEventData_rootcint_210_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11122{
11123 ((TTofTrack*) G__getstructoffset())->setTofTrackID((Int_t) G__int(libp->para[0]));
11124 G__setnull(result7);
11125 return(1 || funcname || hash || result7 || libp) ;
11126}
11127
11128static int G__RootEventData_rootcint_210_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11129{
11130 ((TTofTrack*) G__getstructoffset())->setTrackID((Int_t) G__int(libp->para[0]));
11131 G__setnull(result7);
11132 return(1 || funcname || hash || result7 || libp) ;
11133}
11134
11135static int G__RootEventData_rootcint_210_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11136{
11137 ((TTofTrack*) G__getstructoffset())->setTofID((Int_t) G__int(libp->para[0]));
11138 G__setnull(result7);
11139 return(1 || funcname || hash || result7 || libp) ;
11140}
11141
11142static int G__RootEventData_rootcint_210_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11143{
11144 ((TTofTrack*) G__getstructoffset())->setStatus((UInt_t) G__int(libp->para[0]));
11145 G__setnull(result7);
11146 return(1 || funcname || hash || result7 || libp) ;
11147}
11148
11149static int G__RootEventData_rootcint_210_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11150{
11151 ((TTofTrack*) G__getstructoffset())->setPath((Double_t) G__double(libp->para[0]));
11152 G__setnull(result7);
11153 return(1 || funcname || hash || result7 || libp) ;
11154}
11155
11156static int G__RootEventData_rootcint_210_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11157{
11158 ((TTofTrack*) G__getstructoffset())->setZrHit((Double_t) G__double(libp->para[0]));
11159 G__setnull(result7);
11160 return(1 || funcname || hash || result7 || libp) ;
11161}
11162
11163static int G__RootEventData_rootcint_210_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11164{
11165 ((TTofTrack*) G__getstructoffset())->setPh((Double_t) G__double(libp->para[0]));
11166 G__setnull(result7);
11167 return(1 || funcname || hash || result7 || libp) ;
11168}
11169
11170static int G__RootEventData_rootcint_210_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11171{
11172 ((TTofTrack*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
11173 G__setnull(result7);
11174 return(1 || funcname || hash || result7 || libp) ;
11175}
11176
11177static int G__RootEventData_rootcint_210_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11178{
11179 ((TTofTrack*) G__getstructoffset())->setErrTof((Double_t) G__double(libp->para[0]));
11180 G__setnull(result7);
11181 return(1 || funcname || hash || result7 || libp) ;
11182}
11183
11184static int G__RootEventData_rootcint_210_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11185{
11186 ((TTofTrack*) G__getstructoffset())->setBeta((Double_t) G__double(libp->para[0]));
11187 G__setnull(result7);
11188 return(1 || funcname || hash || result7 || libp) ;
11189}
11190
11191static int G__RootEventData_rootcint_210_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11192{
11193 ((TTofTrack*) G__getstructoffset())->setTexp((Double_t*) G__int(libp->para[0]));
11194 G__setnull(result7);
11195 return(1 || funcname || hash || result7 || libp) ;
11196}
11197
11198static int G__RootEventData_rootcint_210_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11199{
11200 ((TTofTrack*) G__getstructoffset())->setTexpElectron((Double_t) G__double(libp->para[0]));
11201 G__setnull(result7);
11202 return(1 || funcname || hash || result7 || libp) ;
11203}
11204
11205static int G__RootEventData_rootcint_210_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11206{
11207 ((TTofTrack*) G__getstructoffset())->setTexpMuon((Double_t) G__double(libp->para[0]));
11208 G__setnull(result7);
11209 return(1 || funcname || hash || result7 || libp) ;
11210}
11211
11212static int G__RootEventData_rootcint_210_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11213{
11214 ((TTofTrack*) G__getstructoffset())->setTexpPion((Double_t) G__double(libp->para[0]));
11215 G__setnull(result7);
11216 return(1 || funcname || hash || result7 || libp) ;
11217}
11218
11219static int G__RootEventData_rootcint_210_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11220{
11221 ((TTofTrack*) G__getstructoffset())->setTexpKaon((Double_t) G__double(libp->para[0]));
11222 G__setnull(result7);
11223 return(1 || funcname || hash || result7 || libp) ;
11224}
11225
11226static int G__RootEventData_rootcint_210_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11227{
11228 ((TTofTrack*) G__getstructoffset())->setTexpProton((Double_t) G__double(libp->para[0]));
11229 G__setnull(result7);
11230 return(1 || funcname || hash || result7 || libp) ;
11231}
11232
11233static int G__RootEventData_rootcint_210_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11234{
11235 ((TTofTrack*) G__getstructoffset())->setToffset((Double_t*) G__int(libp->para[0]));
11236 G__setnull(result7);
11237 return(1 || funcname || hash || result7 || libp) ;
11238}
11239
11240static int G__RootEventData_rootcint_210_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11241{
11242 ((TTofTrack*) G__getstructoffset())->setToffsetElectron((Double_t) G__double(libp->para[0]));
11243 G__setnull(result7);
11244 return(1 || funcname || hash || result7 || libp) ;
11245}
11246
11247static int G__RootEventData_rootcint_210_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11248{
11249 ((TTofTrack*) G__getstructoffset())->setToffsetMuon((Double_t) G__double(libp->para[0]));
11250 G__setnull(result7);
11251 return(1 || funcname || hash || result7 || libp) ;
11252}
11253
11254static int G__RootEventData_rootcint_210_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11255{
11256 ((TTofTrack*) G__getstructoffset())->setToffsetPion((Double_t) G__double(libp->para[0]));
11257 G__setnull(result7);
11258 return(1 || funcname || hash || result7 || libp) ;
11259}
11260
11261static int G__RootEventData_rootcint_210_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11262{
11263 ((TTofTrack*) G__getstructoffset())->setToffsetKaon((Double_t) G__double(libp->para[0]));
11264 G__setnull(result7);
11265 return(1 || funcname || hash || result7 || libp) ;
11266}
11267
11268static int G__RootEventData_rootcint_210_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11269{
11270 ((TTofTrack*) G__getstructoffset())->setToffsetProton((Double_t) G__double(libp->para[0]));
11271 G__setnull(result7);
11272 return(1 || funcname || hash || result7 || libp) ;
11273}
11274
11275static int G__RootEventData_rootcint_210_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11276{
11277 ((TTofTrack*) G__getstructoffset())->setToffsetAntiProton((Double_t) G__double(libp->para[0]));
11278 G__setnull(result7);
11279 return(1 || funcname || hash || result7 || libp) ;
11280}
11281
11282static int G__RootEventData_rootcint_210_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11283{
11284 ((TTofTrack*) G__getstructoffset())->setSigma((Double_t*) G__int(libp->para[0]));
11285 G__setnull(result7);
11286 return(1 || funcname || hash || result7 || libp) ;
11287}
11288
11289static int G__RootEventData_rootcint_210_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11290{
11291 ((TTofTrack*) G__getstructoffset())->setSigmaElectron((Double_t) G__double(libp->para[0]));
11292 G__setnull(result7);
11293 return(1 || funcname || hash || result7 || libp) ;
11294}
11295
11296static int G__RootEventData_rootcint_210_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11297{
11298 ((TTofTrack*) G__getstructoffset())->setSigmaMuon((Double_t) G__double(libp->para[0]));
11299 G__setnull(result7);
11300 return(1 || funcname || hash || result7 || libp) ;
11301}
11302
11303static int G__RootEventData_rootcint_210_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11304{
11305 ((TTofTrack*) G__getstructoffset())->setSigmaPion((Double_t) G__double(libp->para[0]));
11306 G__setnull(result7);
11307 return(1 || funcname || hash || result7 || libp) ;
11308}
11309
11310static int G__RootEventData_rootcint_210_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11311{
11312 ((TTofTrack*) G__getstructoffset())->setSigmaKaon((Double_t) G__double(libp->para[0]));
11313 G__setnull(result7);
11314 return(1 || funcname || hash || result7 || libp) ;
11315}
11316
11317static int G__RootEventData_rootcint_210_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11318{
11319 ((TTofTrack*) G__getstructoffset())->setSigmaProton((Double_t) G__double(libp->para[0]));
11320 G__setnull(result7);
11321 return(1 || funcname || hash || result7 || libp) ;
11322}
11323
11324static int G__RootEventData_rootcint_210_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11325{
11326 ((TTofTrack*) G__getstructoffset())->setSigmaAntiProton((Double_t) G__double(libp->para[0]));
11327 G__setnull(result7);
11328 return(1 || funcname || hash || result7 || libp) ;
11329}
11330
11331static int G__RootEventData_rootcint_210_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11332{
11333 ((TTofTrack*) G__getstructoffset())->setQuality((Int_t) G__int(libp->para[0]));
11334 G__setnull(result7);
11335 return(1 || funcname || hash || result7 || libp) ;
11336}
11337
11338static int G__RootEventData_rootcint_210_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11339{
11340 ((TTofTrack*) G__getstructoffset())->setT0((Double_t) G__double(libp->para[0]));
11341 G__setnull(result7);
11342 return(1 || funcname || hash || result7 || libp) ;
11343}
11344
11345static int G__RootEventData_rootcint_210_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11346{
11347 ((TTofTrack*) G__getstructoffset())->setErrT0((Double_t) G__double(libp->para[0]));
11348 G__setnull(result7);
11349 return(1 || funcname || hash || result7 || libp) ;
11350}
11351
11352static int G__RootEventData_rootcint_210_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11353{
11354 ((TTofTrack*) G__getstructoffset())->setErrZ((Double_t) G__double(libp->para[0]));
11355 G__setnull(result7);
11356 return(1 || funcname || hash || result7 || libp) ;
11357}
11358
11359static int G__RootEventData_rootcint_210_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11360{
11361 ((TTofTrack*) G__getstructoffset())->setPhi((Double_t) G__double(libp->para[0]));
11362 G__setnull(result7);
11363 return(1 || funcname || hash || result7 || libp) ;
11364}
11365
11366static int G__RootEventData_rootcint_210_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11367{
11368 ((TTofTrack*) G__getstructoffset())->setErrPhi((Double_t) G__double(libp->para[0]));
11369 G__setnull(result7);
11370 return(1 || funcname || hash || result7 || libp) ;
11371}
11372
11373static int G__RootEventData_rootcint_210_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11374{
11375 ((TTofTrack*) G__getstructoffset())->setEnergy((Double_t) G__double(libp->para[0]));
11376 G__setnull(result7);
11377 return(1 || funcname || hash || result7 || libp) ;
11378}
11379
11380static int G__RootEventData_rootcint_210_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11381{
11382 ((TTofTrack*) G__getstructoffset())->setErrEnergy((Double_t) G__double(libp->para[0]));
11383 G__setnull(result7);
11384 return(1 || funcname || hash || result7 || libp) ;
11385}
11386
11387static int G__RootEventData_rootcint_210_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11388{
11389 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->tofTrackID());
11390 return(1 || funcname || hash || result7 || libp) ;
11391}
11392
11393static int G__RootEventData_rootcint_210_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11394{
11395 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->trackID());
11396 return(1 || funcname || hash || result7 || libp) ;
11397}
11398
11399static int G__RootEventData_rootcint_210_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11400{
11401 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->tofID());
11402 return(1 || funcname || hash || result7 || libp) ;
11403}
11404
11405static int G__RootEventData_rootcint_210_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11406{
11407 G__letint(result7, 104, (long) ((const TTofTrack*) G__getstructoffset())->status());
11408 return(1 || funcname || hash || result7 || libp) ;
11409}
11410
11411static int G__RootEventData_rootcint_210_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11412{
11413 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->path());
11414 return(1 || funcname || hash || result7 || libp) ;
11415}
11416
11417static int G__RootEventData_rootcint_210_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11418{
11419 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->zrhit());
11420 return(1 || funcname || hash || result7 || libp) ;
11421}
11422
11423static int G__RootEventData_rootcint_210_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11424{
11425 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->ph());
11426 return(1 || funcname || hash || result7 || libp) ;
11427}
11428
11429static int G__RootEventData_rootcint_210_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11430{
11431 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->tof());
11432 return(1 || funcname || hash || result7 || libp) ;
11433}
11434
11435static int G__RootEventData_rootcint_210_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11436{
11437 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errtof());
11438 return(1 || funcname || hash || result7 || libp) ;
11439}
11440
11441static int G__RootEventData_rootcint_210_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11442{
11443 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->beta());
11444 return(1 || funcname || hash || result7 || libp) ;
11445}
11446
11447static int G__RootEventData_rootcint_210_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11448{
11449 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texp((Int_t) G__int(libp->para[0])));
11450 return(1 || funcname || hash || result7 || libp) ;
11451}
11452
11453static int G__RootEventData_rootcint_210_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11454{
11455 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpElectron());
11456 return(1 || funcname || hash || result7 || libp) ;
11457}
11458
11459static int G__RootEventData_rootcint_210_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11460{
11461 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpMuon());
11462 return(1 || funcname || hash || result7 || libp) ;
11463}
11464
11465static int G__RootEventData_rootcint_210_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11466{
11467 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpPion());
11468 return(1 || funcname || hash || result7 || libp) ;
11469}
11470
11471static int G__RootEventData_rootcint_210_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11472{
11473 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpKaon());
11474 return(1 || funcname || hash || result7 || libp) ;
11475}
11476
11477static int G__RootEventData_rootcint_210_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11478{
11479 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpProton());
11480 return(1 || funcname || hash || result7 || libp) ;
11481}
11482
11483static int G__RootEventData_rootcint_210_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11484{
11485 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffset((Int_t) G__int(libp->para[0])));
11486 return(1 || funcname || hash || result7 || libp) ;
11487}
11488
11489static int G__RootEventData_rootcint_210_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11490{
11491 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetElectron());
11492 return(1 || funcname || hash || result7 || libp) ;
11493}
11494
11495static int G__RootEventData_rootcint_210_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11496{
11497 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetMuon());
11498 return(1 || funcname || hash || result7 || libp) ;
11499}
11500
11501static int G__RootEventData_rootcint_210_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11502{
11503 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetPion());
11504 return(1 || funcname || hash || result7 || libp) ;
11505}
11506
11507static int G__RootEventData_rootcint_210_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11508{
11509 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetKaon());
11510 return(1 || funcname || hash || result7 || libp) ;
11511}
11512
11513static int G__RootEventData_rootcint_210_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11514{
11515 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetProton());
11516 return(1 || funcname || hash || result7 || libp) ;
11517}
11518
11519static int G__RootEventData_rootcint_210_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11520{
11521 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetAntiProton());
11522 return(1 || funcname || hash || result7 || libp) ;
11523}
11524
11525static int G__RootEventData_rootcint_210_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11526{
11527 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigma((Int_t) G__int(libp->para[0])));
11528 return(1 || funcname || hash || result7 || libp) ;
11529}
11530
11531static int G__RootEventData_rootcint_210_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11532{
11533 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaElectron());
11534 return(1 || funcname || hash || result7 || libp) ;
11535}
11536
11537static int G__RootEventData_rootcint_210_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11538{
11539 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaMuon());
11540 return(1 || funcname || hash || result7 || libp) ;
11541}
11542
11543static int G__RootEventData_rootcint_210_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11544{
11545 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaPion());
11546 return(1 || funcname || hash || result7 || libp) ;
11547}
11548
11549static int G__RootEventData_rootcint_210_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11550{
11551 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaKaon());
11552 return(1 || funcname || hash || result7 || libp) ;
11553}
11554
11555static int G__RootEventData_rootcint_210_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11556{
11557 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaProton());
11558 return(1 || funcname || hash || result7 || libp) ;
11559}
11560
11561static int G__RootEventData_rootcint_210_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11562{
11563 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaAntiProton());
11564 return(1 || funcname || hash || result7 || libp) ;
11565}
11566
11567static int G__RootEventData_rootcint_210_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11568{
11569 G__letint(result7, 105, (long) ((const TTofTrack*) G__getstructoffset())->quality());
11570 return(1 || funcname || hash || result7 || libp) ;
11571}
11572
11573static int G__RootEventData_rootcint_210_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11574{
11575 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->t0());
11576 return(1 || funcname || hash || result7 || libp) ;
11577}
11578
11579static int G__RootEventData_rootcint_210_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11580{
11581 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errt0());
11582 return(1 || funcname || hash || result7 || libp) ;
11583}
11584
11585static int G__RootEventData_rootcint_210_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11586{
11587 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errz());
11588 return(1 || funcname || hash || result7 || libp) ;
11589}
11590
11591static int G__RootEventData_rootcint_210_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11592{
11593 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->phi());
11594 return(1 || funcname || hash || result7 || libp) ;
11595}
11596
11597static int G__RootEventData_rootcint_210_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11598{
11599 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errphi());
11600 return(1 || funcname || hash || result7 || libp) ;
11601}
11602
11603static int G__RootEventData_rootcint_210_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11604{
11605 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->energy());
11606 return(1 || funcname || hash || result7 || libp) ;
11607}
11608
11609static int G__RootEventData_rootcint_210_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11610{
11611 G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errenergy());
11612 return(1 || funcname || hash || result7 || libp) ;
11613}
11614
11615static int G__RootEventData_rootcint_210_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11616{
11617 G__letint(result7, 85, (long) TTofTrack::Class());
11618 return(1 || funcname || hash || result7 || libp) ;
11619}
11620
11621static int G__RootEventData_rootcint_210_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11622{
11623 G__letint(result7, 67, (long) TTofTrack::Class_Name());
11624 return(1 || funcname || hash || result7 || libp) ;
11625}
11626
11627static int G__RootEventData_rootcint_210_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11628{
11629 G__letint(result7, 115, (long) TTofTrack::Class_Version());
11630 return(1 || funcname || hash || result7 || libp) ;
11631}
11632
11633static int G__RootEventData_rootcint_210_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11634{
11635 TTofTrack::Dictionary();
11636 G__setnull(result7);
11637 return(1 || funcname || hash || result7 || libp) ;
11638}
11639
11640static int G__RootEventData_rootcint_210_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11641{
11642 ((TTofTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11643 G__setnull(result7);
11644 return(1 || funcname || hash || result7 || libp) ;
11645}
11646
11647static int G__RootEventData_rootcint_210_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11648{
11649 G__letint(result7, 67, (long) TTofTrack::DeclFileName());
11650 return(1 || funcname || hash || result7 || libp) ;
11651}
11652
11653static int G__RootEventData_rootcint_210_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11654{
11655 G__letint(result7, 105, (long) TTofTrack::ImplFileLine());
11656 return(1 || funcname || hash || result7 || libp) ;
11657}
11658
11659static int G__RootEventData_rootcint_210_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11660{
11661 G__letint(result7, 67, (long) TTofTrack::ImplFileName());
11662 return(1 || funcname || hash || result7 || libp) ;
11663}
11664
11665static int G__RootEventData_rootcint_210_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11666{
11667 G__letint(result7, 105, (long) TTofTrack::DeclFileLine());
11668 return(1 || funcname || hash || result7 || libp) ;
11669}
11670
11671// automatic copy constructor
11672static int G__RootEventData_rootcint_210_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11673
11674{
11675 TTofTrack* p;
11676 void* tmp = (void*) G__int(libp->para[0]);
11677 p = new TTofTrack(*(TTofTrack*) tmp);
11678 result7->obj.i = (long) p;
11679 result7->ref = (long) p;
11680 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
11681 return(1 || funcname || hash || result7 || libp) ;
11682}
11683
11684// automatic destructor
11685typedef TTofTrack G__TTTofTrack;
11686static int G__RootEventData_rootcint_210_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11687{
11688 char* gvp = (char*) G__getgvp();
11689 long soff = G__getstructoffset();
11690 int n = G__getaryconstruct();
11691 //
11692 //has_a_delete: 1
11693 //has_own_delete1arg: 0
11694 //has_own_delete2arg: 0
11695 //
11696 if (!soff) {
11697 return(1);
11698 }
11699 if (n) {
11700 if (gvp == (char*)G__PVOID) {
11701 delete[] (TTofTrack*) soff;
11702 } else {
11703 G__setgvp((long) G__PVOID);
11704 for (int i = n - 1; i >= 0; --i) {
11705 ((TTofTrack*) (soff+(sizeof(TTofTrack)*i)))->~G__TTTofTrack();
11706 }
11707 G__setgvp((long)gvp);
11708 }
11709 } else {
11710 if (gvp == (char*)G__PVOID) {
11711 delete (TTofTrack*) soff;
11712 } else {
11713 G__setgvp((long) G__PVOID);
11714 ((TTofTrack*) (soff))->~G__TTTofTrack();
11715 G__setgvp((long)gvp);
11716 }
11717 }
11718 G__setnull(result7);
11719 return(1 || funcname || hash || result7 || libp) ;
11720}
11721
11722// automatic assignment operator
11723static int G__RootEventData_rootcint_210_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11724{
11725 TTofTrack* dest = (TTofTrack*) G__getstructoffset();
11726 *dest = *(TTofTrack*) libp->para[0].ref;
11727 const TTofTrack& obj = *dest;
11728 result7->ref = (long) (&obj);
11729 result7->obj.i = (long) (&obj);
11730 return(1 || funcname || hash || result7 || libp) ;
11731}
11732
11733
11734/* TRecTofTrack */
11735static int G__RootEventData_rootcint_211_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11736{
11737 TRecTofTrack* p = NULL;
11738 char* gvp = (char*) G__getgvp();
11739 int n = G__getaryconstruct();
11740 if (n) {
11741 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11742 p = new TRecTofTrack[n];
11743 } else {
11744 p = new((void*) gvp) TRecTofTrack[n];
11745 }
11746 } else {
11747 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11748 p = new TRecTofTrack;
11749 } else {
11750 p = new((void*) gvp) TRecTofTrack;
11751 }
11752 }
11753 result7->obj.i = (long) p;
11754 result7->ref = (long) p;
11755 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
11756 return(1 || funcname || hash || result7 || libp) ;
11757}
11758
11759static int G__RootEventData_rootcint_211_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11760{
11761 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->tofTrackID());
11762 return(1 || funcname || hash || result7 || libp) ;
11763}
11764
11765static int G__RootEventData_rootcint_211_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11766{
11767 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->trackID());
11768 return(1 || funcname || hash || result7 || libp) ;
11769}
11770
11771static int G__RootEventData_rootcint_211_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11772{
11773 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->tofID());
11774 return(1 || funcname || hash || result7 || libp) ;
11775}
11776
11777static int G__RootEventData_rootcint_211_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11778{
11779 G__letint(result7, 104, (long) ((const TRecTofTrack*) G__getstructoffset())->status());
11780 return(1 || funcname || hash || result7 || libp) ;
11781}
11782
11783static int G__RootEventData_rootcint_211_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11784{
11785 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->path());
11786 return(1 || funcname || hash || result7 || libp) ;
11787}
11788
11789static int G__RootEventData_rootcint_211_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11790{
11791 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->zrhit());
11792 return(1 || funcname || hash || result7 || libp) ;
11793}
11794
11795static int G__RootEventData_rootcint_211_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11796{
11797 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->ph());
11798 return(1 || funcname || hash || result7 || libp) ;
11799}
11800
11801static int G__RootEventData_rootcint_211_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11802{
11803 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->tof());
11804 return(1 || funcname || hash || result7 || libp) ;
11805}
11806
11807static int G__RootEventData_rootcint_211_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11808{
11809 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errtof());
11810 return(1 || funcname || hash || result7 || libp) ;
11811}
11812
11813static int G__RootEventData_rootcint_211_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11814{
11815 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->beta());
11816 return(1 || funcname || hash || result7 || libp) ;
11817}
11818
11819static int G__RootEventData_rootcint_211_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11820{
11821 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texp((Int_t) G__int(libp->para[0])));
11822 return(1 || funcname || hash || result7 || libp) ;
11823}
11824
11825static int G__RootEventData_rootcint_211_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11826{
11827 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpElectron());
11828 return(1 || funcname || hash || result7 || libp) ;
11829}
11830
11831static int G__RootEventData_rootcint_211_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11832{
11833 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpMuon());
11834 return(1 || funcname || hash || result7 || libp) ;
11835}
11836
11837static int G__RootEventData_rootcint_211_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11838{
11839 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpPion());
11840 return(1 || funcname || hash || result7 || libp) ;
11841}
11842
11843static int G__RootEventData_rootcint_211_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11844{
11845 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpKaon());
11846 return(1 || funcname || hash || result7 || libp) ;
11847}
11848
11849static int G__RootEventData_rootcint_211_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11850{
11851 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpProton());
11852 return(1 || funcname || hash || result7 || libp) ;
11853}
11854
11855static int G__RootEventData_rootcint_211_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11856{
11857 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffset((Int_t) G__int(libp->para[0])));
11858 return(1 || funcname || hash || result7 || libp) ;
11859}
11860
11861static int G__RootEventData_rootcint_211_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11862{
11863 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetElectron());
11864 return(1 || funcname || hash || result7 || libp) ;
11865}
11866
11867static int G__RootEventData_rootcint_211_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11868{
11869 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetMuon());
11870 return(1 || funcname || hash || result7 || libp) ;
11871}
11872
11873static int G__RootEventData_rootcint_211_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11874{
11875 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetPion());
11876 return(1 || funcname || hash || result7 || libp) ;
11877}
11878
11879static int G__RootEventData_rootcint_211_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11880{
11881 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetKaon());
11882 return(1 || funcname || hash || result7 || libp) ;
11883}
11884
11885static int G__RootEventData_rootcint_211_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11886{
11887 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetProton());
11888 return(1 || funcname || hash || result7 || libp) ;
11889}
11890
11891static int G__RootEventData_rootcint_211_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11892{
11893 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetAntiProton());
11894 return(1 || funcname || hash || result7 || libp) ;
11895}
11896
11897static int G__RootEventData_rootcint_211_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11898{
11899 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigma((Int_t) G__int(libp->para[0])));
11900 return(1 || funcname || hash || result7 || libp) ;
11901}
11902
11903static int G__RootEventData_rootcint_211_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11904{
11905 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaElectron());
11906 return(1 || funcname || hash || result7 || libp) ;
11907}
11908
11909static int G__RootEventData_rootcint_211_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11910{
11911 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaMuon());
11912 return(1 || funcname || hash || result7 || libp) ;
11913}
11914
11915static int G__RootEventData_rootcint_211_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11916{
11917 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaPion());
11918 return(1 || funcname || hash || result7 || libp) ;
11919}
11920
11921static int G__RootEventData_rootcint_211_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11922{
11923 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaKaon());
11924 return(1 || funcname || hash || result7 || libp) ;
11925}
11926
11927static int G__RootEventData_rootcint_211_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11928{
11929 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaProton());
11930 return(1 || funcname || hash || result7 || libp) ;
11931}
11932
11933static int G__RootEventData_rootcint_211_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11934{
11935 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaAntiProton());
11936 return(1 || funcname || hash || result7 || libp) ;
11937}
11938
11939static int G__RootEventData_rootcint_211_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11940{
11941 G__letint(result7, 105, (long) ((const TRecTofTrack*) G__getstructoffset())->quality());
11942 return(1 || funcname || hash || result7 || libp) ;
11943}
11944
11945static int G__RootEventData_rootcint_211_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11946{
11947 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->t0());
11948 return(1 || funcname || hash || result7 || libp) ;
11949}
11950
11951static int G__RootEventData_rootcint_211_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11952{
11953 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errt0());
11954 return(1 || funcname || hash || result7 || libp) ;
11955}
11956
11957static int G__RootEventData_rootcint_211_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11958{
11959 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errz());
11960 return(1 || funcname || hash || result7 || libp) ;
11961}
11962
11963static int G__RootEventData_rootcint_211_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11964{
11965 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->phi());
11966 return(1 || funcname || hash || result7 || libp) ;
11967}
11968
11969static int G__RootEventData_rootcint_211_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11970{
11971 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errphi());
11972 return(1 || funcname || hash || result7 || libp) ;
11973}
11974
11975static int G__RootEventData_rootcint_211_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11976{
11977 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->energy());
11978 return(1 || funcname || hash || result7 || libp) ;
11979}
11980
11981static int G__RootEventData_rootcint_211_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11982{
11983 G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errenergy());
11984 return(1 || funcname || hash || result7 || libp) ;
11985}
11986
11987static int G__RootEventData_rootcint_211_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11988{
11989 ((TRecTofTrack*) G__getstructoffset())->setTofTrackID((Int_t) G__int(libp->para[0]));
11990 G__setnull(result7);
11991 return(1 || funcname || hash || result7 || libp) ;
11992}
11993
11994static int G__RootEventData_rootcint_211_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11995{
11996 ((TRecTofTrack*) G__getstructoffset())->setTrackID((Int_t) G__int(libp->para[0]));
11997 G__setnull(result7);
11998 return(1 || funcname || hash || result7 || libp) ;
11999}
12000
12001static int G__RootEventData_rootcint_211_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12002{
12003 ((TRecTofTrack*) G__getstructoffset())->setTofID((Int_t) G__int(libp->para[0]));
12004 G__setnull(result7);
12005 return(1 || funcname || hash || result7 || libp) ;
12006}
12007
12008static int G__RootEventData_rootcint_211_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12009{
12010 ((TRecTofTrack*) G__getstructoffset())->setStatus((UInt_t) G__int(libp->para[0]));
12011 G__setnull(result7);
12012 return(1 || funcname || hash || result7 || libp) ;
12013}
12014
12015static int G__RootEventData_rootcint_211_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12016{
12017 ((TRecTofTrack*) G__getstructoffset())->setPath((Double_t) G__double(libp->para[0]));
12018 G__setnull(result7);
12019 return(1 || funcname || hash || result7 || libp) ;
12020}
12021
12022static int G__RootEventData_rootcint_211_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12023{
12024 ((TRecTofTrack*) G__getstructoffset())->setZrHit((Double_t) G__double(libp->para[0]));
12025 G__setnull(result7);
12026 return(1 || funcname || hash || result7 || libp) ;
12027}
12028
12029static int G__RootEventData_rootcint_211_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12030{
12031 ((TRecTofTrack*) G__getstructoffset())->setPh((Double_t) G__double(libp->para[0]));
12032 G__setnull(result7);
12033 return(1 || funcname || hash || result7 || libp) ;
12034}
12035
12036static int G__RootEventData_rootcint_211_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12037{
12038 ((TRecTofTrack*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
12039 G__setnull(result7);
12040 return(1 || funcname || hash || result7 || libp) ;
12041}
12042
12043static int G__RootEventData_rootcint_211_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12044{
12045 ((TRecTofTrack*) G__getstructoffset())->setErrTof((Double_t) G__double(libp->para[0]));
12046 G__setnull(result7);
12047 return(1 || funcname || hash || result7 || libp) ;
12048}
12049
12050static int G__RootEventData_rootcint_211_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12051{
12052 ((TRecTofTrack*) G__getstructoffset())->setBeta((Double_t) G__double(libp->para[0]));
12053 G__setnull(result7);
12054 return(1 || funcname || hash || result7 || libp) ;
12055}
12056
12057static int G__RootEventData_rootcint_211_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12058{
12059 ((TRecTofTrack*) G__getstructoffset())->setTexp((Double_t*) G__int(libp->para[0]));
12060 G__setnull(result7);
12061 return(1 || funcname || hash || result7 || libp) ;
12062}
12063
12064static int G__RootEventData_rootcint_211_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12065{
12066 ((TRecTofTrack*) G__getstructoffset())->setTexpElectron((Double_t) G__double(libp->para[0]));
12067 G__setnull(result7);
12068 return(1 || funcname || hash || result7 || libp) ;
12069}
12070
12071static int G__RootEventData_rootcint_211_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12072{
12073 ((TRecTofTrack*) G__getstructoffset())->setTexpMuon((Double_t) G__double(libp->para[0]));
12074 G__setnull(result7);
12075 return(1 || funcname || hash || result7 || libp) ;
12076}
12077
12078static int G__RootEventData_rootcint_211_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12079{
12080 ((TRecTofTrack*) G__getstructoffset())->setTexpPion((Double_t) G__double(libp->para[0]));
12081 G__setnull(result7);
12082 return(1 || funcname || hash || result7 || libp) ;
12083}
12084
12085static int G__RootEventData_rootcint_211_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12086{
12087 ((TRecTofTrack*) G__getstructoffset())->setTexpKaon((Double_t) G__double(libp->para[0]));
12088 G__setnull(result7);
12089 return(1 || funcname || hash || result7 || libp) ;
12090}
12091
12092static int G__RootEventData_rootcint_211_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12093{
12094 ((TRecTofTrack*) G__getstructoffset())->setTexpProton((Double_t) G__double(libp->para[0]));
12095 G__setnull(result7);
12096 return(1 || funcname || hash || result7 || libp) ;
12097}
12098
12099static int G__RootEventData_rootcint_211_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12100{
12101 ((TRecTofTrack*) G__getstructoffset())->setToffset((Double_t*) G__int(libp->para[0]));
12102 G__setnull(result7);
12103 return(1 || funcname || hash || result7 || libp) ;
12104}
12105
12106static int G__RootEventData_rootcint_211_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12107{
12108 ((TRecTofTrack*) G__getstructoffset())->setToffsetElectron((Double_t) G__double(libp->para[0]));
12109 G__setnull(result7);
12110 return(1 || funcname || hash || result7 || libp) ;
12111}
12112
12113static int G__RootEventData_rootcint_211_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12114{
12115 ((TRecTofTrack*) G__getstructoffset())->setToffsetMuon((Double_t) G__double(libp->para[0]));
12116 G__setnull(result7);
12117 return(1 || funcname || hash || result7 || libp) ;
12118}
12119
12120static int G__RootEventData_rootcint_211_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12121{
12122 ((TRecTofTrack*) G__getstructoffset())->setToffsetPion((Double_t) G__double(libp->para[0]));
12123 G__setnull(result7);
12124 return(1 || funcname || hash || result7 || libp) ;
12125}
12126
12127static int G__RootEventData_rootcint_211_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12128{
12129 ((TRecTofTrack*) G__getstructoffset())->setToffsetKaon((Double_t) G__double(libp->para[0]));
12130 G__setnull(result7);
12131 return(1 || funcname || hash || result7 || libp) ;
12132}
12133
12134static int G__RootEventData_rootcint_211_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12135{
12136 ((TRecTofTrack*) G__getstructoffset())->setToffsetProton((Double_t) G__double(libp->para[0]));
12137 G__setnull(result7);
12138 return(1 || funcname || hash || result7 || libp) ;
12139}
12140
12141static int G__RootEventData_rootcint_211_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12142{
12143 ((TRecTofTrack*) G__getstructoffset())->setToffsetAntiProton((Double_t) G__double(libp->para[0]));
12144 G__setnull(result7);
12145 return(1 || funcname || hash || result7 || libp) ;
12146}
12147
12148static int G__RootEventData_rootcint_211_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12149{
12150 ((TRecTofTrack*) G__getstructoffset())->setSigma((Double_t*) G__int(libp->para[0]));
12151 G__setnull(result7);
12152 return(1 || funcname || hash || result7 || libp) ;
12153}
12154
12155static int G__RootEventData_rootcint_211_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12156{
12157 ((TRecTofTrack*) G__getstructoffset())->setSigmaElectron((Double_t) G__double(libp->para[0]));
12158 G__setnull(result7);
12159 return(1 || funcname || hash || result7 || libp) ;
12160}
12161
12162static int G__RootEventData_rootcint_211_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12163{
12164 ((TRecTofTrack*) G__getstructoffset())->setSigmaMuon((Double_t) G__double(libp->para[0]));
12165 G__setnull(result7);
12166 return(1 || funcname || hash || result7 || libp) ;
12167}
12168
12169static int G__RootEventData_rootcint_211_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12170{
12171 ((TRecTofTrack*) G__getstructoffset())->setSigmaPion((Double_t) G__double(libp->para[0]));
12172 G__setnull(result7);
12173 return(1 || funcname || hash || result7 || libp) ;
12174}
12175
12176static int G__RootEventData_rootcint_211_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12177{
12178 ((TRecTofTrack*) G__getstructoffset())->setSigmaKaon((Double_t) G__double(libp->para[0]));
12179 G__setnull(result7);
12180 return(1 || funcname || hash || result7 || libp) ;
12181}
12182
12183static int G__RootEventData_rootcint_211_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12184{
12185 ((TRecTofTrack*) G__getstructoffset())->setSigmaProton((Double_t) G__double(libp->para[0]));
12186 G__setnull(result7);
12187 return(1 || funcname || hash || result7 || libp) ;
12188}
12189
12190static int G__RootEventData_rootcint_211_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12191{
12192 ((TRecTofTrack*) G__getstructoffset())->setSigmaAntiProton((Double_t) G__double(libp->para[0]));
12193 G__setnull(result7);
12194 return(1 || funcname || hash || result7 || libp) ;
12195}
12196
12197static int G__RootEventData_rootcint_211_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12198{
12199 ((TRecTofTrack*) G__getstructoffset())->setQuality((Int_t) G__int(libp->para[0]));
12200 G__setnull(result7);
12201 return(1 || funcname || hash || result7 || libp) ;
12202}
12203
12204static int G__RootEventData_rootcint_211_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12205{
12206 ((TRecTofTrack*) G__getstructoffset())->setT0((Double_t) G__double(libp->para[0]));
12207 G__setnull(result7);
12208 return(1 || funcname || hash || result7 || libp) ;
12209}
12210
12211static int G__RootEventData_rootcint_211_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12212{
12213 ((TRecTofTrack*) G__getstructoffset())->setErrT0((Double_t) G__double(libp->para[0]));
12214 G__setnull(result7);
12215 return(1 || funcname || hash || result7 || libp) ;
12216}
12217
12218static int G__RootEventData_rootcint_211_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12219{
12220 ((TRecTofTrack*) G__getstructoffset())->setErrZ((Double_t) G__double(libp->para[0]));
12221 G__setnull(result7);
12222 return(1 || funcname || hash || result7 || libp) ;
12223}
12224
12225static int G__RootEventData_rootcint_211_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12226{
12227 ((TRecTofTrack*) G__getstructoffset())->setPhi((Double_t) G__double(libp->para[0]));
12228 G__setnull(result7);
12229 return(1 || funcname || hash || result7 || libp) ;
12230}
12231
12232static int G__RootEventData_rootcint_211_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12233{
12234 ((TRecTofTrack*) G__getstructoffset())->setErrPhi((Double_t) G__double(libp->para[0]));
12235 G__setnull(result7);
12236 return(1 || funcname || hash || result7 || libp) ;
12237}
12238
12239static int G__RootEventData_rootcint_211_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12240{
12241 ((TRecTofTrack*) G__getstructoffset())->setEnergy((Double_t) G__double(libp->para[0]));
12242 G__setnull(result7);
12243 return(1 || funcname || hash || result7 || libp) ;
12244}
12245
12246static int G__RootEventData_rootcint_211_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12247{
12248 ((TRecTofTrack*) G__getstructoffset())->setErrEnergy((Double_t) G__double(libp->para[0]));
12249 G__setnull(result7);
12250 return(1 || funcname || hash || result7 || libp) ;
12251}
12252
12253static int G__RootEventData_rootcint_211_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12254{
12255 ((TRecTofTrack*) G__getstructoffset())->setTRecTofTrack((TRecTofTrack*) G__int(libp->para[0]));
12256 G__setnull(result7);
12257 return(1 || funcname || hash || result7 || libp) ;
12258}
12259
12260static int G__RootEventData_rootcint_211_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12261{
12262 G__letint(result7, 85, (long) TRecTofTrack::Class());
12263 return(1 || funcname || hash || result7 || libp) ;
12264}
12265
12266static int G__RootEventData_rootcint_211_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12267{
12268 G__letint(result7, 67, (long) TRecTofTrack::Class_Name());
12269 return(1 || funcname || hash || result7 || libp) ;
12270}
12271
12272static int G__RootEventData_rootcint_211_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12273{
12274 G__letint(result7, 115, (long) TRecTofTrack::Class_Version());
12275 return(1 || funcname || hash || result7 || libp) ;
12276}
12277
12278static int G__RootEventData_rootcint_211_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12279{
12280 TRecTofTrack::Dictionary();
12281 G__setnull(result7);
12282 return(1 || funcname || hash || result7 || libp) ;
12283}
12284
12285static int G__RootEventData_rootcint_211_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12286{
12287 ((TRecTofTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12288 G__setnull(result7);
12289 return(1 || funcname || hash || result7 || libp) ;
12290}
12291
12292static int G__RootEventData_rootcint_211_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12293{
12294 G__letint(result7, 67, (long) TRecTofTrack::DeclFileName());
12295 return(1 || funcname || hash || result7 || libp) ;
12296}
12297
12298static int G__RootEventData_rootcint_211_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12299{
12300 G__letint(result7, 105, (long) TRecTofTrack::ImplFileLine());
12301 return(1 || funcname || hash || result7 || libp) ;
12302}
12303
12304static int G__RootEventData_rootcint_211_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12305{
12306 G__letint(result7, 67, (long) TRecTofTrack::ImplFileName());
12307 return(1 || funcname || hash || result7 || libp) ;
12308}
12309
12310static int G__RootEventData_rootcint_211_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12311{
12312 G__letint(result7, 105, (long) TRecTofTrack::DeclFileLine());
12313 return(1 || funcname || hash || result7 || libp) ;
12314}
12315
12316// automatic copy constructor
12317static int G__RootEventData_rootcint_211_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12318
12319{
12320 TRecTofTrack* p;
12321 void* tmp = (void*) G__int(libp->para[0]);
12322 p = new TRecTofTrack(*(TRecTofTrack*) tmp);
12323 result7->obj.i = (long) p;
12324 result7->ref = (long) p;
12325 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
12326 return(1 || funcname || hash || result7 || libp) ;
12327}
12328
12329// automatic destructor
12330typedef TRecTofTrack G__TTRecTofTrack;
12331static int G__RootEventData_rootcint_211_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12332{
12333 char* gvp = (char*) G__getgvp();
12334 long soff = G__getstructoffset();
12335 int n = G__getaryconstruct();
12336 //
12337 //has_a_delete: 1
12338 //has_own_delete1arg: 0
12339 //has_own_delete2arg: 0
12340 //
12341 if (!soff) {
12342 return(1);
12343 }
12344 if (n) {
12345 if (gvp == (char*)G__PVOID) {
12346 delete[] (TRecTofTrack*) soff;
12347 } else {
12348 G__setgvp((long) G__PVOID);
12349 for (int i = n - 1; i >= 0; --i) {
12350 ((TRecTofTrack*) (soff+(sizeof(TRecTofTrack)*i)))->~G__TTRecTofTrack();
12351 }
12352 G__setgvp((long)gvp);
12353 }
12354 } else {
12355 if (gvp == (char*)G__PVOID) {
12356 delete (TRecTofTrack*) soff;
12357 } else {
12358 G__setgvp((long) G__PVOID);
12359 ((TRecTofTrack*) (soff))->~G__TTRecTofTrack();
12360 G__setgvp((long)gvp);
12361 }
12362 }
12363 G__setnull(result7);
12364 return(1 || funcname || hash || result7 || libp) ;
12365}
12366
12367// automatic assignment operator
12368static int G__RootEventData_rootcint_211_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12369{
12370 TRecTofTrack* dest = (TRecTofTrack*) G__getstructoffset();
12371 *dest = *(TRecTofTrack*) libp->para[0].ref;
12372 const TRecTofTrack& obj = *dest;
12373 result7->ref = (long) (&obj);
12374 result7->obj.i = (long) (&obj);
12375 return(1 || funcname || hash || result7 || libp) ;
12376}
12377
12378
12379/* TRecEmcHit */
12380static int G__RootEventData_rootcint_212_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12381{
12382 TRecEmcHit* p = NULL;
12383 char* gvp = (char*) G__getgvp();
12384 int n = G__getaryconstruct();
12385 if (n) {
12386 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12387 p = new TRecEmcHit[n];
12388 } else {
12389 p = new((void*) gvp) TRecEmcHit[n];
12390 }
12391 } else {
12392 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12393 p = new TRecEmcHit;
12394 } else {
12395 p = new((void*) gvp) TRecEmcHit;
12396 }
12397 }
12398 result7->obj.i = (long) p;
12399 result7->ref = (long) p;
12400 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
12401 return(1 || funcname || hash || result7 || libp) ;
12402}
12403
12404static int G__RootEventData_rootcint_212_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12405{
12406 G__letint(result7, 105, (long) ((const TRecEmcHit*) G__getstructoffset())->cellId());
12407 return(1 || funcname || hash || result7 || libp) ;
12408}
12409
12410static int G__RootEventData_rootcint_212_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12411{
12412 G__letdouble(result7, 100, (double) ((const TRecEmcHit*) G__getstructoffset())->energy());
12413 return(1 || funcname || hash || result7 || libp) ;
12414}
12415
12416static int G__RootEventData_rootcint_212_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12417{
12418 G__letdouble(result7, 100, (double) ((const TRecEmcHit*) G__getstructoffset())->time());
12419 return(1 || funcname || hash || result7 || libp) ;
12420}
12421
12422static int G__RootEventData_rootcint_212_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12423{
12424 ((TRecEmcHit*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
12425 G__setnull(result7);
12426 return(1 || funcname || hash || result7 || libp) ;
12427}
12428
12429static int G__RootEventData_rootcint_212_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12430{
12431 ((TRecEmcHit*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
12432 G__setnull(result7);
12433 return(1 || funcname || hash || result7 || libp) ;
12434}
12435
12436static int G__RootEventData_rootcint_212_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12437{
12438 ((TRecEmcHit*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
12439 G__setnull(result7);
12440 return(1 || funcname || hash || result7 || libp) ;
12441}
12442
12443static int G__RootEventData_rootcint_212_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12444{
12445 G__letint(result7, 85, (long) TRecEmcHit::Class());
12446 return(1 || funcname || hash || result7 || libp) ;
12447}
12448
12449static int G__RootEventData_rootcint_212_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12450{
12451 G__letint(result7, 67, (long) TRecEmcHit::Class_Name());
12452 return(1 || funcname || hash || result7 || libp) ;
12453}
12454
12455static int G__RootEventData_rootcint_212_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12456{
12457 G__letint(result7, 115, (long) TRecEmcHit::Class_Version());
12458 return(1 || funcname || hash || result7 || libp) ;
12459}
12460
12461static int G__RootEventData_rootcint_212_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12462{
12463 TRecEmcHit::Dictionary();
12464 G__setnull(result7);
12465 return(1 || funcname || hash || result7 || libp) ;
12466}
12467
12468static int G__RootEventData_rootcint_212_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12469{
12470 ((TRecEmcHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12471 G__setnull(result7);
12472 return(1 || funcname || hash || result7 || libp) ;
12473}
12474
12475static int G__RootEventData_rootcint_212_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12476{
12477 G__letint(result7, 67, (long) TRecEmcHit::DeclFileName());
12478 return(1 || funcname || hash || result7 || libp) ;
12479}
12480
12481static int G__RootEventData_rootcint_212_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12482{
12483 G__letint(result7, 105, (long) TRecEmcHit::ImplFileLine());
12484 return(1 || funcname || hash || result7 || libp) ;
12485}
12486
12487static int G__RootEventData_rootcint_212_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12488{
12489 G__letint(result7, 67, (long) TRecEmcHit::ImplFileName());
12490 return(1 || funcname || hash || result7 || libp) ;
12491}
12492
12493static int G__RootEventData_rootcint_212_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12494{
12495 G__letint(result7, 105, (long) TRecEmcHit::DeclFileLine());
12496 return(1 || funcname || hash || result7 || libp) ;
12497}
12498
12499// automatic copy constructor
12500static int G__RootEventData_rootcint_212_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12501
12502{
12503 TRecEmcHit* p;
12504 void* tmp = (void*) G__int(libp->para[0]);
12505 p = new TRecEmcHit(*(TRecEmcHit*) tmp);
12506 result7->obj.i = (long) p;
12507 result7->ref = (long) p;
12508 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
12509 return(1 || funcname || hash || result7 || libp) ;
12510}
12511
12512// automatic destructor
12513typedef TRecEmcHit G__TTRecEmcHit;
12514static int G__RootEventData_rootcint_212_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12515{
12516 char* gvp = (char*) G__getgvp();
12517 long soff = G__getstructoffset();
12518 int n = G__getaryconstruct();
12519 //
12520 //has_a_delete: 1
12521 //has_own_delete1arg: 0
12522 //has_own_delete2arg: 0
12523 //
12524 if (!soff) {
12525 return(1);
12526 }
12527 if (n) {
12528 if (gvp == (char*)G__PVOID) {
12529 delete[] (TRecEmcHit*) soff;
12530 } else {
12531 G__setgvp((long) G__PVOID);
12532 for (int i = n - 1; i >= 0; --i) {
12533 ((TRecEmcHit*) (soff+(sizeof(TRecEmcHit)*i)))->~G__TTRecEmcHit();
12534 }
12535 G__setgvp((long)gvp);
12536 }
12537 } else {
12538 if (gvp == (char*)G__PVOID) {
12539 delete (TRecEmcHit*) soff;
12540 } else {
12541 G__setgvp((long) G__PVOID);
12542 ((TRecEmcHit*) (soff))->~G__TTRecEmcHit();
12543 G__setgvp((long)gvp);
12544 }
12545 }
12546 G__setnull(result7);
12547 return(1 || funcname || hash || result7 || libp) ;
12548}
12549
12550// automatic assignment operator
12551static int G__RootEventData_rootcint_212_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12552{
12553 TRecEmcHit* dest = (TRecEmcHit*) G__getstructoffset();
12554 *dest = *(TRecEmcHit*) libp->para[0].ref;
12555 const TRecEmcHit& obj = *dest;
12556 result7->ref = (long) (&obj);
12557 result7->obj.i = (long) (&obj);
12558 return(1 || funcname || hash || result7 || libp) ;
12559}
12560
12561
12562/* TRecEmcCluster */
12563static int G__RootEventData_rootcint_213_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12564{
12565 TRecEmcCluster* p = NULL;
12566 char* gvp = (char*) G__getgvp();
12567 int n = G__getaryconstruct();
12568 if (n) {
12569 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12570 p = new TRecEmcCluster[n];
12571 } else {
12572 p = new((void*) gvp) TRecEmcCluster[n];
12573 }
12574 } else {
12575 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12576 p = new TRecEmcCluster;
12577 } else {
12578 p = new((void*) gvp) TRecEmcCluster;
12579 }
12580 }
12581 result7->obj.i = (long) p;
12582 result7->ref = (long) p;
12583 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
12584 return(1 || funcname || hash || result7 || libp) ;
12585}
12586
12587static int G__RootEventData_rootcint_213_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12588{
12589 G__letint(result7, 105, (long) ((const TRecEmcCluster*) G__getstructoffset())->clusterId());
12590 return(1 || funcname || hash || result7 || libp) ;
12591}
12592
12593static int G__RootEventData_rootcint_213_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12594{
12595 {
12596 const vector<Int_t>* pobj;
12597 const vector<Int_t> xobj = ((const TRecEmcCluster*) G__getstructoffset())->vecHits();
12598 pobj = new vector<Int_t>(xobj);
12599 result7->obj.i = (long) ((void*) pobj);
12600 result7->ref = result7->obj.i;
12601 G__store_tempobject(*result7);
12602 }
12603 return(1 || funcname || hash || result7 || libp) ;
12604}
12605
12606static int G__RootEventData_rootcint_213_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12607{
12608 {
12609 const vector<Int_t>* pobj;
12610 const vector<Int_t> xobj = ((const TRecEmcCluster*) G__getstructoffset())->vecSeeds();
12611 pobj = new vector<Int_t>(xobj);
12612 result7->obj.i = (long) ((void*) pobj);
12613 result7->ref = result7->obj.i;
12614 G__store_tempobject(*result7);
12615 }
12616 return(1 || funcname || hash || result7 || libp) ;
12617}
12618
12619static int G__RootEventData_rootcint_213_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12620{
12621 {
12622 const vector<Int_t>* pobj;
12623 const vector<Int_t> xobj = ((const TRecEmcCluster*) G__getstructoffset())->vecShowers();
12624 pobj = new vector<Int_t>(xobj);
12625 result7->obj.i = (long) ((void*) pobj);
12626 result7->ref = result7->obj.i;
12627 G__store_tempobject(*result7);
12628 }
12629 return(1 || funcname || hash || result7 || libp) ;
12630}
12631
12632static int G__RootEventData_rootcint_213_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12633{
12634 ((TRecEmcCluster*) G__getstructoffset())->setClusterId((const Int_t) G__int(libp->para[0]));
12635 G__setnull(result7);
12636 return(1 || funcname || hash || result7 || libp) ;
12637}
12638
12639static int G__RootEventData_rootcint_213_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12640{
12641 ((TRecEmcCluster*) G__getstructoffset())->setVecHits(*(vector<Int_t>*) libp->para[0].ref);
12642 G__setnull(result7);
12643 return(1 || funcname || hash || result7 || libp) ;
12644}
12645
12646static int G__RootEventData_rootcint_213_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12647{
12648 ((TRecEmcCluster*) G__getstructoffset())->setVecSeeds(*(vector<Int_t>*) libp->para[0].ref);
12649 G__setnull(result7);
12650 return(1 || funcname || hash || result7 || libp) ;
12651}
12652
12653static int G__RootEventData_rootcint_213_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12654{
12655 ((TRecEmcCluster*) G__getstructoffset())->setVecShowers(*(vector<Int_t>*) libp->para[0].ref);
12656 G__setnull(result7);
12657 return(1 || funcname || hash || result7 || libp) ;
12658}
12659
12660static int G__RootEventData_rootcint_213_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12661{
12662 G__letint(result7, 85, (long) TRecEmcCluster::Class());
12663 return(1 || funcname || hash || result7 || libp) ;
12664}
12665
12666static int G__RootEventData_rootcint_213_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12667{
12668 G__letint(result7, 67, (long) TRecEmcCluster::Class_Name());
12669 return(1 || funcname || hash || result7 || libp) ;
12670}
12671
12672static int G__RootEventData_rootcint_213_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12673{
12674 G__letint(result7, 115, (long) TRecEmcCluster::Class_Version());
12675 return(1 || funcname || hash || result7 || libp) ;
12676}
12677
12678static int G__RootEventData_rootcint_213_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12679{
12680 TRecEmcCluster::Dictionary();
12681 G__setnull(result7);
12682 return(1 || funcname || hash || result7 || libp) ;
12683}
12684
12685static int G__RootEventData_rootcint_213_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12686{
12687 ((TRecEmcCluster*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12688 G__setnull(result7);
12689 return(1 || funcname || hash || result7 || libp) ;
12690}
12691
12692static int G__RootEventData_rootcint_213_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12693{
12694 G__letint(result7, 67, (long) TRecEmcCluster::DeclFileName());
12695 return(1 || funcname || hash || result7 || libp) ;
12696}
12697
12698static int G__RootEventData_rootcint_213_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12699{
12700 G__letint(result7, 105, (long) TRecEmcCluster::ImplFileLine());
12701 return(1 || funcname || hash || result7 || libp) ;
12702}
12703
12704static int G__RootEventData_rootcint_213_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12705{
12706 G__letint(result7, 67, (long) TRecEmcCluster::ImplFileName());
12707 return(1 || funcname || hash || result7 || libp) ;
12708}
12709
12710static int G__RootEventData_rootcint_213_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12711{
12712 G__letint(result7, 105, (long) TRecEmcCluster::DeclFileLine());
12713 return(1 || funcname || hash || result7 || libp) ;
12714}
12715
12716// automatic copy constructor
12717static int G__RootEventData_rootcint_213_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12718
12719{
12720 TRecEmcCluster* p;
12721 void* tmp = (void*) G__int(libp->para[0]);
12722 p = new TRecEmcCluster(*(TRecEmcCluster*) tmp);
12723 result7->obj.i = (long) p;
12724 result7->ref = (long) p;
12725 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
12726 return(1 || funcname || hash || result7 || libp) ;
12727}
12728
12729// automatic destructor
12730typedef TRecEmcCluster G__TTRecEmcCluster;
12731static int G__RootEventData_rootcint_213_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12732{
12733 char* gvp = (char*) G__getgvp();
12734 long soff = G__getstructoffset();
12735 int n = G__getaryconstruct();
12736 //
12737 //has_a_delete: 1
12738 //has_own_delete1arg: 0
12739 //has_own_delete2arg: 0
12740 //
12741 if (!soff) {
12742 return(1);
12743 }
12744 if (n) {
12745 if (gvp == (char*)G__PVOID) {
12746 delete[] (TRecEmcCluster*) soff;
12747 } else {
12748 G__setgvp((long) G__PVOID);
12749 for (int i = n - 1; i >= 0; --i) {
12750 ((TRecEmcCluster*) (soff+(sizeof(TRecEmcCluster)*i)))->~G__TTRecEmcCluster();
12751 }
12752 G__setgvp((long)gvp);
12753 }
12754 } else {
12755 if (gvp == (char*)G__PVOID) {
12756 delete (TRecEmcCluster*) soff;
12757 } else {
12758 G__setgvp((long) G__PVOID);
12759 ((TRecEmcCluster*) (soff))->~G__TTRecEmcCluster();
12760 G__setgvp((long)gvp);
12761 }
12762 }
12763 G__setnull(result7);
12764 return(1 || funcname || hash || result7 || libp) ;
12765}
12766
12767// automatic assignment operator
12768static int G__RootEventData_rootcint_213_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12769{
12770 TRecEmcCluster* dest = (TRecEmcCluster*) G__getstructoffset();
12771 *dest = *(TRecEmcCluster*) libp->para[0].ref;
12772 const TRecEmcCluster& obj = *dest;
12773 result7->ref = (long) (&obj);
12774 result7->obj.i = (long) (&obj);
12775 return(1 || funcname || hash || result7 || libp) ;
12776}
12777
12778
12779/* TRecEmcShower */
12780static int G__RootEventData_rootcint_449_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12781{
12782 TRecEmcShower* p = NULL;
12783 char* gvp = (char*) G__getgvp();
12784 int n = G__getaryconstruct();
12785 if (n) {
12786 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12787 p = new TRecEmcShower[n];
12788 } else {
12789 p = new((void*) gvp) TRecEmcShower[n];
12790 }
12791 } else {
12792 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12793 p = new TRecEmcShower;
12794 } else {
12795 p = new((void*) gvp) TRecEmcShower;
12796 }
12797 }
12798 result7->obj.i = (long) p;
12799 result7->ref = (long) p;
12800 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
12801 return(1 || funcname || hash || result7 || libp) ;
12802}
12803
12804static int G__RootEventData_rootcint_449_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12805{
12806 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->trackId());
12807 return(1 || funcname || hash || result7 || libp) ;
12808}
12809
12810static int G__RootEventData_rootcint_449_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12811{
12812 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->numHits());
12813 return(1 || funcname || hash || result7 || libp) ;
12814}
12815
12816static int G__RootEventData_rootcint_449_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12817{
12818 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->status());
12819 return(1 || funcname || hash || result7 || libp) ;
12820}
12821
12822static int G__RootEventData_rootcint_449_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12823{
12824 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->cellId());
12825 return(1 || funcname || hash || result7 || libp) ;
12826}
12827
12828static int G__RootEventData_rootcint_449_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12829{
12830 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->module());
12831 return(1 || funcname || hash || result7 || libp) ;
12832}
12833
12834static int G__RootEventData_rootcint_449_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12835{
12836 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->x());
12837 return(1 || funcname || hash || result7 || libp) ;
12838}
12839
12840static int G__RootEventData_rootcint_449_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12841{
12842 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->y());
12843 return(1 || funcname || hash || result7 || libp) ;
12844}
12845
12846static int G__RootEventData_rootcint_449_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12847{
12848 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->z());
12849 return(1 || funcname || hash || result7 || libp) ;
12850}
12851
12852static int G__RootEventData_rootcint_449_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12853{
12854 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->theta());
12855 return(1 || funcname || hash || result7 || libp) ;
12856}
12857
12858static int G__RootEventData_rootcint_449_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12859{
12860 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dtheta());
12861 return(1 || funcname || hash || result7 || libp) ;
12862}
12863
12864static int G__RootEventData_rootcint_449_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12865{
12866 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->phi());
12867 return(1 || funcname || hash || result7 || libp) ;
12868}
12869
12870static int G__RootEventData_rootcint_449_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12871{
12872 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dphi());
12873 return(1 || funcname || hash || result7 || libp) ;
12874}
12875
12876static int G__RootEventData_rootcint_449_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12877{
12878 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->energy());
12879 return(1 || funcname || hash || result7 || libp) ;
12880}
12881
12882static int G__RootEventData_rootcint_449_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12883{
12884 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dE());
12885 return(1 || funcname || hash || result7 || libp) ;
12886}
12887
12888static int G__RootEventData_rootcint_449_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12889{
12890 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eSeed());
12891 return(1 || funcname || hash || result7 || libp) ;
12892}
12893
12894static int G__RootEventData_rootcint_449_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12895{
12896 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->e3x3());
12897 return(1 || funcname || hash || result7 || libp) ;
12898}
12899
12900static int G__RootEventData_rootcint_449_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12901{
12902 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->e5x5());
12903 return(1 || funcname || hash || result7 || libp) ;
12904}
12905
12906static int G__RootEventData_rootcint_449_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12907{
12908 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eAll());
12909 return(1 || funcname || hash || result7 || libp) ;
12910}
12911
12912static int G__RootEventData_rootcint_449_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12913{
12914 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eLepton());
12915 return(1 || funcname || hash || result7 || libp) ;
12916}
12917
12918static int G__RootEventData_rootcint_449_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12919{
12920 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->time());
12921 return(1 || funcname || hash || result7 || libp) ;
12922}
12923
12924static int G__RootEventData_rootcint_449_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12925{
12926 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->secondMoment());
12927 return(1 || funcname || hash || result7 || libp) ;
12928}
12929
12930static int G__RootEventData_rootcint_449_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12931{
12932 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->latMoment());
12933 return(1 || funcname || hash || result7 || libp) ;
12934}
12935
12936static int G__RootEventData_rootcint_449_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12937{
12938 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->a20Moment());
12939 return(1 || funcname || hash || result7 || libp) ;
12940}
12941
12942static int G__RootEventData_rootcint_449_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12943{
12944 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->a42Moment());
12945 return(1 || funcname || hash || result7 || libp) ;
12946}
12947
12948static int G__RootEventData_rootcint_449_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12949{
12950 G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
12951 return(1 || funcname || hash || result7 || libp) ;
12952}
12953
12954static int G__RootEventData_rootcint_449_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12955{
12956 {
12957 const map<Int_t,Double_t>* pobj;
12958 const map<Int_t,Double_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellIdMap();
12959 pobj = new map<Int_t,Double_t>(xobj);
12960 result7->obj.i = (long) ((void*) pobj);
12961 result7->ref = result7->obj.i;
12962 G__store_tempobject(*result7);
12963 }
12964 return(1 || funcname || hash || result7 || libp) ;
12965}
12966
12967static int G__RootEventData_rootcint_449_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12968{
12969 {
12970 const vector<Int_t>* pobj;
12971 const vector<Int_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellId3x3();
12972 pobj = new vector<Int_t>(xobj);
12973 result7->obj.i = (long) ((void*) pobj);
12974 result7->ref = result7->obj.i;
12975 G__store_tempobject(*result7);
12976 }
12977 return(1 || funcname || hash || result7 || libp) ;
12978}
12979
12980static int G__RootEventData_rootcint_449_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12981{
12982 {
12983 const vector<Int_t>* pobj;
12984 const vector<Int_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellId5x5();
12985 pobj = new vector<Int_t>(xobj);
12986 result7->obj.i = (long) ((void*) pobj);
12987 result7->ref = result7->obj.i;
12988 G__store_tempobject(*result7);
12989 }
12990 return(1 || funcname || hash || result7 || libp) ;
12991}
12992
12993static int G__RootEventData_rootcint_449_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12994{
12995 G__letint(result7, 105, (long) ((const TRecEmcShower*) G__getstructoffset())->clusterId());
12996 return(1 || funcname || hash || result7 || libp) ;
12997}
12998
12999static int G__RootEventData_rootcint_449_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13000{
13001 ((TRecEmcShower*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
13002 G__setnull(result7);
13003 return(1 || funcname || hash || result7 || libp) ;
13004}
13005
13006static int G__RootEventData_rootcint_449_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13007{
13008 ((TRecEmcShower*) G__getstructoffset())->setNumHits((const Int_t) G__int(libp->para[0]));
13009 G__setnull(result7);
13010 return(1 || funcname || hash || result7 || libp) ;
13011}
13012
13013static int G__RootEventData_rootcint_449_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13014{
13015 ((TRecEmcShower*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
13016 G__setnull(result7);
13017 return(1 || funcname || hash || result7 || libp) ;
13018}
13019
13020static int G__RootEventData_rootcint_449_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13021{
13022 ((TRecEmcShower*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
13023 G__setnull(result7);
13024 return(1 || funcname || hash || result7 || libp) ;
13025}
13026
13027static int G__RootEventData_rootcint_449_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13028{
13029 ((TRecEmcShower*) G__getstructoffset())->setModule((const Int_t) G__int(libp->para[0]));
13030 G__setnull(result7);
13031 return(1 || funcname || hash || result7 || libp) ;
13032}
13033
13034static int G__RootEventData_rootcint_449_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13035{
13036 ((TRecEmcShower*) G__getstructoffset())->setX((const Double_t) G__double(libp->para[0]));
13037 G__setnull(result7);
13038 return(1 || funcname || hash || result7 || libp) ;
13039}
13040
13041static int G__RootEventData_rootcint_449_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13042{
13043 ((TRecEmcShower*) G__getstructoffset())->setY((const Double_t) G__double(libp->para[0]));
13044 G__setnull(result7);
13045 return(1 || funcname || hash || result7 || libp) ;
13046}
13047
13048static int G__RootEventData_rootcint_449_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13049{
13050 ((TRecEmcShower*) G__getstructoffset())->setZ((const Double_t) G__double(libp->para[0]));
13051 G__setnull(result7);
13052 return(1 || funcname || hash || result7 || libp) ;
13053}
13054
13055static int G__RootEventData_rootcint_449_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13056{
13057 ((TRecEmcShower*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
13058 G__setnull(result7);
13059 return(1 || funcname || hash || result7 || libp) ;
13060}
13061
13062static int G__RootEventData_rootcint_449_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13063{
13064 ((TRecEmcShower*) G__getstructoffset())->setDE((const Double_t) G__double(libp->para[0]));
13065 G__setnull(result7);
13066 return(1 || funcname || hash || result7 || libp) ;
13067}
13068
13069static int G__RootEventData_rootcint_449_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13070{
13071 ((TRecEmcShower*) G__getstructoffset())->setTheta((const Double_t) G__double(libp->para[0]));
13072 G__setnull(result7);
13073 return(1 || funcname || hash || result7 || libp) ;
13074}
13075
13076static int G__RootEventData_rootcint_449_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13077{
13078 ((TRecEmcShower*) G__getstructoffset())->setDtheta((const Double_t) G__double(libp->para[0]));
13079 G__setnull(result7);
13080 return(1 || funcname || hash || result7 || libp) ;
13081}
13082
13083static int G__RootEventData_rootcint_449_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13084{
13085 ((TRecEmcShower*) G__getstructoffset())->setPhi((const Double_t) G__double(libp->para[0]));
13086 G__setnull(result7);
13087 return(1 || funcname || hash || result7 || libp) ;
13088}
13089
13090static int G__RootEventData_rootcint_449_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13091{
13092 ((TRecEmcShower*) G__getstructoffset())->setDphi((const Double_t) G__double(libp->para[0]));
13093 G__setnull(result7);
13094 return(1 || funcname || hash || result7 || libp) ;
13095}
13096
13097static int G__RootEventData_rootcint_449_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13098{
13099 ((TRecEmcShower*) G__getstructoffset())->setESeed((const Double_t) G__double(libp->para[0]));
13100 G__setnull(result7);
13101 return(1 || funcname || hash || result7 || libp) ;
13102}
13103
13104static int G__RootEventData_rootcint_449_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13105{
13106 ((TRecEmcShower*) G__getstructoffset())->setE3x3((const Double_t) G__double(libp->para[0]));
13107 G__setnull(result7);
13108 return(1 || funcname || hash || result7 || libp) ;
13109}
13110
13111static int G__RootEventData_rootcint_449_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13112{
13113 ((TRecEmcShower*) G__getstructoffset())->setE5x5((const Double_t) G__double(libp->para[0]));
13114 G__setnull(result7);
13115 return(1 || funcname || hash || result7 || libp) ;
13116}
13117
13118static int G__RootEventData_rootcint_449_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13119{
13120 ((TRecEmcShower*) G__getstructoffset())->setEAll((const Double_t) G__double(libp->para[0]));
13121 G__setnull(result7);
13122 return(1 || funcname || hash || result7 || libp) ;
13123}
13124
13125static int G__RootEventData_rootcint_449_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13126{
13127 ((TRecEmcShower*) G__getstructoffset())->setELepton((const Double_t) G__double(libp->para[0]));
13128 G__setnull(result7);
13129 return(1 || funcname || hash || result7 || libp) ;
13130}
13131
13132static int G__RootEventData_rootcint_449_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13133{
13134 ((TRecEmcShower*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
13135 G__setnull(result7);
13136 return(1 || funcname || hash || result7 || libp) ;
13137}
13138
13139static int G__RootEventData_rootcint_449_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13140{
13141 ((TRecEmcShower*) G__getstructoffset())->setSecondMoment((const Double_t) G__double(libp->para[0]));
13142 G__setnull(result7);
13143 return(1 || funcname || hash || result7 || libp) ;
13144}
13145
13146static int G__RootEventData_rootcint_449_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13147{
13148 ((TRecEmcShower*) G__getstructoffset())->setLatMoment((const Double_t) G__double(libp->para[0]));
13149 G__setnull(result7);
13150 return(1 || funcname || hash || result7 || libp) ;
13151}
13152
13153static int G__RootEventData_rootcint_449_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13154{
13155 ((TRecEmcShower*) G__getstructoffset())->setA20Moment((const Double_t) G__double(libp->para[0]));
13156 G__setnull(result7);
13157 return(1 || funcname || hash || result7 || libp) ;
13158}
13159
13160static int G__RootEventData_rootcint_449_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13161{
13162 ((TRecEmcShower*) G__getstructoffset())->setA42Moment((const Double_t) G__double(libp->para[0]));
13163 G__setnull(result7);
13164 return(1 || funcname || hash || result7 || libp) ;
13165}
13166
13167static int G__RootEventData_rootcint_449_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13168{
13169 ((TRecEmcShower*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
13170 G__setnull(result7);
13171 return(1 || funcname || hash || result7 || libp) ;
13172}
13173
13174static int G__RootEventData_rootcint_449_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13175{
13176 ((TRecEmcShower*) G__getstructoffset())->setCellIdMap(*(map<Int_t,Double_t>*) libp->para[0].ref);
13177 G__setnull(result7);
13178 return(1 || funcname || hash || result7 || libp) ;
13179}
13180
13181static int G__RootEventData_rootcint_449_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13182{
13183 ((TRecEmcShower*) G__getstructoffset())->setCellId3x3(*(vector<Int_t>*) libp->para[0].ref);
13184 G__setnull(result7);
13185 return(1 || funcname || hash || result7 || libp) ;
13186}
13187
13188static int G__RootEventData_rootcint_449_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13189{
13190 ((TRecEmcShower*) G__getstructoffset())->setCellId5x5(*(vector<Int_t>*) libp->para[0].ref);
13191 G__setnull(result7);
13192 return(1 || funcname || hash || result7 || libp) ;
13193}
13194
13195static int G__RootEventData_rootcint_449_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13196{
13197 ((TRecEmcShower*) G__getstructoffset())->setClusterId((const Int_t) G__int(libp->para[0]));
13198 G__setnull(result7);
13199 return(1 || funcname || hash || result7 || libp) ;
13200}
13201
13202static int G__RootEventData_rootcint_449_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13203{
13204 ((TRecEmcShower*) G__getstructoffset())->setTRecEmcShower((TRecEmcShower*) G__int(libp->para[0]));
13205 G__setnull(result7);
13206 return(1 || funcname || hash || result7 || libp) ;
13207}
13208
13209static int G__RootEventData_rootcint_449_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13210{
13211 G__letint(result7, 85, (long) TRecEmcShower::Class());
13212 return(1 || funcname || hash || result7 || libp) ;
13213}
13214
13215static int G__RootEventData_rootcint_449_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13216{
13217 G__letint(result7, 67, (long) TRecEmcShower::Class_Name());
13218 return(1 || funcname || hash || result7 || libp) ;
13219}
13220
13221static int G__RootEventData_rootcint_449_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13222{
13223 G__letint(result7, 115, (long) TRecEmcShower::Class_Version());
13224 return(1 || funcname || hash || result7 || libp) ;
13225}
13226
13227static int G__RootEventData_rootcint_449_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13228{
13229 TRecEmcShower::Dictionary();
13230 G__setnull(result7);
13231 return(1 || funcname || hash || result7 || libp) ;
13232}
13233
13234static int G__RootEventData_rootcint_449_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13235{
13236 ((TRecEmcShower*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13237 G__setnull(result7);
13238 return(1 || funcname || hash || result7 || libp) ;
13239}
13240
13241static int G__RootEventData_rootcint_449_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13242{
13243 G__letint(result7, 67, (long) TRecEmcShower::DeclFileName());
13244 return(1 || funcname || hash || result7 || libp) ;
13245}
13246
13247static int G__RootEventData_rootcint_449_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13248{
13249 G__letint(result7, 105, (long) TRecEmcShower::ImplFileLine());
13250 return(1 || funcname || hash || result7 || libp) ;
13251}
13252
13253static int G__RootEventData_rootcint_449_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13254{
13255 G__letint(result7, 67, (long) TRecEmcShower::ImplFileName());
13256 return(1 || funcname || hash || result7 || libp) ;
13257}
13258
13259static int G__RootEventData_rootcint_449_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13260{
13261 G__letint(result7, 105, (long) TRecEmcShower::DeclFileLine());
13262 return(1 || funcname || hash || result7 || libp) ;
13263}
13264
13265// automatic copy constructor
13266static int G__RootEventData_rootcint_449_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13267
13268{
13269 TRecEmcShower* p;
13270 void* tmp = (void*) G__int(libp->para[0]);
13271 p = new TRecEmcShower(*(TRecEmcShower*) tmp);
13272 result7->obj.i = (long) p;
13273 result7->ref = (long) p;
13274 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
13275 return(1 || funcname || hash || result7 || libp) ;
13276}
13277
13278// automatic destructor
13279typedef TRecEmcShower G__TTRecEmcShower;
13280static int G__RootEventData_rootcint_449_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13281{
13282 char* gvp = (char*) G__getgvp();
13283 long soff = G__getstructoffset();
13284 int n = G__getaryconstruct();
13285 //
13286 //has_a_delete: 1
13287 //has_own_delete1arg: 0
13288 //has_own_delete2arg: 0
13289 //
13290 if (!soff) {
13291 return(1);
13292 }
13293 if (n) {
13294 if (gvp == (char*)G__PVOID) {
13295 delete[] (TRecEmcShower*) soff;
13296 } else {
13297 G__setgvp((long) G__PVOID);
13298 for (int i = n - 1; i >= 0; --i) {
13299 ((TRecEmcShower*) (soff+(sizeof(TRecEmcShower)*i)))->~G__TTRecEmcShower();
13300 }
13301 G__setgvp((long)gvp);
13302 }
13303 } else {
13304 if (gvp == (char*)G__PVOID) {
13305 delete (TRecEmcShower*) soff;
13306 } else {
13307 G__setgvp((long) G__PVOID);
13308 ((TRecEmcShower*) (soff))->~G__TTRecEmcShower();
13309 G__setgvp((long)gvp);
13310 }
13311 }
13312 G__setnull(result7);
13313 return(1 || funcname || hash || result7 || libp) ;
13314}
13315
13316// automatic assignment operator
13317static int G__RootEventData_rootcint_449_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13318{
13319 TRecEmcShower* dest = (TRecEmcShower*) G__getstructoffset();
13320 *dest = *(TRecEmcShower*) libp->para[0].ref;
13321 const TRecEmcShower& obj = *dest;
13322 result7->ref = (long) (&obj);
13323 result7->obj.i = (long) (&obj);
13324 return(1 || funcname || hash || result7 || libp) ;
13325}
13326
13327
13328/* TRecMucTrack */
13329static int G__RootEventData_rootcint_457_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13330{
13331 TRecMucTrack* p = NULL;
13332 char* gvp = (char*) G__getgvp();
13333 int n = G__getaryconstruct();
13334 if (n) {
13335 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13336 p = new TRecMucTrack[n];
13337 } else {
13338 p = new((void*) gvp) TRecMucTrack[n];
13339 }
13340 } else {
13341 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13342 p = new TRecMucTrack;
13343 } else {
13344 p = new((void*) gvp) TRecMucTrack;
13345 }
13346 }
13347 result7->obj.i = (long) p;
13348 result7->ref = (long) p;
13349 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
13350 return(1 || funcname || hash || result7 || libp) ;
13351}
13352
13353static int G__RootEventData_rootcint_457_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13354{
13355 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->trackId());
13356 return(1 || funcname || hash || result7 || libp) ;
13357}
13358
13359static int G__RootEventData_rootcint_457_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13360{
13361 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->id());
13362 return(1 || funcname || hash || result7 || libp) ;
13363}
13364
13365static int G__RootEventData_rootcint_457_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13366{
13367 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->status());
13368 return(1 || funcname || hash || result7 || libp) ;
13369}
13370
13371static int G__RootEventData_rootcint_457_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13372{
13373 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->type());
13374 return(1 || funcname || hash || result7 || libp) ;
13375}
13376
13377static int G__RootEventData_rootcint_457_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13378{
13379 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->startPart());
13380 return(1 || funcname || hash || result7 || libp) ;
13381}
13382
13383static int G__RootEventData_rootcint_457_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13384{
13385 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->endPart());
13386 return(1 || funcname || hash || result7 || libp) ;
13387}
13388
13389static int G__RootEventData_rootcint_457_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13390{
13391 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->brLastLayer());
13392 return(1 || funcname || hash || result7 || libp) ;
13393}
13394
13395static int G__RootEventData_rootcint_457_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13396{
13397 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->ecLastLayer());
13398 return(1 || funcname || hash || result7 || libp) ;
13399}
13400
13401static int G__RootEventData_rootcint_457_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13402{
13403 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->numHits());
13404 return(1 || funcname || hash || result7 || libp) ;
13405}
13406
13407static int G__RootEventData_rootcint_457_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13408{
13409 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->numLayers());
13410 return(1 || funcname || hash || result7 || libp) ;
13411}
13412
13413static int G__RootEventData_rootcint_457_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13414{
13415 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->maxHitsInLayer());
13416 return(1 || funcname || hash || result7 || libp) ;
13417}
13418
13419static int G__RootEventData_rootcint_457_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13420{
13421 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->depth());
13422 return(1 || funcname || hash || result7 || libp) ;
13423}
13424
13425static int G__RootEventData_rootcint_457_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13426{
13427 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->chi2());
13428 return(1 || funcname || hash || result7 || libp) ;
13429}
13430
13431static int G__RootEventData_rootcint_457_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13432{
13433 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->dof());
13434 return(1 || funcname || hash || result7 || libp) ;
13435}
13436
13437static int G__RootEventData_rootcint_457_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13438{
13439 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->rms());
13440 return(1 || funcname || hash || result7 || libp) ;
13441}
13442
13443static int G__RootEventData_rootcint_457_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13444{
13445 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->distance());
13446 return(1 || funcname || hash || result7 || libp) ;
13447}
13448
13449static int G__RootEventData_rootcint_457_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13450{
13451 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->deltaPhi());
13452 return(1 || funcname || hash || result7 || libp) ;
13453}
13454
13455static int G__RootEventData_rootcint_457_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13456{
13457 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->xPos());
13458 return(1 || funcname || hash || result7 || libp) ;
13459}
13460
13461static int G__RootEventData_rootcint_457_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13462{
13463 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->yPos());
13464 return(1 || funcname || hash || result7 || libp) ;
13465}
13466
13467static int G__RootEventData_rootcint_457_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13468{
13469 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->zPos());
13470 return(1 || funcname || hash || result7 || libp) ;
13471}
13472
13473static int G__RootEventData_rootcint_457_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13474{
13475 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->xPosSigma());
13476 return(1 || funcname || hash || result7 || libp) ;
13477}
13478
13479static int G__RootEventData_rootcint_457_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13480{
13481 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->yPosSigma());
13482 return(1 || funcname || hash || result7 || libp) ;
13483}
13484
13485static int G__RootEventData_rootcint_457_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13486{
13487 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->zPosSigma());
13488 return(1 || funcname || hash || result7 || libp) ;
13489}
13490
13491static int G__RootEventData_rootcint_457_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13492{
13493 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->px());
13494 return(1 || funcname || hash || result7 || libp) ;
13495}
13496
13497static int G__RootEventData_rootcint_457_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13498{
13499 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->py());
13500 return(1 || funcname || hash || result7 || libp) ;
13501}
13502
13503static int G__RootEventData_rootcint_457_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13504{
13505 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->pz());
13506 return(1 || funcname || hash || result7 || libp) ;
13507}
13508
13509static int G__RootEventData_rootcint_457_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13510{
13511 {
13512 const vector<Int_t>* pobj;
13513 const vector<Int_t> xobj = ((const TRecMucTrack*) G__getstructoffset())->vecHits();
13514 pobj = new vector<Int_t>(xobj);
13515 result7->obj.i = (long) ((void*) pobj);
13516 result7->ref = result7->obj.i;
13517 G__store_tempobject(*result7);
13518 }
13519 return(1 || funcname || hash || result7 || libp) ;
13520}
13521
13522static int G__RootEventData_rootcint_457_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13523{
13524 {
13525 const vector<Int_t>* pobj;
13526 const vector<Int_t> xobj = ((const TRecMucTrack*) G__getstructoffset())->expHits();
13527 pobj = new vector<Int_t>(xobj);
13528 result7->obj.i = (long) ((void*) pobj);
13529 result7->ref = result7->obj.i;
13530 G__store_tempobject(*result7);
13531 }
13532 return(1 || funcname || hash || result7 || libp) ;
13533}
13534
13535static int G__RootEventData_rootcint_457_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13536{
13537 {
13538 const vector<Float_t>* pobj;
13539 const vector<Float_t> xobj = ((const TRecMucTrack*) G__getstructoffset())->distHits();
13540 pobj = new vector<Float_t>(xobj);
13541 result7->obj.i = (long) ((void*) pobj);
13542 result7->ref = result7->obj.i;
13543 G__store_tempobject(*result7);
13544 }
13545 return(1 || funcname || hash || result7 || libp) ;
13546}
13547
13548static int G__RootEventData_rootcint_457_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13549{
13550 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->kalRechi2());
13551 return(1 || funcname || hash || result7 || libp) ;
13552}
13553
13554static int G__RootEventData_rootcint_457_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13555{
13556 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->kaldof());
13557 return(1 || funcname || hash || result7 || libp) ;
13558}
13559
13560static int G__RootEventData_rootcint_457_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13561{
13562 G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->kaldepth());
13563 return(1 || funcname || hash || result7 || libp) ;
13564}
13565
13566static int G__RootEventData_rootcint_457_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13567{
13568 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->kalbrLastLayer());
13569 return(1 || funcname || hash || result7 || libp) ;
13570}
13571
13572static int G__RootEventData_rootcint_457_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13573{
13574 G__letint(result7, 105, (long) ((const TRecMucTrack*) G__getstructoffset())->kalecLastLayer());
13575 return(1 || funcname || hash || result7 || libp) ;
13576}
13577
13578static int G__RootEventData_rootcint_457_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13579{
13580 ((TRecMucTrack*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
13581 G__setnull(result7);
13582 return(1 || funcname || hash || result7 || libp) ;
13583}
13584
13585static int G__RootEventData_rootcint_457_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13586{
13587 ((TRecMucTrack*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
13588 G__setnull(result7);
13589 return(1 || funcname || hash || result7 || libp) ;
13590}
13591
13592static int G__RootEventData_rootcint_457_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13593{
13594 ((TRecMucTrack*) G__getstructoffset())->setStatus((Int_t) G__int(libp->para[0]));
13595 G__setnull(result7);
13596 return(1 || funcname || hash || result7 || libp) ;
13597}
13598
13599static int G__RootEventData_rootcint_457_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13600{
13601 ((TRecMucTrack*) G__getstructoffset())->setType((Int_t) G__int(libp->para[0]));
13602 G__setnull(result7);
13603 return(1 || funcname || hash || result7 || libp) ;
13604}
13605
13606static int G__RootEventData_rootcint_457_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13607{
13608 ((TRecMucTrack*) G__getstructoffset())->setStartPart((Int_t) G__int(libp->para[0]));
13609 G__setnull(result7);
13610 return(1 || funcname || hash || result7 || libp) ;
13611}
13612
13613static int G__RootEventData_rootcint_457_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13614{
13615 ((TRecMucTrack*) G__getstructoffset())->setEndPart((Int_t) G__int(libp->para[0]));
13616 G__setnull(result7);
13617 return(1 || funcname || hash || result7 || libp) ;
13618}
13619
13620static int G__RootEventData_rootcint_457_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13621{
13622 ((TRecMucTrack*) G__getstructoffset())->setBrLastLayer((Int_t) G__int(libp->para[0]));
13623 G__setnull(result7);
13624 return(1 || funcname || hash || result7 || libp) ;
13625}
13626
13627static int G__RootEventData_rootcint_457_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13628{
13629 ((TRecMucTrack*) G__getstructoffset())->setEcLastLayer((Int_t) G__int(libp->para[0]));
13630 G__setnull(result7);
13631 return(1 || funcname || hash || result7 || libp) ;
13632}
13633
13634static int G__RootEventData_rootcint_457_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13635{
13636 ((TRecMucTrack*) G__getstructoffset())->setNumHits((Int_t) G__int(libp->para[0]));
13637 G__setnull(result7);
13638 return(1 || funcname || hash || result7 || libp) ;
13639}
13640
13641static int G__RootEventData_rootcint_457_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13642{
13643 ((TRecMucTrack*) G__getstructoffset())->setNumLayers((Int_t) G__int(libp->para[0]));
13644 G__setnull(result7);
13645 return(1 || funcname || hash || result7 || libp) ;
13646}
13647
13648static int G__RootEventData_rootcint_457_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13649{
13650 ((TRecMucTrack*) G__getstructoffset())->setMaxHitsInLayer((Int_t) G__int(libp->para[0]));
13651 G__setnull(result7);
13652 return(1 || funcname || hash || result7 || libp) ;
13653}
13654
13655static int G__RootEventData_rootcint_457_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13656{
13657 ((TRecMucTrack*) G__getstructoffset())->setDepth((Double_t) G__double(libp->para[0]));
13658 G__setnull(result7);
13659 return(1 || funcname || hash || result7 || libp) ;
13660}
13661
13662static int G__RootEventData_rootcint_457_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13663{
13664 ((TRecMucTrack*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
13665 G__setnull(result7);
13666 return(1 || funcname || hash || result7 || libp) ;
13667}
13668
13669static int G__RootEventData_rootcint_457_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13670{
13671 ((TRecMucTrack*) G__getstructoffset())->setDof((Int_t) G__int(libp->para[0]));
13672 G__setnull(result7);
13673 return(1 || funcname || hash || result7 || libp) ;
13674}
13675
13676static int G__RootEventData_rootcint_457_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13677{
13678 ((TRecMucTrack*) G__getstructoffset())->setRms((Double_t) G__double(libp->para[0]));
13679 G__setnull(result7);
13680 return(1 || funcname || hash || result7 || libp) ;
13681}
13682
13683static int G__RootEventData_rootcint_457_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13684{
13685 ((TRecMucTrack*) G__getstructoffset())->setDistance((Double_t) G__double(libp->para[0]));
13686 G__setnull(result7);
13687 return(1 || funcname || hash || result7 || libp) ;
13688}
13689
13690static int G__RootEventData_rootcint_457_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13691{
13692 ((TRecMucTrack*) G__getstructoffset())->setDeltaPhi((Double_t) G__double(libp->para[0]));
13693 G__setnull(result7);
13694 return(1 || funcname || hash || result7 || libp) ;
13695}
13696
13697static int G__RootEventData_rootcint_457_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13698{
13699 ((TRecMucTrack*) G__getstructoffset())->setXPos((Double_t) G__double(libp->para[0]));
13700 G__setnull(result7);
13701 return(1 || funcname || hash || result7 || libp) ;
13702}
13703
13704static int G__RootEventData_rootcint_457_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13705{
13706 ((TRecMucTrack*) G__getstructoffset())->setYPos((Double_t) G__double(libp->para[0]));
13707 G__setnull(result7);
13708 return(1 || funcname || hash || result7 || libp) ;
13709}
13710
13711static int G__RootEventData_rootcint_457_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13712{
13713 ((TRecMucTrack*) G__getstructoffset())->setZPos((Double_t) G__double(libp->para[0]));
13714 G__setnull(result7);
13715 return(1 || funcname || hash || result7 || libp) ;
13716}
13717
13718static int G__RootEventData_rootcint_457_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13719{
13720 ((TRecMucTrack*) G__getstructoffset())->setXPosSigma((Double_t) G__double(libp->para[0]));
13721 G__setnull(result7);
13722 return(1 || funcname || hash || result7 || libp) ;
13723}
13724
13725static int G__RootEventData_rootcint_457_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13726{
13727 ((TRecMucTrack*) G__getstructoffset())->setYPosSigma((Double_t) G__double(libp->para[0]));
13728 G__setnull(result7);
13729 return(1 || funcname || hash || result7 || libp) ;
13730}
13731
13732static int G__RootEventData_rootcint_457_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13733{
13734 ((TRecMucTrack*) G__getstructoffset())->setZPosSigma((Double_t) G__double(libp->para[0]));
13735 G__setnull(result7);
13736 return(1 || funcname || hash || result7 || libp) ;
13737}
13738
13739static int G__RootEventData_rootcint_457_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13740{
13741 ((TRecMucTrack*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
13742 G__setnull(result7);
13743 return(1 || funcname || hash || result7 || libp) ;
13744}
13745
13746static int G__RootEventData_rootcint_457_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13747{
13748 ((TRecMucTrack*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
13749 G__setnull(result7);
13750 return(1 || funcname || hash || result7 || libp) ;
13751}
13752
13753static int G__RootEventData_rootcint_457_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13754{
13755 ((TRecMucTrack*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
13756 G__setnull(result7);
13757 return(1 || funcname || hash || result7 || libp) ;
13758}
13759
13760static int G__RootEventData_rootcint_457_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13761{
13762 ((TRecMucTrack*) G__getstructoffset())->setVecHits(*(vector<Int_t>*) libp->para[0].ref);
13763 G__setnull(result7);
13764 return(1 || funcname || hash || result7 || libp) ;
13765}
13766
13767static int G__RootEventData_rootcint_457_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13768{
13769 ((TRecMucTrack*) G__getstructoffset())->setExpHits(*(vector<Int_t>*) libp->para[0].ref);
13770 G__setnull(result7);
13771 return(1 || funcname || hash || result7 || libp) ;
13772}
13773
13774static int G__RootEventData_rootcint_457_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13775{
13776 ((TRecMucTrack*) G__getstructoffset())->setDistHits(*(vector<Float_t>*) libp->para[0].ref);
13777 G__setnull(result7);
13778 return(1 || funcname || hash || result7 || libp) ;
13779}
13780
13781static int G__RootEventData_rootcint_457_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13782{
13783 ((TRecMucTrack*) G__getstructoffset())->setkalRechi2((Double_t) G__double(libp->para[0]));
13784 G__setnull(result7);
13785 return(1 || funcname || hash || result7 || libp) ;
13786}
13787
13788static int G__RootEventData_rootcint_457_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13789{
13790 ((TRecMucTrack*) G__getstructoffset())->setkalDof((Int_t) G__int(libp->para[0]));
13791 G__setnull(result7);
13792 return(1 || funcname || hash || result7 || libp) ;
13793}
13794
13795static int G__RootEventData_rootcint_457_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13796{
13797 ((TRecMucTrack*) G__getstructoffset())->setkalDepth((Double_t) G__double(libp->para[0]));
13798 G__setnull(result7);
13799 return(1 || funcname || hash || result7 || libp) ;
13800}
13801
13802static int G__RootEventData_rootcint_457_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13803{
13804 ((TRecMucTrack*) G__getstructoffset())->setkalbrLastLayer((Int_t) G__int(libp->para[0]));
13805 G__setnull(result7);
13806 return(1 || funcname || hash || result7 || libp) ;
13807}
13808
13809static int G__RootEventData_rootcint_457_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13810{
13811 ((TRecMucTrack*) G__getstructoffset())->setkalecLastLayer((Int_t) G__int(libp->para[0]));
13812 G__setnull(result7);
13813 return(1 || funcname || hash || result7 || libp) ;
13814}
13815
13816static int G__RootEventData_rootcint_457_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13817{
13818 ((TRecMucTrack*) G__getstructoffset())->setTRecMucTrack((TRecMucTrack*) G__int(libp->para[0]));
13819 G__setnull(result7);
13820 return(1 || funcname || hash || result7 || libp) ;
13821}
13822
13823static int G__RootEventData_rootcint_457_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13824{
13825 G__letint(result7, 85, (long) TRecMucTrack::Class());
13826 return(1 || funcname || hash || result7 || libp) ;
13827}
13828
13829static int G__RootEventData_rootcint_457_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13830{
13831 G__letint(result7, 67, (long) TRecMucTrack::Class_Name());
13832 return(1 || funcname || hash || result7 || libp) ;
13833}
13834
13835static int G__RootEventData_rootcint_457_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13836{
13837 G__letint(result7, 115, (long) TRecMucTrack::Class_Version());
13838 return(1 || funcname || hash || result7 || libp) ;
13839}
13840
13841static int G__RootEventData_rootcint_457_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13842{
13843 TRecMucTrack::Dictionary();
13844 G__setnull(result7);
13845 return(1 || funcname || hash || result7 || libp) ;
13846}
13847
13848static int G__RootEventData_rootcint_457_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13849{
13850 ((TRecMucTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13851 G__setnull(result7);
13852 return(1 || funcname || hash || result7 || libp) ;
13853}
13854
13855static int G__RootEventData_rootcint_457_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13856{
13857 G__letint(result7, 67, (long) TRecMucTrack::DeclFileName());
13858 return(1 || funcname || hash || result7 || libp) ;
13859}
13860
13861static int G__RootEventData_rootcint_457_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13862{
13863 G__letint(result7, 105, (long) TRecMucTrack::ImplFileLine());
13864 return(1 || funcname || hash || result7 || libp) ;
13865}
13866
13867static int G__RootEventData_rootcint_457_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13868{
13869 G__letint(result7, 67, (long) TRecMucTrack::ImplFileName());
13870 return(1 || funcname || hash || result7 || libp) ;
13871}
13872
13873static int G__RootEventData_rootcint_457_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13874{
13875 G__letint(result7, 105, (long) TRecMucTrack::DeclFileLine());
13876 return(1 || funcname || hash || result7 || libp) ;
13877}
13878
13879// automatic copy constructor
13880static int G__RootEventData_rootcint_457_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13881
13882{
13883 TRecMucTrack* p;
13884 void* tmp = (void*) G__int(libp->para[0]);
13885 p = new TRecMucTrack(*(TRecMucTrack*) tmp);
13886 result7->obj.i = (long) p;
13887 result7->ref = (long) p;
13888 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
13889 return(1 || funcname || hash || result7 || libp) ;
13890}
13891
13892// automatic destructor
13893typedef TRecMucTrack G__TTRecMucTrack;
13894static int G__RootEventData_rootcint_457_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13895{
13896 char* gvp = (char*) G__getgvp();
13897 long soff = G__getstructoffset();
13898 int n = G__getaryconstruct();
13899 //
13900 //has_a_delete: 1
13901 //has_own_delete1arg: 0
13902 //has_own_delete2arg: 0
13903 //
13904 if (!soff) {
13905 return(1);
13906 }
13907 if (n) {
13908 if (gvp == (char*)G__PVOID) {
13909 delete[] (TRecMucTrack*) soff;
13910 } else {
13911 G__setgvp((long) G__PVOID);
13912 for (int i = n - 1; i >= 0; --i) {
13913 ((TRecMucTrack*) (soff+(sizeof(TRecMucTrack)*i)))->~G__TTRecMucTrack();
13914 }
13915 G__setgvp((long)gvp);
13916 }
13917 } else {
13918 if (gvp == (char*)G__PVOID) {
13919 delete (TRecMucTrack*) soff;
13920 } else {
13921 G__setgvp((long) G__PVOID);
13922 ((TRecMucTrack*) (soff))->~G__TTRecMucTrack();
13923 G__setgvp((long)gvp);
13924 }
13925 }
13926 G__setnull(result7);
13927 return(1 || funcname || hash || result7 || libp) ;
13928}
13929
13930// automatic assignment operator
13931static int G__RootEventData_rootcint_457_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13932{
13933 TRecMucTrack* dest = (TRecMucTrack*) G__getstructoffset();
13934 *dest = *(TRecMucTrack*) libp->para[0].ref;
13935 const TRecMucTrack& obj = *dest;
13936 result7->ref = (long) (&obj);
13937 result7->obj.i = (long) (&obj);
13938 return(1 || funcname || hash || result7 || libp) ;
13939}
13940
13941
13942/* TRecMdcDedx */
13943static int G__RootEventData_rootcint_458_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13944{
13945 TRecMdcDedx* p = NULL;
13946 char* gvp = (char*) G__getgvp();
13947 int n = G__getaryconstruct();
13948 if (n) {
13949 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13950 p = new TRecMdcDedx[n];
13951 } else {
13952 p = new((void*) gvp) TRecMdcDedx[n];
13953 }
13954 } else {
13955 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13956 p = new TRecMdcDedx;
13957 } else {
13958 p = new((void*) gvp) TRecMdcDedx;
13959 }
13960 }
13961 result7->obj.i = (long) p;
13962 result7->ref = (long) p;
13963 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
13964 return(1 || funcname || hash || result7 || libp) ;
13965}
13966
13967static int G__RootEventData_rootcint_458_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13968{
13969 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->mdcTrackId());
13970 return(1 || funcname || hash || result7 || libp) ;
13971}
13972
13973static int G__RootEventData_rootcint_458_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13974{
13975 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->mdcKalTrackId());
13976 return(1 || funcname || hash || result7 || libp) ;
13977}
13978
13979static int G__RootEventData_rootcint_458_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13980{
13981 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->trackId());
13982 return(1 || funcname || hash || result7 || libp) ;
13983}
13984
13985static int G__RootEventData_rootcint_458_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13986{
13987 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->particleId());
13988 return(1 || funcname || hash || result7 || libp) ;
13989}
13990
13991static int G__RootEventData_rootcint_458_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13992{
13993 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->status());
13994 return(1 || funcname || hash || result7 || libp) ;
13995}
13996
13997static int G__RootEventData_rootcint_458_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13998{
13999 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->truncAlg());
14000 return(1 || funcname || hash || result7 || libp) ;
14001}
14002
14003static int G__RootEventData_rootcint_458_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14004{
14005 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chi((int) G__int(libp->para[0])));
14006 return(1 || funcname || hash || result7 || libp) ;
14007}
14008
14009static int G__RootEventData_rootcint_458_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14010{
14011 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiE());
14012 return(1 || funcname || hash || result7 || libp) ;
14013}
14014
14015static int G__RootEventData_rootcint_458_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14016{
14017 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiMu());
14018 return(1 || funcname || hash || result7 || libp) ;
14019}
14020
14021static int G__RootEventData_rootcint_458_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14022{
14023 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiPi());
14024 return(1 || funcname || hash || result7 || libp) ;
14025}
14026
14027static int G__RootEventData_rootcint_458_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14028{
14029 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiK());
14030 return(1 || funcname || hash || result7 || libp) ;
14031}
14032
14033static int G__RootEventData_rootcint_458_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14034{
14035 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiP());
14036 return(1 || funcname || hash || result7 || libp) ;
14037}
14038
14039static int G__RootEventData_rootcint_458_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14040{
14041 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->numGoodHits());
14042 return(1 || funcname || hash || result7 || libp) ;
14043}
14044
14045static int G__RootEventData_rootcint_458_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14046{
14047 G__letint(result7, 105, (long) ((const TRecMdcDedx*) G__getstructoffset())->numTotalHits());
14048 return(1 || funcname || hash || result7 || libp) ;
14049}
14050
14051static int G__RootEventData_rootcint_458_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14052{
14053 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->probPH());
14054 return(1 || funcname || hash || result7 || libp) ;
14055}
14056
14057static int G__RootEventData_rootcint_458_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14058{
14059 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->normPH());
14060 return(1 || funcname || hash || result7 || libp) ;
14061}
14062
14063static int G__RootEventData_rootcint_458_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14064{
14065 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->errorPH());
14066 return(1 || funcname || hash || result7 || libp) ;
14067}
14068
14069static int G__RootEventData_rootcint_458_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14070{
14071 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->twentyPH());
14072 return(1 || funcname || hash || result7 || libp) ;
14073}
14074
14075static int G__RootEventData_rootcint_458_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14076{
14077 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxExpect((int) G__int(libp->para[0])));
14078 return(1 || funcname || hash || result7 || libp) ;
14079}
14080
14081static int G__RootEventData_rootcint_458_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14082{
14083 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->sigmaDedx((int) G__int(libp->para[0])));
14084 return(1 || funcname || hash || result7 || libp) ;
14085}
14086
14087static int G__RootEventData_rootcint_458_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14088{
14089 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->pidProb((int) G__int(libp->para[0])));
14090 return(1 || funcname || hash || result7 || libp) ;
14091}
14092
14093static int G__RootEventData_rootcint_458_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14094{
14095 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxHit());
14096 return(1 || funcname || hash || result7 || libp) ;
14097}
14098
14099static int G__RootEventData_rootcint_458_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14100{
14101 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxEsat());
14102 return(1 || funcname || hash || result7 || libp) ;
14103}
14104
14105static int G__RootEventData_rootcint_458_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14106{
14107 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxNoRun());
14108 return(1 || funcname || hash || result7 || libp) ;
14109}
14110
14111static int G__RootEventData_rootcint_458_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14112{
14113 G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxMoment());
14114 return(1 || funcname || hash || result7 || libp) ;
14115}
14116
14117static int G__RootEventData_rootcint_458_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14118{
14119 ((TRecMdcDedx*) G__getstructoffset())->setDedxHit((const Double_t) G__double(libp->para[0]));
14120 G__setnull(result7);
14121 return(1 || funcname || hash || result7 || libp) ;
14122}
14123
14124static int G__RootEventData_rootcint_458_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14125{
14126 ((TRecMdcDedx*) G__getstructoffset())->setDedxEsat((const Double_t) G__double(libp->para[0]));
14127 G__setnull(result7);
14128 return(1 || funcname || hash || result7 || libp) ;
14129}
14130
14131static int G__RootEventData_rootcint_458_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14132{
14133 ((TRecMdcDedx*) G__getstructoffset())->setDedxNoRun((const Double_t) G__double(libp->para[0]));
14134 G__setnull(result7);
14135 return(1 || funcname || hash || result7 || libp) ;
14136}
14137
14138static int G__RootEventData_rootcint_458_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14139{
14140 ((TRecMdcDedx*) G__getstructoffset())->setDedxMoment((const Double_t) G__double(libp->para[0]));
14141 G__setnull(result7);
14142 return(1 || funcname || hash || result7 || libp) ;
14143}
14144
14145static int G__RootEventData_rootcint_458_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14146{
14147 ((TRecMdcDedx*) G__getstructoffset())->setMdcTrackId((const int) G__int(libp->para[0]));
14148 G__setnull(result7);
14149 return(1 || funcname || hash || result7 || libp) ;
14150}
14151
14152static int G__RootEventData_rootcint_458_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14153{
14154 ((TRecMdcDedx*) G__getstructoffset())->setMdcKalTrackId((const int) G__int(libp->para[0]));
14155 G__setnull(result7);
14156 return(1 || funcname || hash || result7 || libp) ;
14157}
14158
14159static int G__RootEventData_rootcint_458_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14160{
14161 ((TRecMdcDedx*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
14162 G__setnull(result7);
14163 return(1 || funcname || hash || result7 || libp) ;
14164}
14165
14166static int G__RootEventData_rootcint_458_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14167{
14168 ((TRecMdcDedx*) G__getstructoffset())->setParticleId((const Int_t) G__int(libp->para[0]));
14169 G__setnull(result7);
14170 return(1 || funcname || hash || result7 || libp) ;
14171}
14172
14173static int G__RootEventData_rootcint_458_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14174{
14175 ((TRecMdcDedx*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
14176 G__setnull(result7);
14177 return(1 || funcname || hash || result7 || libp) ;
14178}
14179
14180static int G__RootEventData_rootcint_458_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14181{
14182 ((TRecMdcDedx*) G__getstructoffset())->setTruncAlg((const Int_t) G__int(libp->para[0]));
14183 G__setnull(result7);
14184 return(1 || funcname || hash || result7 || libp) ;
14185}
14186
14187static int G__RootEventData_rootcint_458_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14188{
14189 ((TRecMdcDedx*) G__getstructoffset())->setChiE((const Double_t) G__double(libp->para[0]));
14190 G__setnull(result7);
14191 return(1 || funcname || hash || result7 || libp) ;
14192}
14193
14194static int G__RootEventData_rootcint_458_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14195{
14196 ((TRecMdcDedx*) G__getstructoffset())->setChiMu((const Double_t) G__double(libp->para[0]));
14197 G__setnull(result7);
14198 return(1 || funcname || hash || result7 || libp) ;
14199}
14200
14201static int G__RootEventData_rootcint_458_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14202{
14203 ((TRecMdcDedx*) G__getstructoffset())->setChiPi((const Double_t) G__double(libp->para[0]));
14204 G__setnull(result7);
14205 return(1 || funcname || hash || result7 || libp) ;
14206}
14207
14208static int G__RootEventData_rootcint_458_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14209{
14210 ((TRecMdcDedx*) G__getstructoffset())->setChiK((const Double_t) G__double(libp->para[0]));
14211 G__setnull(result7);
14212 return(1 || funcname || hash || result7 || libp) ;
14213}
14214
14215static int G__RootEventData_rootcint_458_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14216{
14217 ((TRecMdcDedx*) G__getstructoffset())->setChiP((const Double_t) G__double(libp->para[0]));
14218 G__setnull(result7);
14219 return(1 || funcname || hash || result7 || libp) ;
14220}
14221
14222static int G__RootEventData_rootcint_458_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14223{
14224 ((TRecMdcDedx*) G__getstructoffset())->setNumGoodHits((const Int_t) G__int(libp->para[0]));
14225 G__setnull(result7);
14226 return(1 || funcname || hash || result7 || libp) ;
14227}
14228
14229static int G__RootEventData_rootcint_458_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14230{
14231 ((TRecMdcDedx*) G__getstructoffset())->setNumTotalHits((const Int_t) G__int(libp->para[0]));
14232 G__setnull(result7);
14233 return(1 || funcname || hash || result7 || libp) ;
14234}
14235
14236static int G__RootEventData_rootcint_458_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14237{
14238 ((TRecMdcDedx*) G__getstructoffset())->setProbPH((const Double_t) G__double(libp->para[0]));
14239 G__setnull(result7);
14240 return(1 || funcname || hash || result7 || libp) ;
14241}
14242
14243static int G__RootEventData_rootcint_458_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14244{
14245 ((TRecMdcDedx*) G__getstructoffset())->setNormPH((const Double_t) G__double(libp->para[0]));
14246 G__setnull(result7);
14247 return(1 || funcname || hash || result7 || libp) ;
14248}
14249
14250static int G__RootEventData_rootcint_458_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14251{
14252 ((TRecMdcDedx*) G__getstructoffset())->setErrorPH((const Double_t) G__double(libp->para[0]));
14253 G__setnull(result7);
14254 return(1 || funcname || hash || result7 || libp) ;
14255}
14256
14257static int G__RootEventData_rootcint_458_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14258{
14259 ((TRecMdcDedx*) G__getstructoffset())->setTwentyPH((const Double_t) G__double(libp->para[0]));
14260 G__setnull(result7);
14261 return(1 || funcname || hash || result7 || libp) ;
14262}
14263
14264static int G__RootEventData_rootcint_458_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14265{
14266 ((TRecMdcDedx*) G__getstructoffset())->setChi((double*) G__int(libp->para[0]));
14267 G__setnull(result7);
14268 return(1 || funcname || hash || result7 || libp) ;
14269}
14270
14271static int G__RootEventData_rootcint_458_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14272{
14273 ((TRecMdcDedx*) G__getstructoffset())->setDedxExpect((double*) G__int(libp->para[0]));
14274 G__setnull(result7);
14275 return(1 || funcname || hash || result7 || libp) ;
14276}
14277
14278static int G__RootEventData_rootcint_458_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14279{
14280 ((TRecMdcDedx*) G__getstructoffset())->setSigmaDedx((double*) G__int(libp->para[0]));
14281 G__setnull(result7);
14282 return(1 || funcname || hash || result7 || libp) ;
14283}
14284
14285static int G__RootEventData_rootcint_458_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14286{
14287 ((TRecMdcDedx*) G__getstructoffset())->setPidProb((double*) G__int(libp->para[0]));
14288 G__setnull(result7);
14289 return(1 || funcname || hash || result7 || libp) ;
14290}
14291
14292static int G__RootEventData_rootcint_458_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14293{
14294 G__letint(result7, 85, (long) TRecMdcDedx::Class());
14295 return(1 || funcname || hash || result7 || libp) ;
14296}
14297
14298static int G__RootEventData_rootcint_458_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14299{
14300 G__letint(result7, 67, (long) TRecMdcDedx::Class_Name());
14301 return(1 || funcname || hash || result7 || libp) ;
14302}
14303
14304static int G__RootEventData_rootcint_458_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14305{
14306 G__letint(result7, 115, (long) TRecMdcDedx::Class_Version());
14307 return(1 || funcname || hash || result7 || libp) ;
14308}
14309
14310static int G__RootEventData_rootcint_458_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14311{
14312 TRecMdcDedx::Dictionary();
14313 G__setnull(result7);
14314 return(1 || funcname || hash || result7 || libp) ;
14315}
14316
14317static int G__RootEventData_rootcint_458_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14318{
14319 ((TRecMdcDedx*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14320 G__setnull(result7);
14321 return(1 || funcname || hash || result7 || libp) ;
14322}
14323
14324static int G__RootEventData_rootcint_458_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14325{
14326 G__letint(result7, 67, (long) TRecMdcDedx::DeclFileName());
14327 return(1 || funcname || hash || result7 || libp) ;
14328}
14329
14330static int G__RootEventData_rootcint_458_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14331{
14332 G__letint(result7, 105, (long) TRecMdcDedx::ImplFileLine());
14333 return(1 || funcname || hash || result7 || libp) ;
14334}
14335
14336static int G__RootEventData_rootcint_458_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14337{
14338 G__letint(result7, 67, (long) TRecMdcDedx::ImplFileName());
14339 return(1 || funcname || hash || result7 || libp) ;
14340}
14341
14342static int G__RootEventData_rootcint_458_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14343{
14344 G__letint(result7, 105, (long) TRecMdcDedx::DeclFileLine());
14345 return(1 || funcname || hash || result7 || libp) ;
14346}
14347
14348// automatic copy constructor
14349static int G__RootEventData_rootcint_458_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14350
14351{
14352 TRecMdcDedx* p;
14353 void* tmp = (void*) G__int(libp->para[0]);
14354 p = new TRecMdcDedx(*(TRecMdcDedx*) tmp);
14355 result7->obj.i = (long) p;
14356 result7->ref = (long) p;
14357 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
14358 return(1 || funcname || hash || result7 || libp) ;
14359}
14360
14361// automatic destructor
14362typedef TRecMdcDedx G__TTRecMdcDedx;
14363static int G__RootEventData_rootcint_458_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14364{
14365 char* gvp = (char*) G__getgvp();
14366 long soff = G__getstructoffset();
14367 int n = G__getaryconstruct();
14368 //
14369 //has_a_delete: 1
14370 //has_own_delete1arg: 0
14371 //has_own_delete2arg: 0
14372 //
14373 if (!soff) {
14374 return(1);
14375 }
14376 if (n) {
14377 if (gvp == (char*)G__PVOID) {
14378 delete[] (TRecMdcDedx*) soff;
14379 } else {
14380 G__setgvp((long) G__PVOID);
14381 for (int i = n - 1; i >= 0; --i) {
14382 ((TRecMdcDedx*) (soff+(sizeof(TRecMdcDedx)*i)))->~G__TTRecMdcDedx();
14383 }
14384 G__setgvp((long)gvp);
14385 }
14386 } else {
14387 if (gvp == (char*)G__PVOID) {
14388 delete (TRecMdcDedx*) soff;
14389 } else {
14390 G__setgvp((long) G__PVOID);
14391 ((TRecMdcDedx*) (soff))->~G__TTRecMdcDedx();
14392 G__setgvp((long)gvp);
14393 }
14394 }
14395 G__setnull(result7);
14396 return(1 || funcname || hash || result7 || libp) ;
14397}
14398
14399// automatic assignment operator
14400static int G__RootEventData_rootcint_458_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14401{
14402 TRecMdcDedx* dest = (TRecMdcDedx*) G__getstructoffset();
14403 *dest = *(TRecMdcDedx*) libp->para[0].ref;
14404 const TRecMdcDedx& obj = *dest;
14405 result7->ref = (long) (&obj);
14406 result7->obj.i = (long) (&obj);
14407 return(1 || funcname || hash || result7 || libp) ;
14408}
14409
14410
14411/* TRecMdcDedxHit */
14412static int G__RootEventData_rootcint_459_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14413{
14414 TRecMdcDedxHit* p = NULL;
14415 char* gvp = (char*) G__getgvp();
14416 int n = G__getaryconstruct();
14417 if (n) {
14418 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14419 p = new TRecMdcDedxHit[n];
14420 } else {
14421 p = new((void*) gvp) TRecMdcDedxHit[n];
14422 }
14423 } else {
14424 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14425 p = new TRecMdcDedxHit;
14426 } else {
14427 p = new((void*) gvp) TRecMdcDedxHit;
14428 }
14429 }
14430 result7->obj.i = (long) p;
14431 result7->ref = (long) p;
14432 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
14433 return(1 || funcname || hash || result7 || libp) ;
14434}
14435
14436static int G__RootEventData_rootcint_459_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14437{
14438 G__letint(result7, 103, (long) ((TRecMdcDedxHit*) G__getstructoffset())->isGrouped());
14439 return(1 || funcname || hash || result7 || libp) ;
14440}
14441
14442static int G__RootEventData_rootcint_459_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14443{
14444 G__letint(result7, 105, (long) ((TRecMdcDedxHit*) G__getstructoffset())->mdcHitId());
14445 return(1 || funcname || hash || result7 || libp) ;
14446}
14447
14448static int G__RootEventData_rootcint_459_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14449{
14450 G__letint(result7, 105, (long) ((TRecMdcDedxHit*) G__getstructoffset())->mdcKalHelixSegId());
14451 return(1 || funcname || hash || result7 || libp) ;
14452}
14453
14454static int G__RootEventData_rootcint_459_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14455{
14456 G__letint(result7, 105, (long) ((const TRecMdcDedxHit*) G__getstructoffset())->trkId());
14457 return(1 || funcname || hash || result7 || libp) ;
14458}
14459
14460static int G__RootEventData_rootcint_459_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14461{
14462 G__letint(result7, 105, (long) ((const TRecMdcDedxHit*) G__getstructoffset())->flagLR());
14463 return(1 || funcname || hash || result7 || libp) ;
14464}
14465
14466static int G__RootEventData_rootcint_459_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14467{
14468 G__letint(result7, 104, (long) ((const TRecMdcDedxHit*) G__getstructoffset())->mdcId());
14469 return(1 || funcname || hash || result7 || libp) ;
14470}
14471
14472static int G__RootEventData_rootcint_459_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14473{
14474 G__letdouble(result7, 100, (double) ((const TRecMdcDedxHit*) G__getstructoffset())->pathLength());
14475 return(1 || funcname || hash || result7 || libp) ;
14476}
14477
14478static int G__RootEventData_rootcint_459_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14479{
14480 G__letdouble(result7, 100, (double) ((const TRecMdcDedxHit*) G__getstructoffset())->getDedx());
14481 return(1 || funcname || hash || result7 || libp) ;
14482}
14483
14484static int G__RootEventData_rootcint_459_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14485{
14486 ((TRecMdcDedxHit*) G__getstructoffset())->setMdcHitId((const int) G__int(libp->para[0]));
14487 G__setnull(result7);
14488 return(1 || funcname || hash || result7 || libp) ;
14489}
14490
14491static int G__RootEventData_rootcint_459_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14492{
14493 ((TRecMdcDedxHit*) G__getstructoffset())->setMdcKalHelixSegId((const int) G__int(libp->para[0]));
14494 G__setnull(result7);
14495 return(1 || funcname || hash || result7 || libp) ;
14496}
14497
14498static int G__RootEventData_rootcint_459_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14499{
14500 ((TRecMdcDedxHit*) G__getstructoffset())->setDedx((double) G__double(libp->para[0]));
14501 G__setnull(result7);
14502 return(1 || funcname || hash || result7 || libp) ;
14503}
14504
14505static int G__RootEventData_rootcint_459_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14506{
14507 ((TRecMdcDedxHit*) G__getstructoffset())->setIsGrouped((Bool_t) G__int(libp->para[0]));
14508 G__setnull(result7);
14509 return(1 || funcname || hash || result7 || libp) ;
14510}
14511
14512static int G__RootEventData_rootcint_459_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14513{
14514 ((TRecMdcDedxHit*) G__getstructoffset())->setTrkId((Int_t) G__int(libp->para[0]));
14515 G__setnull(result7);
14516 return(1 || funcname || hash || result7 || libp) ;
14517}
14518
14519static int G__RootEventData_rootcint_459_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14520{
14521 ((TRecMdcDedxHit*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
14522 G__setnull(result7);
14523 return(1 || funcname || hash || result7 || libp) ;
14524}
14525
14526static int G__RootEventData_rootcint_459_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14527{
14528 ((TRecMdcDedxHit*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
14529 G__setnull(result7);
14530 return(1 || funcname || hash || result7 || libp) ;
14531}
14532
14533static int G__RootEventData_rootcint_459_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14534{
14535 ((TRecMdcDedxHit*) G__getstructoffset())->setPathLength((double) G__double(libp->para[0]));
14536 G__setnull(result7);
14537 return(1 || funcname || hash || result7 || libp) ;
14538}
14539
14540static int G__RootEventData_rootcint_459_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14541{
14542 G__letint(result7, 85, (long) TRecMdcDedxHit::Class());
14543 return(1 || funcname || hash || result7 || libp) ;
14544}
14545
14546static int G__RootEventData_rootcint_459_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14547{
14548 G__letint(result7, 67, (long) TRecMdcDedxHit::Class_Name());
14549 return(1 || funcname || hash || result7 || libp) ;
14550}
14551
14552static int G__RootEventData_rootcint_459_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14553{
14554 G__letint(result7, 115, (long) TRecMdcDedxHit::Class_Version());
14555 return(1 || funcname || hash || result7 || libp) ;
14556}
14557
14558static int G__RootEventData_rootcint_459_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14559{
14560 TRecMdcDedxHit::Dictionary();
14561 G__setnull(result7);
14562 return(1 || funcname || hash || result7 || libp) ;
14563}
14564
14565static int G__RootEventData_rootcint_459_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14566{
14567 ((TRecMdcDedxHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14568 G__setnull(result7);
14569 return(1 || funcname || hash || result7 || libp) ;
14570}
14571
14572static int G__RootEventData_rootcint_459_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14573{
14574 G__letint(result7, 67, (long) TRecMdcDedxHit::DeclFileName());
14575 return(1 || funcname || hash || result7 || libp) ;
14576}
14577
14578static int G__RootEventData_rootcint_459_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14579{
14580 G__letint(result7, 105, (long) TRecMdcDedxHit::ImplFileLine());
14581 return(1 || funcname || hash || result7 || libp) ;
14582}
14583
14584static int G__RootEventData_rootcint_459_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14585{
14586 G__letint(result7, 67, (long) TRecMdcDedxHit::ImplFileName());
14587 return(1 || funcname || hash || result7 || libp) ;
14588}
14589
14590static int G__RootEventData_rootcint_459_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14591{
14592 G__letint(result7, 105, (long) TRecMdcDedxHit::DeclFileLine());
14593 return(1 || funcname || hash || result7 || libp) ;
14594}
14595
14596// automatic copy constructor
14597static int G__RootEventData_rootcint_459_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14598
14599{
14600 TRecMdcDedxHit* p;
14601 void* tmp = (void*) G__int(libp->para[0]);
14602 p = new TRecMdcDedxHit(*(TRecMdcDedxHit*) tmp);
14603 result7->obj.i = (long) p;
14604 result7->ref = (long) p;
14605 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
14606 return(1 || funcname || hash || result7 || libp) ;
14607}
14608
14609// automatic destructor
14610typedef TRecMdcDedxHit G__TTRecMdcDedxHit;
14611static int G__RootEventData_rootcint_459_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14612{
14613 char* gvp = (char*) G__getgvp();
14614 long soff = G__getstructoffset();
14615 int n = G__getaryconstruct();
14616 //
14617 //has_a_delete: 1
14618 //has_own_delete1arg: 0
14619 //has_own_delete2arg: 0
14620 //
14621 if (!soff) {
14622 return(1);
14623 }
14624 if (n) {
14625 if (gvp == (char*)G__PVOID) {
14626 delete[] (TRecMdcDedxHit*) soff;
14627 } else {
14628 G__setgvp((long) G__PVOID);
14629 for (int i = n - 1; i >= 0; --i) {
14630 ((TRecMdcDedxHit*) (soff+(sizeof(TRecMdcDedxHit)*i)))->~G__TTRecMdcDedxHit();
14631 }
14632 G__setgvp((long)gvp);
14633 }
14634 } else {
14635 if (gvp == (char*)G__PVOID) {
14636 delete (TRecMdcDedxHit*) soff;
14637 } else {
14638 G__setgvp((long) G__PVOID);
14639 ((TRecMdcDedxHit*) (soff))->~G__TTRecMdcDedxHit();
14640 G__setgvp((long)gvp);
14641 }
14642 }
14643 G__setnull(result7);
14644 return(1 || funcname || hash || result7 || libp) ;
14645}
14646
14647// automatic assignment operator
14648static int G__RootEventData_rootcint_459_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14649{
14650 TRecMdcDedxHit* dest = (TRecMdcDedxHit*) G__getstructoffset();
14651 *dest = *(TRecMdcDedxHit*) libp->para[0].ref;
14652 const TRecMdcDedxHit& obj = *dest;
14653 result7->ref = (long) (&obj);
14654 result7->obj.i = (long) (&obj);
14655 return(1 || funcname || hash || result7 || libp) ;
14656}
14657
14658
14659/* TRecExtTrack */
14660static int G__RootEventData_rootcint_460_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14661{
14662 TRecExtTrack* p = NULL;
14663 char* gvp = (char*) G__getgvp();
14664 int n = G__getaryconstruct();
14665 if (n) {
14666 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14667 p = new TRecExtTrack[n];
14668 } else {
14669 p = new((void*) gvp) TRecExtTrack[n];
14670 }
14671 } else {
14672 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14673 p = new TRecExtTrack;
14674 } else {
14675 p = new((void*) gvp) TRecExtTrack;
14676 }
14677 }
14678 result7->obj.i = (long) p;
14679 result7->ref = (long) p;
14680 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
14681 return(1 || funcname || hash || result7 || libp) ;
14682}
14683
14684static int G__RootEventData_rootcint_460_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14685{
14686 ((TRecExtTrack*) G__getstructoffset())->SetTrackId((const Int_t) G__int(libp->para[0]));
14687 G__setnull(result7);
14688 return(1 || funcname || hash || result7 || libp) ;
14689}
14690
14691static int G__RootEventData_rootcint_460_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14692{
14693 switch (libp->paran) {
14694 case 2:
14695 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14696 G__setnull(result7);
14697 break;
14698 case 1:
14699 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]));
14700 G__setnull(result7);
14701 break;
14702 }
14703 return(1 || funcname || hash || result7 || libp) ;
14704}
14705
14706static int G__RootEventData_rootcint_460_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14707{
14708 switch (libp->paran) {
14709 case 2:
14710 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14711 G__setnull(result7);
14712 break;
14713 case 1:
14714 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]));
14715 G__setnull(result7);
14716 break;
14717 }
14718 return(1 || funcname || hash || result7 || libp) ;
14719}
14720
14721static int G__RootEventData_rootcint_460_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14722{
14723 switch (libp->paran) {
14724 case 2:
14725 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14726 G__setnull(result7);
14727 break;
14728 case 1:
14729 ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]));
14730 G__setnull(result7);
14731 break;
14732 }
14733 return(1 || funcname || hash || result7 || libp) ;
14734}
14735
14736static int G__RootEventData_rootcint_460_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14737{
14738 switch (libp->paran) {
14739 case 2:
14740 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14741 G__setnull(result7);
14742 break;
14743 case 1:
14744 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]));
14745 G__setnull(result7);
14746 break;
14747 }
14748 return(1 || funcname || hash || result7 || libp) ;
14749}
14750
14751static int G__RootEventData_rootcint_460_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14752{
14753 switch (libp->paran) {
14754 case 2:
14755 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14756 G__setnull(result7);
14757 break;
14758 case 1:
14759 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]));
14760 G__setnull(result7);
14761 break;
14762 }
14763 return(1 || funcname || hash || result7 || libp) ;
14764}
14765
14766static int G__RootEventData_rootcint_460_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14767{
14768 switch (libp->paran) {
14769 case 2:
14770 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14771 G__setnull(result7);
14772 break;
14773 case 1:
14774 ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]));
14775 G__setnull(result7);
14776 break;
14777 }
14778 return(1 || funcname || hash || result7 || libp) ;
14779}
14780
14781static int G__RootEventData_rootcint_460_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14782{
14783 switch (libp->paran) {
14784 case 2:
14785 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
14786 G__setnull(result7);
14787 break;
14788 case 1:
14789 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])));
14790 G__setnull(result7);
14791 break;
14792 }
14793 return(1 || funcname || hash || result7 || libp) ;
14794}
14795
14796static int G__RootEventData_rootcint_460_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14797{
14798 switch (libp->paran) {
14799 case 2:
14800 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14801 G__setnull(result7);
14802 break;
14803 case 1:
14804 ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]));
14805 G__setnull(result7);
14806 break;
14807 }
14808 return(1 || funcname || hash || result7 || libp) ;
14809}
14810
14811static int G__RootEventData_rootcint_460_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14812{
14813 switch (libp->paran) {
14814 case 2:
14815 ((TRecExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14816 G__setnull(result7);
14817 break;
14818 case 1:
14819 ((TRecExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]));
14820 G__setnull(result7);
14821 break;
14822 }
14823 return(1 || funcname || hash || result7 || libp) ;
14824}
14825
14826static int G__RootEventData_rootcint_460_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14827{
14828 switch (libp->paran) {
14829 case 2:
14830 ((TRecExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14831 G__setnull(result7);
14832 break;
14833 case 1:
14834 ((TRecExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]));
14835 G__setnull(result7);
14836 break;
14837 }
14838 return(1 || funcname || hash || result7 || libp) ;
14839}
14840
14841static int G__RootEventData_rootcint_460_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14842{
14843 switch (libp->paran) {
14844 case 2:
14845 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14846 G__setnull(result7);
14847 break;
14848 case 1:
14849 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
14850 G__setnull(result7);
14851 break;
14852 }
14853 return(1 || funcname || hash || result7 || libp) ;
14854}
14855
14856static int G__RootEventData_rootcint_460_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14857{
14858 switch (libp->paran) {
14859 case 2:
14860 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14861 G__setnull(result7);
14862 break;
14863 case 1:
14864 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
14865 G__setnull(result7);
14866 break;
14867 }
14868 return(1 || funcname || hash || result7 || libp) ;
14869}
14870
14871static int G__RootEventData_rootcint_460_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14872{
14873 switch (libp->paran) {
14874 case 2:
14875 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14876 G__setnull(result7);
14877 break;
14878 case 1:
14879 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
14880 G__setnull(result7);
14881 break;
14882 }
14883 return(1 || funcname || hash || result7 || libp) ;
14884}
14885
14886static int G__RootEventData_rootcint_460_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14887{
14888 switch (libp->paran) {
14889 case 2:
14890 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14891 G__setnull(result7);
14892 break;
14893 case 1:
14894 ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
14895 G__setnull(result7);
14896 break;
14897 }
14898 return(1 || funcname || hash || result7 || libp) ;
14899}
14900
14901static int G__RootEventData_rootcint_460_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14902{
14903 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
14904 switch (libp->paran) {
14905 case 2:
14906 ((TRecExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
14907 G__setnull(result7);
14908 break;
14909 case 1:
14910 ((TRecExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a);
14911 G__setnull(result7);
14912 break;
14913 }
14914 return(1 || funcname || hash || result7 || libp) ;
14915}
14916
14917static int G__RootEventData_rootcint_460_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14918{
14919 switch (libp->paran) {
14920 case 2:
14921 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14922 G__setnull(result7);
14923 break;
14924 case 1:
14925 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]));
14926 G__setnull(result7);
14927 break;
14928 }
14929 return(1 || funcname || hash || result7 || libp) ;
14930}
14931
14932static int G__RootEventData_rootcint_460_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14933{
14934 switch (libp->paran) {
14935 case 2:
14936 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14937 G__setnull(result7);
14938 break;
14939 case 1:
14940 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]));
14941 G__setnull(result7);
14942 break;
14943 }
14944 return(1 || funcname || hash || result7 || libp) ;
14945}
14946
14947static int G__RootEventData_rootcint_460_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14948{
14949 switch (libp->paran) {
14950 case 2:
14951 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14952 G__setnull(result7);
14953 break;
14954 case 1:
14955 ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]));
14956 G__setnull(result7);
14957 break;
14958 }
14959 return(1 || funcname || hash || result7 || libp) ;
14960}
14961
14962static int G__RootEventData_rootcint_460_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14963{
14964 switch (libp->paran) {
14965 case 2:
14966 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14967 G__setnull(result7);
14968 break;
14969 case 1:
14970 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]));
14971 G__setnull(result7);
14972 break;
14973 }
14974 return(1 || funcname || hash || result7 || libp) ;
14975}
14976
14977static int G__RootEventData_rootcint_460_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14978{
14979 switch (libp->paran) {
14980 case 2:
14981 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14982 G__setnull(result7);
14983 break;
14984 case 1:
14985 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]));
14986 G__setnull(result7);
14987 break;
14988 }
14989 return(1 || funcname || hash || result7 || libp) ;
14990}
14991
14992static int G__RootEventData_rootcint_460_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14993{
14994 switch (libp->paran) {
14995 case 2:
14996 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
14997 G__setnull(result7);
14998 break;
14999 case 1:
15000 ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]));
15001 G__setnull(result7);
15002 break;
15003 }
15004 return(1 || funcname || hash || result7 || libp) ;
15005}
15006
15007static int G__RootEventData_rootcint_460_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15008{
15009 switch (libp->paran) {
15010 case 2:
15011 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
15012 G__setnull(result7);
15013 break;
15014 case 1:
15015 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])));
15016 G__setnull(result7);
15017 break;
15018 }
15019 return(1 || funcname || hash || result7 || libp) ;
15020}
15021
15022static int G__RootEventData_rootcint_460_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15023{
15024 switch (libp->paran) {
15025 case 2:
15026 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15027 G__setnull(result7);
15028 break;
15029 case 1:
15030 ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]));
15031 G__setnull(result7);
15032 break;
15033 }
15034 return(1 || funcname || hash || result7 || libp) ;
15035}
15036
15037static int G__RootEventData_rootcint_460_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15038{
15039 switch (libp->paran) {
15040 case 2:
15041 ((TRecExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15042 G__setnull(result7);
15043 break;
15044 case 1:
15045 ((TRecExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]));
15046 G__setnull(result7);
15047 break;
15048 }
15049 return(1 || funcname || hash || result7 || libp) ;
15050}
15051
15052static int G__RootEventData_rootcint_460_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15053{
15054 switch (libp->paran) {
15055 case 2:
15056 ((TRecExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15057 G__setnull(result7);
15058 break;
15059 case 1:
15060 ((TRecExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]));
15061 G__setnull(result7);
15062 break;
15063 }
15064 return(1 || funcname || hash || result7 || libp) ;
15065}
15066
15067static int G__RootEventData_rootcint_460_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15068{
15069 switch (libp->paran) {
15070 case 2:
15071 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15072 G__setnull(result7);
15073 break;
15074 case 1:
15075 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
15076 G__setnull(result7);
15077 break;
15078 }
15079 return(1 || funcname || hash || result7 || libp) ;
15080}
15081
15082static int G__RootEventData_rootcint_460_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15083{
15084 switch (libp->paran) {
15085 case 2:
15086 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15087 G__setnull(result7);
15088 break;
15089 case 1:
15090 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
15091 G__setnull(result7);
15092 break;
15093 }
15094 return(1 || funcname || hash || result7 || libp) ;
15095}
15096
15097static int G__RootEventData_rootcint_460_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15098{
15099 switch (libp->paran) {
15100 case 2:
15101 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15102 G__setnull(result7);
15103 break;
15104 case 1:
15105 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
15106 G__setnull(result7);
15107 break;
15108 }
15109 return(1 || funcname || hash || result7 || libp) ;
15110}
15111
15112static int G__RootEventData_rootcint_460_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15113{
15114 switch (libp->paran) {
15115 case 2:
15116 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15117 G__setnull(result7);
15118 break;
15119 case 1:
15120 ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
15121 G__setnull(result7);
15122 break;
15123 }
15124 return(1 || funcname || hash || result7 || libp) ;
15125}
15126
15127static int G__RootEventData_rootcint_460_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15128{
15129 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
15130 switch (libp->paran) {
15131 case 2:
15132 ((TRecExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
15133 G__setnull(result7);
15134 break;
15135 case 1:
15136 ((TRecExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a);
15137 G__setnull(result7);
15138 break;
15139 }
15140 return(1 || funcname || hash || result7 || libp) ;
15141}
15142
15143static int G__RootEventData_rootcint_460_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15144{
15145 switch (libp->paran) {
15146 case 2:
15147 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15148 G__setnull(result7);
15149 break;
15150 case 1:
15151 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]));
15152 G__setnull(result7);
15153 break;
15154 }
15155 return(1 || funcname || hash || result7 || libp) ;
15156}
15157
15158static int G__RootEventData_rootcint_460_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15159{
15160 switch (libp->paran) {
15161 case 2:
15162 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15163 G__setnull(result7);
15164 break;
15165 case 1:
15166 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]));
15167 G__setnull(result7);
15168 break;
15169 }
15170 return(1 || funcname || hash || result7 || libp) ;
15171}
15172
15173static int G__RootEventData_rootcint_460_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15174{
15175 switch (libp->paran) {
15176 case 2:
15177 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15178 G__setnull(result7);
15179 break;
15180 case 1:
15181 ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]));
15182 G__setnull(result7);
15183 break;
15184 }
15185 return(1 || funcname || hash || result7 || libp) ;
15186}
15187
15188static int G__RootEventData_rootcint_460_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15189{
15190 switch (libp->paran) {
15191 case 2:
15192 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15193 G__setnull(result7);
15194 break;
15195 case 1:
15196 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]));
15197 G__setnull(result7);
15198 break;
15199 }
15200 return(1 || funcname || hash || result7 || libp) ;
15201}
15202
15203static int G__RootEventData_rootcint_460_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15204{
15205 switch (libp->paran) {
15206 case 2:
15207 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15208 G__setnull(result7);
15209 break;
15210 case 1:
15211 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]));
15212 G__setnull(result7);
15213 break;
15214 }
15215 return(1 || funcname || hash || result7 || libp) ;
15216}
15217
15218static int G__RootEventData_rootcint_460_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15219{
15220 switch (libp->paran) {
15221 case 2:
15222 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15223 G__setnull(result7);
15224 break;
15225 case 1:
15226 ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]));
15227 G__setnull(result7);
15228 break;
15229 }
15230 return(1 || funcname || hash || result7 || libp) ;
15231}
15232
15233static int G__RootEventData_rootcint_460_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15234{
15235 switch (libp->paran) {
15236 case 2:
15237 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
15238 G__setnull(result7);
15239 break;
15240 case 1:
15241 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])));
15242 G__setnull(result7);
15243 break;
15244 }
15245 return(1 || funcname || hash || result7 || libp) ;
15246}
15247
15248static int G__RootEventData_rootcint_460_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15249{
15250 switch (libp->paran) {
15251 case 2:
15252 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15253 G__setnull(result7);
15254 break;
15255 case 1:
15256 ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]));
15257 G__setnull(result7);
15258 break;
15259 }
15260 return(1 || funcname || hash || result7 || libp) ;
15261}
15262
15263static int G__RootEventData_rootcint_460_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15264{
15265 switch (libp->paran) {
15266 case 2:
15267 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15268 G__setnull(result7);
15269 break;
15270 case 1:
15271 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]));
15272 G__setnull(result7);
15273 break;
15274 }
15275 return(1 || funcname || hash || result7 || libp) ;
15276}
15277
15278static int G__RootEventData_rootcint_460_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15279{
15280 switch (libp->paran) {
15281 case 2:
15282 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15283 G__setnull(result7);
15284 break;
15285 case 1:
15286 ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]));
15287 G__setnull(result7);
15288 break;
15289 }
15290 return(1 || funcname || hash || result7 || libp) ;
15291}
15292
15293static int G__RootEventData_rootcint_460_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15294{
15295 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
15296 switch (libp->paran) {
15297 case 2:
15298 ((TRecExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
15299 G__setnull(result7);
15300 break;
15301 case 1:
15302 ((TRecExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a);
15303 G__setnull(result7);
15304 break;
15305 }
15306 return(1 || funcname || hash || result7 || libp) ;
15307}
15308
15309static int G__RootEventData_rootcint_460_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15310{
15311 switch (libp->paran) {
15312 case 2:
15313 ((TRecExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15314 G__setnull(result7);
15315 break;
15316 case 1:
15317 ((TRecExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]));
15318 G__setnull(result7);
15319 break;
15320 }
15321 return(1 || funcname || hash || result7 || libp) ;
15322}
15323
15324static int G__RootEventData_rootcint_460_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15325{
15326 switch (libp->paran) {
15327 case 2:
15328 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15329 G__setnull(result7);
15330 break;
15331 case 1:
15332 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]));
15333 G__setnull(result7);
15334 break;
15335 }
15336 return(1 || funcname || hash || result7 || libp) ;
15337}
15338
15339static int G__RootEventData_rootcint_460_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15340{
15341 switch (libp->paran) {
15342 case 2:
15343 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15344 G__setnull(result7);
15345 break;
15346 case 1:
15347 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]));
15348 G__setnull(result7);
15349 break;
15350 }
15351 return(1 || funcname || hash || result7 || libp) ;
15352}
15353
15354static int G__RootEventData_rootcint_460_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15355{
15356 switch (libp->paran) {
15357 case 2:
15358 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15359 G__setnull(result7);
15360 break;
15361 case 1:
15362 ((TRecExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]));
15363 G__setnull(result7);
15364 break;
15365 }
15366 return(1 || funcname || hash || result7 || libp) ;
15367}
15368
15369static int G__RootEventData_rootcint_460_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15370{
15371 switch (libp->paran) {
15372 case 2:
15373 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15374 G__setnull(result7);
15375 break;
15376 case 1:
15377 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]));
15378 G__setnull(result7);
15379 break;
15380 }
15381 return(1 || funcname || hash || result7 || libp) ;
15382}
15383
15384static int G__RootEventData_rootcint_460_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15385{
15386 switch (libp->paran) {
15387 case 2:
15388 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15389 G__setnull(result7);
15390 break;
15391 case 1:
15392 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]));
15393 G__setnull(result7);
15394 break;
15395 }
15396 return(1 || funcname || hash || result7 || libp) ;
15397}
15398
15399static int G__RootEventData_rootcint_460_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15400{
15401 switch (libp->paran) {
15402 case 2:
15403 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15404 G__setnull(result7);
15405 break;
15406 case 1:
15407 ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]));
15408 G__setnull(result7);
15409 break;
15410 }
15411 return(1 || funcname || hash || result7 || libp) ;
15412}
15413
15414static int G__RootEventData_rootcint_460_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15415{
15416 switch (libp->paran) {
15417 case 2:
15418 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
15419 G__setnull(result7);
15420 break;
15421 case 1:
15422 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])));
15423 G__setnull(result7);
15424 break;
15425 }
15426 return(1 || funcname || hash || result7 || libp) ;
15427}
15428
15429static int G__RootEventData_rootcint_460_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15430{
15431 switch (libp->paran) {
15432 case 2:
15433 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15434 G__setnull(result7);
15435 break;
15436 case 1:
15437 ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]));
15438 G__setnull(result7);
15439 break;
15440 }
15441 return(1 || funcname || hash || result7 || libp) ;
15442}
15443
15444static int G__RootEventData_rootcint_460_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15445{
15446 switch (libp->paran) {
15447 case 2:
15448 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15449 G__setnull(result7);
15450 break;
15451 case 1:
15452 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
15453 G__setnull(result7);
15454 break;
15455 }
15456 return(1 || funcname || hash || result7 || libp) ;
15457}
15458
15459static int G__RootEventData_rootcint_460_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15460{
15461 switch (libp->paran) {
15462 case 2:
15463 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15464 G__setnull(result7);
15465 break;
15466 case 1:
15467 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]));
15468 G__setnull(result7);
15469 break;
15470 }
15471 return(1 || funcname || hash || result7 || libp) ;
15472}
15473
15474static int G__RootEventData_rootcint_460_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15475{
15476 switch (libp->paran) {
15477 case 2:
15478 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15479 G__setnull(result7);
15480 break;
15481 case 1:
15482 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]));
15483 G__setnull(result7);
15484 break;
15485 }
15486 return(1 || funcname || hash || result7 || libp) ;
15487}
15488
15489static int G__RootEventData_rootcint_460_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15490{
15491 switch (libp->paran) {
15492 case 2:
15493 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15494 G__setnull(result7);
15495 break;
15496 case 1:
15497 ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]));
15498 G__setnull(result7);
15499 break;
15500 }
15501 return(1 || funcname || hash || result7 || libp) ;
15502}
15503
15504static int G__RootEventData_rootcint_460_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15505{
15506 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
15507 switch (libp->paran) {
15508 case 2:
15509 ((TRecExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
15510 G__setnull(result7);
15511 break;
15512 case 1:
15513 ((TRecExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a);
15514 G__setnull(result7);
15515 break;
15516 }
15517 return(1 || funcname || hash || result7 || libp) ;
15518}
15519
15520static int G__RootEventData_rootcint_460_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15521{
15522 switch (libp->paran) {
15523 case 2:
15524 ((TRecExtTrack*) G__getstructoffset())->SetSize((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
15525 G__setnull(result7);
15526 break;
15527 case 1:
15528 ((TRecExtTrack*) G__getstructoffset())->SetSize((Int_t) G__int(libp->para[0]));
15529 G__setnull(result7);
15530 break;
15531 }
15532 return(1 || funcname || hash || result7 || libp) ;
15533}
15534
15535static int G__RootEventData_rootcint_460_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15536{
15537 struct G__aRyp12 { Double_t a[1][6]; }* G__Ap12 = (struct G__aRyp12*) G__int(libp->para[12]);
15538 switch (libp->paran) {
15539 case 14:
15540 ((TRecExtTrack*) G__getstructoffset())->SetExtMucHit(
15541(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
15542, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
15543, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
15544, *((TString*) G__int(libp->para[6])), (Int_t) G__int(libp->para[7])
15545, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
15546, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
15547, G__Ap12->a, (const Int_t) G__int(libp->para[13]));
15548 G__setnull(result7);
15549 break;
15550 case 13:
15551 ((TRecExtTrack*) G__getstructoffset())->SetExtMucHit(
15552(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
15553, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
15554, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
15555, *((TString*) G__int(libp->para[6])), (Int_t) G__int(libp->para[7])
15556, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
15557, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
15558, G__Ap12->a);
15559 G__setnull(result7);
15560 break;
15561 }
15562 return(1 || funcname || hash || result7 || libp) ;
15563}
15564
15565static int G__RootEventData_rootcint_460_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15566{
15567 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTrackId());
15568 return(1 || funcname || hash || result7 || libp) ;
15569}
15570
15571static int G__RootEventData_rootcint_460_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15572{
15573 switch (libp->paran) {
15574 case 1:
15575 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionX((const Int_t) G__int(libp->para[0])));
15576 break;
15577 case 0:
15578 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionX());
15579 break;
15580 }
15581 return(1 || funcname || hash || result7 || libp) ;
15582}
15583
15584static int G__RootEventData_rootcint_460_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15585{
15586 switch (libp->paran) {
15587 case 1:
15588 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionY((const Int_t) G__int(libp->para[0])));
15589 break;
15590 case 0:
15591 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionY());
15592 break;
15593 }
15594 return(1 || funcname || hash || result7 || libp) ;
15595}
15596
15597static int G__RootEventData_rootcint_460_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15598{
15599 switch (libp->paran) {
15600 case 1:
15601 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionZ((const Int_t) G__int(libp->para[0])));
15602 break;
15603 case 0:
15604 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionZ());
15605 break;
15606 }
15607 return(1 || funcname || hash || result7 || libp) ;
15608}
15609
15610static int G__RootEventData_rootcint_460_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15611{
15612 switch (libp->paran) {
15613 case 1:
15614 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumX((const Int_t) G__int(libp->para[0])));
15615 break;
15616 case 0:
15617 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumX());
15618 break;
15619 }
15620 return(1 || funcname || hash || result7 || libp) ;
15621}
15622
15623static int G__RootEventData_rootcint_460_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15624{
15625 switch (libp->paran) {
15626 case 1:
15627 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumY((const Int_t) G__int(libp->para[0])));
15628 break;
15629 case 0:
15630 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumY());
15631 break;
15632 }
15633 return(1 || funcname || hash || result7 || libp) ;
15634}
15635
15636static int G__RootEventData_rootcint_460_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15637{
15638 switch (libp->paran) {
15639 case 1:
15640 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumZ((const Int_t) G__int(libp->para[0])));
15641 break;
15642 case 0:
15643 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumZ());
15644 break;
15645 }
15646 return(1 || funcname || hash || result7 || libp) ;
15647}
15648
15649static int G__RootEventData_rootcint_460_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15650{
15651 switch (libp->paran) {
15652 case 1:
15653 {
15654 const TString* pobj;
15655 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeName((const Int_t) G__int(libp->para[0]));
15656 pobj = new TString(xobj);
15657 result7->obj.i = (long) ((void*) pobj);
15658 result7->ref = result7->obj.i;
15659 G__store_tempobject(*result7);
15660 }
15661 break;
15662 case 0:
15663 {
15664 const TString* pobj;
15665 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeName();
15666 pobj = new TString(xobj);
15667 result7->obj.i = (long) ((void*) pobj);
15668 result7->ref = result7->obj.i;
15669 G__store_tempobject(*result7);
15670 }
15671 break;
15672 }
15673 return(1 || funcname || hash || result7 || libp) ;
15674}
15675
15676static int G__RootEventData_rootcint_460_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15677{
15678 switch (libp->paran) {
15679 case 1:
15680 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeNumber((const Int_t) G__int(libp->para[0])));
15681 break;
15682 case 0:
15683 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeNumber());
15684 break;
15685 }
15686 return(1 || funcname || hash || result7 || libp) ;
15687}
15688
15689static int G__RootEventData_rootcint_460_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15690{
15691 switch (libp->paran) {
15692 case 1:
15693 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1((const Int_t) G__int(libp->para[0])));
15694 break;
15695 case 0:
15696 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1());
15697 break;
15698 }
15699 return(1 || funcname || hash || result7 || libp) ;
15700}
15701
15702static int G__RootEventData_rootcint_460_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15703{
15704 switch (libp->paran) {
15705 case 1:
15706 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1Path((const Int_t) G__int(libp->para[0])));
15707 break;
15708 case 0:
15709 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1Path());
15710 break;
15711 }
15712 return(1 || funcname || hash || result7 || libp) ;
15713}
15714
15715static int G__RootEventData_rootcint_460_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15716{
15717 switch (libp->paran) {
15718 case 1:
15719 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
15720 break;
15721 case 0:
15722 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ());
15723 break;
15724 }
15725 return(1 || funcname || hash || result7 || libp) ;
15726}
15727
15728static int G__RootEventData_rootcint_460_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15729{
15730 switch (libp->paran) {
15731 case 1:
15732 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT((const Int_t) G__int(libp->para[0])));
15733 break;
15734 case 0:
15735 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT());
15736 break;
15737 }
15738 return(1 || funcname || hash || result7 || libp) ;
15739}
15740
15741static int G__RootEventData_rootcint_460_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15742{
15743 switch (libp->paran) {
15744 case 1:
15745 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX((const Int_t) G__int(libp->para[0])));
15746 break;
15747 case 0:
15748 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX());
15749 break;
15750 }
15751 return(1 || funcname || hash || result7 || libp) ;
15752}
15753
15754static int G__RootEventData_rootcint_460_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15755{
15756 switch (libp->paran) {
15757 case 1:
15758 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY((const Int_t) G__int(libp->para[0])));
15759 break;
15760 case 0:
15761 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY());
15762 break;
15763 }
15764 return(1 || funcname || hash || result7 || libp) ;
15765}
15766
15767static int G__RootEventData_rootcint_460_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15768{
15769 switch (libp->paran) {
15770 case 3:
15771 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
15772, (const Int_t) G__int(libp->para[2])));
15773 break;
15774 case 2:
15775 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
15776 break;
15777 }
15778 return(1 || funcname || hash || result7 || libp) ;
15779}
15780
15781static int G__RootEventData_rootcint_460_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15782{
15783 switch (libp->paran) {
15784 case 1:
15785 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionX((const Int_t) G__int(libp->para[0])));
15786 break;
15787 case 0:
15788 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionX());
15789 break;
15790 }
15791 return(1 || funcname || hash || result7 || libp) ;
15792}
15793
15794static int G__RootEventData_rootcint_460_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15795{
15796 switch (libp->paran) {
15797 case 1:
15798 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionY((const Int_t) G__int(libp->para[0])));
15799 break;
15800 case 0:
15801 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionY());
15802 break;
15803 }
15804 return(1 || funcname || hash || result7 || libp) ;
15805}
15806
15807static int G__RootEventData_rootcint_460_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15808{
15809 switch (libp->paran) {
15810 case 1:
15811 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionZ((const Int_t) G__int(libp->para[0])));
15812 break;
15813 case 0:
15814 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionZ());
15815 break;
15816 }
15817 return(1 || funcname || hash || result7 || libp) ;
15818}
15819
15820static int G__RootEventData_rootcint_460_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15821{
15822 switch (libp->paran) {
15823 case 1:
15824 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumX((const Int_t) G__int(libp->para[0])));
15825 break;
15826 case 0:
15827 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumX());
15828 break;
15829 }
15830 return(1 || funcname || hash || result7 || libp) ;
15831}
15832
15833static int G__RootEventData_rootcint_460_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15834{
15835 switch (libp->paran) {
15836 case 1:
15837 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumY((const Int_t) G__int(libp->para[0])));
15838 break;
15839 case 0:
15840 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumY());
15841 break;
15842 }
15843 return(1 || funcname || hash || result7 || libp) ;
15844}
15845
15846static int G__RootEventData_rootcint_460_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15847{
15848 switch (libp->paran) {
15849 case 1:
15850 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumZ((const Int_t) G__int(libp->para[0])));
15851 break;
15852 case 0:
15853 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumZ());
15854 break;
15855 }
15856 return(1 || funcname || hash || result7 || libp) ;
15857}
15858
15859static int G__RootEventData_rootcint_460_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15860{
15861 switch (libp->paran) {
15862 case 1:
15863 {
15864 const TString* pobj;
15865 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeName((const Int_t) G__int(libp->para[0]));
15866 pobj = new TString(xobj);
15867 result7->obj.i = (long) ((void*) pobj);
15868 result7->ref = result7->obj.i;
15869 G__store_tempobject(*result7);
15870 }
15871 break;
15872 case 0:
15873 {
15874 const TString* pobj;
15875 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeName();
15876 pobj = new TString(xobj);
15877 result7->obj.i = (long) ((void*) pobj);
15878 result7->ref = result7->obj.i;
15879 G__store_tempobject(*result7);
15880 }
15881 break;
15882 }
15883 return(1 || funcname || hash || result7 || libp) ;
15884}
15885
15886static int G__RootEventData_rootcint_460_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15887{
15888 switch (libp->paran) {
15889 case 1:
15890 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeNumber((const Int_t) G__int(libp->para[0])));
15891 break;
15892 case 0:
15893 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeNumber());
15894 break;
15895 }
15896 return(1 || funcname || hash || result7 || libp) ;
15897}
15898
15899static int G__RootEventData_rootcint_460_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15900{
15901 switch (libp->paran) {
15902 case 1:
15903 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2((const Int_t) G__int(libp->para[0])));
15904 break;
15905 case 0:
15906 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2());
15907 break;
15908 }
15909 return(1 || funcname || hash || result7 || libp) ;
15910}
15911
15912static int G__RootEventData_rootcint_460_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15913{
15914 switch (libp->paran) {
15915 case 1:
15916 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2Path((const Int_t) G__int(libp->para[0])));
15917 break;
15918 case 0:
15919 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2Path());
15920 break;
15921 }
15922 return(1 || funcname || hash || result7 || libp) ;
15923}
15924
15925static int G__RootEventData_rootcint_460_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15926{
15927 switch (libp->paran) {
15928 case 1:
15929 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
15930 break;
15931 case 0:
15932 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ());
15933 break;
15934 }
15935 return(1 || funcname || hash || result7 || libp) ;
15936}
15937
15938static int G__RootEventData_rootcint_460_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15939{
15940 switch (libp->paran) {
15941 case 1:
15942 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT((const Int_t) G__int(libp->para[0])));
15943 break;
15944 case 0:
15945 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT());
15946 break;
15947 }
15948 return(1 || funcname || hash || result7 || libp) ;
15949}
15950
15951static int G__RootEventData_rootcint_460_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15952{
15953 switch (libp->paran) {
15954 case 1:
15955 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX((const Int_t) G__int(libp->para[0])));
15956 break;
15957 case 0:
15958 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX());
15959 break;
15960 }
15961 return(1 || funcname || hash || result7 || libp) ;
15962}
15963
15964static int G__RootEventData_rootcint_460_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15965{
15966 switch (libp->paran) {
15967 case 1:
15968 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY((const Int_t) G__int(libp->para[0])));
15969 break;
15970 case 0:
15971 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY());
15972 break;
15973 }
15974 return(1 || funcname || hash || result7 || libp) ;
15975}
15976
15977static int G__RootEventData_rootcint_460_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15978{
15979 switch (libp->paran) {
15980 case 3:
15981 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
15982, (const Int_t) G__int(libp->para[2])));
15983 break;
15984 case 2:
15985 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
15986 break;
15987 }
15988 return(1 || funcname || hash || result7 || libp) ;
15989}
15990
15991static int G__RootEventData_rootcint_460_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15992{
15993 switch (libp->paran) {
15994 case 1:
15995 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionX((const Int_t) G__int(libp->para[0])));
15996 break;
15997 case 0:
15998 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionX());
15999 break;
16000 }
16001 return(1 || funcname || hash || result7 || libp) ;
16002}
16003
16004static int G__RootEventData_rootcint_460_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16005{
16006 switch (libp->paran) {
16007 case 1:
16008 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionY((const Int_t) G__int(libp->para[0])));
16009 break;
16010 case 0:
16011 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionY());
16012 break;
16013 }
16014 return(1 || funcname || hash || result7 || libp) ;
16015}
16016
16017static int G__RootEventData_rootcint_460_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16018{
16019 switch (libp->paran) {
16020 case 1:
16021 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionZ((const Int_t) G__int(libp->para[0])));
16022 break;
16023 case 0:
16024 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionZ());
16025 break;
16026 }
16027 return(1 || funcname || hash || result7 || libp) ;
16028}
16029
16030static int G__RootEventData_rootcint_460_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16031{
16032 switch (libp->paran) {
16033 case 1:
16034 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumX((const Int_t) G__int(libp->para[0])));
16035 break;
16036 case 0:
16037 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumX());
16038 break;
16039 }
16040 return(1 || funcname || hash || result7 || libp) ;
16041}
16042
16043static int G__RootEventData_rootcint_460_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16044{
16045 switch (libp->paran) {
16046 case 1:
16047 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumY((const Int_t) G__int(libp->para[0])));
16048 break;
16049 case 0:
16050 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumY());
16051 break;
16052 }
16053 return(1 || funcname || hash || result7 || libp) ;
16054}
16055
16056static int G__RootEventData_rootcint_460_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16057{
16058 switch (libp->paran) {
16059 case 1:
16060 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumZ((const Int_t) G__int(libp->para[0])));
16061 break;
16062 case 0:
16063 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumZ());
16064 break;
16065 }
16066 return(1 || funcname || hash || result7 || libp) ;
16067}
16068
16069static int G__RootEventData_rootcint_460_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16070{
16071 switch (libp->paran) {
16072 case 1:
16073 {
16074 const TString* pobj;
16075 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeName((const Int_t) G__int(libp->para[0]));
16076 pobj = new TString(xobj);
16077 result7->obj.i = (long) ((void*) pobj);
16078 result7->ref = result7->obj.i;
16079 G__store_tempobject(*result7);
16080 }
16081 break;
16082 case 0:
16083 {
16084 const TString* pobj;
16085 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeName();
16086 pobj = new TString(xobj);
16087 result7->obj.i = (long) ((void*) pobj);
16088 result7->ref = result7->obj.i;
16089 G__store_tempobject(*result7);
16090 }
16091 break;
16092 }
16093 return(1 || funcname || hash || result7 || libp) ;
16094}
16095
16096static int G__RootEventData_rootcint_460_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16097{
16098 switch (libp->paran) {
16099 case 1:
16100 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeNumber((const Int_t) G__int(libp->para[0])));
16101 break;
16102 case 0:
16103 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeNumber());
16104 break;
16105 }
16106 return(1 || funcname || hash || result7 || libp) ;
16107}
16108
16109static int G__RootEventData_rootcint_460_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16110{
16111 switch (libp->paran) {
16112 case 1:
16113 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta((const Int_t) G__int(libp->para[0])));
16114 break;
16115 case 0:
16116 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta());
16117 break;
16118 }
16119 return(1 || funcname || hash || result7 || libp) ;
16120}
16121
16122static int G__RootEventData_rootcint_460_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16123{
16124 switch (libp->paran) {
16125 case 1:
16126 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi((const Int_t) G__int(libp->para[0])));
16127 break;
16128 case 0:
16129 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi());
16130 break;
16131 }
16132 return(1 || funcname || hash || result7 || libp) ;
16133}
16134
16135static int G__RootEventData_rootcint_460_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16136{
16137 switch (libp->paran) {
16138 case 3:
16139 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
16140, (const Int_t) G__int(libp->para[2])));
16141 break;
16142 case 2:
16143 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
16144 break;
16145 }
16146 return(1 || funcname || hash || result7 || libp) ;
16147}
16148
16149static int G__RootEventData_rootcint_460_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16150{
16151 switch (libp->paran) {
16152 case 1:
16153 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->emcPath((const Int_t) G__int(libp->para[0])));
16154 break;
16155 case 0:
16156 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->emcPath());
16157 break;
16158 }
16159 return(1 || funcname || hash || result7 || libp) ;
16160}
16161
16162static int G__RootEventData_rootcint_460_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16163{
16164 switch (libp->paran) {
16165 case 1:
16166 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionX((const Int_t) G__int(libp->para[0])));
16167 break;
16168 case 0:
16169 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionX());
16170 break;
16171 }
16172 return(1 || funcname || hash || result7 || libp) ;
16173}
16174
16175static int G__RootEventData_rootcint_460_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16176{
16177 switch (libp->paran) {
16178 case 1:
16179 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionY((const Int_t) G__int(libp->para[0])));
16180 break;
16181 case 0:
16182 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionY());
16183 break;
16184 }
16185 return(1 || funcname || hash || result7 || libp) ;
16186}
16187
16188static int G__RootEventData_rootcint_460_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16189{
16190 switch (libp->paran) {
16191 case 1:
16192 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionZ((const Int_t) G__int(libp->para[0])));
16193 break;
16194 case 0:
16195 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionZ());
16196 break;
16197 }
16198 return(1 || funcname || hash || result7 || libp) ;
16199}
16200
16201static int G__RootEventData_rootcint_460_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16202{
16203 switch (libp->paran) {
16204 case 1:
16205 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumX((const Int_t) G__int(libp->para[0])));
16206 break;
16207 case 0:
16208 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumX());
16209 break;
16210 }
16211 return(1 || funcname || hash || result7 || libp) ;
16212}
16213
16214static int G__RootEventData_rootcint_460_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16215{
16216 switch (libp->paran) {
16217 case 1:
16218 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumY((const Int_t) G__int(libp->para[0])));
16219 break;
16220 case 0:
16221 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumY());
16222 break;
16223 }
16224 return(1 || funcname || hash || result7 || libp) ;
16225}
16226
16227static int G__RootEventData_rootcint_460_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16228{
16229 switch (libp->paran) {
16230 case 1:
16231 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumZ((const Int_t) G__int(libp->para[0])));
16232 break;
16233 case 0:
16234 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumZ());
16235 break;
16236 }
16237 return(1 || funcname || hash || result7 || libp) ;
16238}
16239
16240static int G__RootEventData_rootcint_460_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16241{
16242 switch (libp->paran) {
16243 case 1:
16244 {
16245 const TString* pobj;
16246 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeName((const Int_t) G__int(libp->para[0]));
16247 pobj = new TString(xobj);
16248 result7->obj.i = (long) ((void*) pobj);
16249 result7->ref = result7->obj.i;
16250 G__store_tempobject(*result7);
16251 }
16252 break;
16253 case 0:
16254 {
16255 const TString* pobj;
16256 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeName();
16257 pobj = new TString(xobj);
16258 result7->obj.i = (long) ((void*) pobj);
16259 result7->ref = result7->obj.i;
16260 G__store_tempobject(*result7);
16261 }
16262 break;
16263 }
16264 return(1 || funcname || hash || result7 || libp) ;
16265}
16266
16267static int G__RootEventData_rootcint_460_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16268{
16269 switch (libp->paran) {
16270 case 1:
16271 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeNumber((const Int_t) G__int(libp->para[0])));
16272 break;
16273 case 0:
16274 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeNumber());
16275 break;
16276 }
16277 return(1 || funcname || hash || result7 || libp) ;
16278}
16279
16280static int G__RootEventData_rootcint_460_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16281{
16282 switch (libp->paran) {
16283 case 1:
16284 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
16285 break;
16286 case 0:
16287 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ());
16288 break;
16289 }
16290 return(1 || funcname || hash || result7 || libp) ;
16291}
16292
16293static int G__RootEventData_rootcint_460_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16294{
16295 switch (libp->paran) {
16296 case 1:
16297 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT((const Int_t) G__int(libp->para[0])));
16298 break;
16299 case 0:
16300 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT());
16301 break;
16302 }
16303 return(1 || funcname || hash || result7 || libp) ;
16304}
16305
16306static int G__RootEventData_rootcint_460_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16307{
16308 switch (libp->paran) {
16309 case 1:
16310 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX((const Int_t) G__int(libp->para[0])));
16311 break;
16312 case 0:
16313 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX());
16314 break;
16315 }
16316 return(1 || funcname || hash || result7 || libp) ;
16317}
16318
16319static int G__RootEventData_rootcint_460_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16320{
16321 switch (libp->paran) {
16322 case 1:
16323 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY((const Int_t) G__int(libp->para[0])));
16324 break;
16325 case 0:
16326 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY());
16327 break;
16328 }
16329 return(1 || funcname || hash || result7 || libp) ;
16330}
16331
16332static int G__RootEventData_rootcint_460_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16333{
16334 switch (libp->paran) {
16335 case 3:
16336 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
16337, (const Int_t) G__int(libp->para[2])));
16338 break;
16339 case 2:
16340 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
16341 break;
16342 }
16343 return(1 || funcname || hash || result7 || libp) ;
16344}
16345
16346static int G__RootEventData_rootcint_460_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16347{
16348 switch (libp->paran) {
16349 case 1:
16350 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetSize((const Int_t) G__int(libp->para[0])));
16351 break;
16352 case 0:
16353 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetSize());
16354 break;
16355 }
16356 return(1 || funcname || hash || result7 || libp) ;
16357}
16358
16359static int G__RootEventData_rootcint_460_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16360{
16361 switch (libp->paran) {
16362 case 2:
16363 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionX((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16364 break;
16365 case 1:
16366 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionX((Int_t) G__int(libp->para[0])));
16367 break;
16368 }
16369 return(1 || funcname || hash || result7 || libp) ;
16370}
16371
16372static int G__RootEventData_rootcint_460_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16373{
16374 switch (libp->paran) {
16375 case 2:
16376 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionY((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16377 break;
16378 case 1:
16379 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionY((Int_t) G__int(libp->para[0])));
16380 break;
16381 }
16382 return(1 || funcname || hash || result7 || libp) ;
16383}
16384
16385static int G__RootEventData_rootcint_460_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16386{
16387 switch (libp->paran) {
16388 case 2:
16389 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionZ((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16390 break;
16391 case 1:
16392 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionZ((Int_t) G__int(libp->para[0])));
16393 break;
16394 }
16395 return(1 || funcname || hash || result7 || libp) ;
16396}
16397
16398static int G__RootEventData_rootcint_460_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16399{
16400 switch (libp->paran) {
16401 case 2:
16402 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumX((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16403 break;
16404 case 1:
16405 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumX((Int_t) G__int(libp->para[0])));
16406 break;
16407 }
16408 return(1 || funcname || hash || result7 || libp) ;
16409}
16410
16411static int G__RootEventData_rootcint_460_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16412{
16413 switch (libp->paran) {
16414 case 2:
16415 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumY((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16416 break;
16417 case 1:
16418 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumY((Int_t) G__int(libp->para[0])));
16419 break;
16420 }
16421 return(1 || funcname || hash || result7 || libp) ;
16422}
16423
16424static int G__RootEventData_rootcint_460_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16425{
16426 switch (libp->paran) {
16427 case 2:
16428 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumZ((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16429 break;
16430 case 1:
16431 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumZ((Int_t) G__int(libp->para[0])));
16432 break;
16433 }
16434 return(1 || funcname || hash || result7 || libp) ;
16435}
16436
16437static int G__RootEventData_rootcint_460_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16438{
16439 switch (libp->paran) {
16440 case 2:
16441 {
16442 const TString* pobj;
16443 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetVolumeName((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
16444 pobj = new TString(xobj);
16445 result7->obj.i = (long) ((void*) pobj);
16446 result7->ref = result7->obj.i;
16447 G__store_tempobject(*result7);
16448 }
16449 break;
16450 case 1:
16451 {
16452 const TString* pobj;
16453 const TString xobj = ((const TRecExtTrack*) G__getstructoffset())->GetVolumeName((Int_t) G__int(libp->para[0]));
16454 pobj = new TString(xobj);
16455 result7->obj.i = (long) ((void*) pobj);
16456 result7->ref = result7->obj.i;
16457 G__store_tempobject(*result7);
16458 }
16459 break;
16460 }
16461 return(1 || funcname || hash || result7 || libp) ;
16462}
16463
16464static int G__RootEventData_rootcint_460_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16465{
16466 switch (libp->paran) {
16467 case 2:
16468 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetVolumeNumber((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16469 break;
16470 case 1:
16471 G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetVolumeNumber((Int_t) G__int(libp->para[0])));
16472 break;
16473 }
16474 return(1 || funcname || hash || result7 || libp) ;
16475}
16476
16477static int G__RootEventData_rootcint_460_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16478{
16479 switch (libp->paran) {
16480 case 2:
16481 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongZ((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16482 break;
16483 case 1:
16484 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongZ((Int_t) G__int(libp->para[0])));
16485 break;
16486 }
16487 return(1 || funcname || hash || result7 || libp) ;
16488}
16489
16490static int G__RootEventData_rootcint_460_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16491{
16492 switch (libp->paran) {
16493 case 2:
16494 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongT((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16495 break;
16496 case 1:
16497 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongT((Int_t) G__int(libp->para[0])));
16498 break;
16499 }
16500 return(1 || funcname || hash || result7 || libp) ;
16501}
16502
16503static int G__RootEventData_rootcint_460_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16504{
16505 switch (libp->paran) {
16506 case 2:
16507 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongX((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16508 break;
16509 case 1:
16510 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongX((Int_t) G__int(libp->para[0])));
16511 break;
16512 }
16513 return(1 || funcname || hash || result7 || libp) ;
16514}
16515
16516static int G__RootEventData_rootcint_460_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16517{
16518 switch (libp->paran) {
16519 case 2:
16520 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongY((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
16521 break;
16522 case 1:
16523 G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongY((Int_t) G__int(libp->para[0])));
16524 break;
16525 }
16526 return(1 || funcname || hash || result7 || libp) ;
16527}
16528
16529static int G__RootEventData_rootcint_460_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16530{
16531 switch (libp->paran) {
16532 case 2:
16533 {
16534 const vector<Double_t>* pobj;
16535 const vector<Double_t> xobj = ((const TRecExtTrack*) G__getstructoffset())->GetErrorMatrix((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
16536 pobj = new vector<Double_t>(xobj);
16537 result7->obj.i = (long) ((void*) pobj);
16538 result7->ref = result7->obj.i;
16539 G__store_tempobject(*result7);
16540 }
16541 break;
16542 case 1:
16543 {
16544 const vector<Double_t>* pobj;
16545 const vector<Double_t> xobj = ((const TRecExtTrack*) G__getstructoffset())->GetErrorMatrix((Int_t) G__int(libp->para[0]));
16546 pobj = new vector<Double_t>(xobj);
16547 result7->obj.i = (long) ((void*) pobj);
16548 result7->ref = result7->obj.i;
16549 G__store_tempobject(*result7);
16550 }
16551 break;
16552 }
16553 return(1 || funcname || hash || result7 || libp) ;
16554}
16555
16556static int G__RootEventData_rootcint_460_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16557{
16558 G__letint(result7, 85, (long) TRecExtTrack::Class());
16559 return(1 || funcname || hash || result7 || libp) ;
16560}
16561
16562static int G__RootEventData_rootcint_460_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16563{
16564 G__letint(result7, 67, (long) TRecExtTrack::Class_Name());
16565 return(1 || funcname || hash || result7 || libp) ;
16566}
16567
16568static int G__RootEventData_rootcint_460_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16569{
16570 G__letint(result7, 115, (long) TRecExtTrack::Class_Version());
16571 return(1 || funcname || hash || result7 || libp) ;
16572}
16573
16574static int G__RootEventData_rootcint_460_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16575{
16576 TRecExtTrack::Dictionary();
16577 G__setnull(result7);
16578 return(1 || funcname || hash || result7 || libp) ;
16579}
16580
16581static int G__RootEventData_rootcint_460_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16582{
16583 ((TRecExtTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
16584 G__setnull(result7);
16585 return(1 || funcname || hash || result7 || libp) ;
16586}
16587
16588static int G__RootEventData_rootcint_460_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16589{
16590 G__letint(result7, 67, (long) TRecExtTrack::DeclFileName());
16591 return(1 || funcname || hash || result7 || libp) ;
16592}
16593
16594static int G__RootEventData_rootcint_460_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16595{
16596 G__letint(result7, 105, (long) TRecExtTrack::ImplFileLine());
16597 return(1 || funcname || hash || result7 || libp) ;
16598}
16599
16600static int G__RootEventData_rootcint_460_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16601{
16602 G__letint(result7, 67, (long) TRecExtTrack::ImplFileName());
16603 return(1 || funcname || hash || result7 || libp) ;
16604}
16605
16606static int G__RootEventData_rootcint_460_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16607{
16608 G__letint(result7, 105, (long) TRecExtTrack::DeclFileLine());
16609 return(1 || funcname || hash || result7 || libp) ;
16610}
16611
16612// automatic copy constructor
16613static int G__RootEventData_rootcint_460_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16614
16615{
16616 TRecExtTrack* p;
16617 void* tmp = (void*) G__int(libp->para[0]);
16618 p = new TRecExtTrack(*(TRecExtTrack*) tmp);
16619 result7->obj.i = (long) p;
16620 result7->ref = (long) p;
16621 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
16622 return(1 || funcname || hash || result7 || libp) ;
16623}
16624
16625// automatic destructor
16626typedef TRecExtTrack G__TTRecExtTrack;
16627static int G__RootEventData_rootcint_460_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16628{
16629 char* gvp = (char*) G__getgvp();
16630 long soff = G__getstructoffset();
16631 int n = G__getaryconstruct();
16632 //
16633 //has_a_delete: 1
16634 //has_own_delete1arg: 0
16635 //has_own_delete2arg: 0
16636 //
16637 if (!soff) {
16638 return(1);
16639 }
16640 if (n) {
16641 if (gvp == (char*)G__PVOID) {
16642 delete[] (TRecExtTrack*) soff;
16643 } else {
16644 G__setgvp((long) G__PVOID);
16645 for (int i = n - 1; i >= 0; --i) {
16646 ((TRecExtTrack*) (soff+(sizeof(TRecExtTrack)*i)))->~G__TTRecExtTrack();
16647 }
16648 G__setgvp((long)gvp);
16649 }
16650 } else {
16651 if (gvp == (char*)G__PVOID) {
16652 delete (TRecExtTrack*) soff;
16653 } else {
16654 G__setgvp((long) G__PVOID);
16655 ((TRecExtTrack*) (soff))->~G__TTRecExtTrack();
16656 G__setgvp((long)gvp);
16657 }
16658 }
16659 G__setnull(result7);
16660 return(1 || funcname || hash || result7 || libp) ;
16661}
16662
16663// automatic assignment operator
16664static int G__RootEventData_rootcint_460_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16665{
16666 TRecExtTrack* dest = (TRecExtTrack*) G__getstructoffset();
16667 *dest = *(TRecExtTrack*) libp->para[0].ref;
16668 const TRecExtTrack& obj = *dest;
16669 result7->ref = (long) (&obj);
16670 result7->obj.i = (long) (&obj);
16671 return(1 || funcname || hash || result7 || libp) ;
16672}
16673
16674
16675/* TRecEvTime */
16676static int G__RootEventData_rootcint_469_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16677{
16678 TRecEvTime* p = NULL;
16679 char* gvp = (char*) G__getgvp();
16680 int n = G__getaryconstruct();
16681 if (n) {
16682 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16683 p = new TRecEvTime[n];
16684 } else {
16685 p = new((void*) gvp) TRecEvTime[n];
16686 }
16687 } else {
16688 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16689 p = new TRecEvTime;
16690 } else {
16691 p = new((void*) gvp) TRecEvTime;
16692 }
16693 }
16694 result7->obj.i = (long) p;
16695 result7->ref = (long) p;
16696 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
16697 return(1 || funcname || hash || result7 || libp) ;
16698}
16699
16700static int G__RootEventData_rootcint_469_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16701{
16702 G__letint(result7, 105, (long) ((const TRecEvTime*) G__getstructoffset())->status());
16703 return(1 || funcname || hash || result7 || libp) ;
16704}
16705
16706static int G__RootEventData_rootcint_469_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16707{
16708 G__letdouble(result7, 100, (double) ((const TRecEvTime*) G__getstructoffset())->estime());
16709 return(1 || funcname || hash || result7 || libp) ;
16710}
16711
16712static int G__RootEventData_rootcint_469_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16713{
16714 G__letdouble(result7, 100, (double) ((const TRecEvTime*) G__getstructoffset())->quality());
16715 return(1 || funcname || hash || result7 || libp) ;
16716}
16717
16718static int G__RootEventData_rootcint_469_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16719{
16720 ((TRecEvTime*) G__getstructoffset())->setTest((Double_t) G__double(libp->para[0]));
16721 G__setnull(result7);
16722 return(1 || funcname || hash || result7 || libp) ;
16723}
16724
16725static int G__RootEventData_rootcint_469_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16726{
16727 ((TRecEvTime*) G__getstructoffset())->setStats((Int_t) G__int(libp->para[0]));
16728 G__setnull(result7);
16729 return(1 || funcname || hash || result7 || libp) ;
16730}
16731
16732static int G__RootEventData_rootcint_469_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16733{
16734 ((TRecEvTime*) G__getstructoffset())->setQuality((Double_t) G__double(libp->para[0]));
16735 G__setnull(result7);
16736 return(1 || funcname || hash || result7 || libp) ;
16737}
16738
16739static int G__RootEventData_rootcint_469_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16740{
16741 G__letint(result7, 85, (long) TRecEvTime::Class());
16742 return(1 || funcname || hash || result7 || libp) ;
16743}
16744
16745static int G__RootEventData_rootcint_469_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16746{
16747 G__letint(result7, 67, (long) TRecEvTime::Class_Name());
16748 return(1 || funcname || hash || result7 || libp) ;
16749}
16750
16751static int G__RootEventData_rootcint_469_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16752{
16753 G__letint(result7, 115, (long) TRecEvTime::Class_Version());
16754 return(1 || funcname || hash || result7 || libp) ;
16755}
16756
16757static int G__RootEventData_rootcint_469_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16758{
16759 TRecEvTime::Dictionary();
16760 G__setnull(result7);
16761 return(1 || funcname || hash || result7 || libp) ;
16762}
16763
16764static int G__RootEventData_rootcint_469_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16765{
16766 ((TRecEvTime*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
16767 G__setnull(result7);
16768 return(1 || funcname || hash || result7 || libp) ;
16769}
16770
16771static int G__RootEventData_rootcint_469_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16772{
16773 G__letint(result7, 67, (long) TRecEvTime::DeclFileName());
16774 return(1 || funcname || hash || result7 || libp) ;
16775}
16776
16777static int G__RootEventData_rootcint_469_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16778{
16779 G__letint(result7, 105, (long) TRecEvTime::ImplFileLine());
16780 return(1 || funcname || hash || result7 || libp) ;
16781}
16782
16783static int G__RootEventData_rootcint_469_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16784{
16785 G__letint(result7, 67, (long) TRecEvTime::ImplFileName());
16786 return(1 || funcname || hash || result7 || libp) ;
16787}
16788
16789static int G__RootEventData_rootcint_469_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16790{
16791 G__letint(result7, 105, (long) TRecEvTime::DeclFileLine());
16792 return(1 || funcname || hash || result7 || libp) ;
16793}
16794
16795// automatic copy constructor
16796static int G__RootEventData_rootcint_469_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16797
16798{
16799 TRecEvTime* p;
16800 void* tmp = (void*) G__int(libp->para[0]);
16801 p = new TRecEvTime(*(TRecEvTime*) tmp);
16802 result7->obj.i = (long) p;
16803 result7->ref = (long) p;
16804 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
16805 return(1 || funcname || hash || result7 || libp) ;
16806}
16807
16808// automatic destructor
16809typedef TRecEvTime G__TTRecEvTime;
16810static int G__RootEventData_rootcint_469_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16811{
16812 char* gvp = (char*) G__getgvp();
16813 long soff = G__getstructoffset();
16814 int n = G__getaryconstruct();
16815 //
16816 //has_a_delete: 1
16817 //has_own_delete1arg: 0
16818 //has_own_delete2arg: 0
16819 //
16820 if (!soff) {
16821 return(1);
16822 }
16823 if (n) {
16824 if (gvp == (char*)G__PVOID) {
16825 delete[] (TRecEvTime*) soff;
16826 } else {
16827 G__setgvp((long) G__PVOID);
16828 for (int i = n - 1; i >= 0; --i) {
16829 ((TRecEvTime*) (soff+(sizeof(TRecEvTime)*i)))->~G__TTRecEvTime();
16830 }
16831 G__setgvp((long)gvp);
16832 }
16833 } else {
16834 if (gvp == (char*)G__PVOID) {
16835 delete (TRecEvTime*) soff;
16836 } else {
16837 G__setgvp((long) G__PVOID);
16838 ((TRecEvTime*) (soff))->~G__TTRecEvTime();
16839 G__setgvp((long)gvp);
16840 }
16841 }
16842 G__setnull(result7);
16843 return(1 || funcname || hash || result7 || libp) ;
16844}
16845
16846// automatic assignment operator
16847static int G__RootEventData_rootcint_469_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16848{
16849 TRecEvTime* dest = (TRecEvTime*) G__getstructoffset();
16850 *dest = *(TRecEvTime*) libp->para[0].ref;
16851 const TRecEvTime& obj = *dest;
16852 result7->ref = (long) (&obj);
16853 result7->obj.i = (long) (&obj);
16854 return(1 || funcname || hash || result7 || libp) ;
16855}
16856
16857
16858/* TRecMdcKalHelixSeg */
16859static int G__RootEventData_rootcint_470_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16860{
16861 TRecMdcKalHelixSeg* p = NULL;
16862 char* gvp = (char*) G__getgvp();
16863 int n = G__getaryconstruct();
16864 if (n) {
16865 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16866 p = new TRecMdcKalHelixSeg[n];
16867 } else {
16868 p = new((void*) gvp) TRecMdcKalHelixSeg[n];
16869 }
16870 } else {
16871 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
16872 p = new TRecMdcKalHelixSeg;
16873 } else {
16874 p = new((void*) gvp) TRecMdcKalHelixSeg;
16875 }
16876 }
16877 result7->obj.i = (long) p;
16878 result7->ref = (long) p;
16879 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
16880 return(1 || funcname || hash || result7 || libp) ;
16881}
16882
16883static int G__RootEventData_rootcint_470_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16884{
16885 G__letint(result7, 105, (long) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTrackId());
16886 return(1 || funcname || hash || result7 || libp) ;
16887}
16888
16889static int G__RootEventData_rootcint_470_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16890{
16891 G__letint(result7, 105, (long) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getFlagLR());
16892 return(1 || funcname || hash || result7 || libp) ;
16893}
16894
16895static int G__RootEventData_rootcint_470_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16896{
16897 G__letint(result7, 104, (long) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getMdcId());
16898 return(1 || funcname || hash || result7 || libp) ;
16899}
16900
16901static int G__RootEventData_rootcint_470_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16902{
16903 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTdc());
16904 return(1 || funcname || hash || result7 || libp) ;
16905}
16906
16907static int G__RootEventData_rootcint_470_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16908{
16909 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getAdc());
16910 return(1 || funcname || hash || result7 || libp) ;
16911}
16912
16913static int G__RootEventData_rootcint_470_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16914{
16915 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getZhit());
16916 return(1 || funcname || hash || result7 || libp) ;
16917}
16918
16919static int G__RootEventData_rootcint_470_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16920{
16921 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTof());
16922 return(1 || funcname || hash || result7 || libp) ;
16923}
16924
16925static int G__RootEventData_rootcint_470_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16926{
16927 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDocaIncl());
16928 return(1 || funcname || hash || result7 || libp) ;
16929}
16930
16931static int G__RootEventData_rootcint_470_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16932{
16933 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDocaExcl());
16934 return(1 || funcname || hash || result7 || libp) ;
16935}
16936
16937static int G__RootEventData_rootcint_470_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16938{
16939 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDD());
16940 return(1 || funcname || hash || result7 || libp) ;
16941}
16942
16943static int G__RootEventData_rootcint_470_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16944{
16945 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getEntra());
16946 return(1 || funcname || hash || result7 || libp) ;
16947}
16948
16949static int G__RootEventData_rootcint_470_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16950{
16951 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDT());
16952 return(1 || funcname || hash || result7 || libp) ;
16953}
16954
16955static int G__RootEventData_rootcint_470_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16956{
16957 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getHelixIncl((Int_t) G__int(libp->para[0])));
16958 return(1 || funcname || hash || result7 || libp) ;
16959}
16960
16961static int G__RootEventData_rootcint_470_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16962{
16963 G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getHelixExcl((Int_t) G__int(libp->para[0])));
16964 return(1 || funcname || hash || result7 || libp) ;
16965}
16966
16967static int G__RootEventData_rootcint_470_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16968{
16969 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
16970 G__setnull(result7);
16971 return(1 || funcname || hash || result7 || libp) ;
16972}
16973
16974static int G__RootEventData_rootcint_470_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16975{
16976 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
16977 G__setnull(result7);
16978 return(1 || funcname || hash || result7 || libp) ;
16979}
16980
16981static int G__RootEventData_rootcint_470_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16982{
16983 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
16984 G__setnull(result7);
16985 return(1 || funcname || hash || result7 || libp) ;
16986}
16987
16988static int G__RootEventData_rootcint_470_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16989{
16990 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTdc((Double_t) G__double(libp->para[0]));
16991 G__setnull(result7);
16992 return(1 || funcname || hash || result7 || libp) ;
16993}
16994
16995static int G__RootEventData_rootcint_470_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
16996{
16997 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setAdc((Double_t) G__double(libp->para[0]));
16998 G__setnull(result7);
16999 return(1 || funcname || hash || result7 || libp) ;
17000}
17001
17002static int G__RootEventData_rootcint_470_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17003{
17004 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setZhit((Double_t) G__double(libp->para[0]));
17005 G__setnull(result7);
17006 return(1 || funcname || hash || result7 || libp) ;
17007}
17008
17009static int G__RootEventData_rootcint_470_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17010{
17011 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
17012 G__setnull(result7);
17013 return(1 || funcname || hash || result7 || libp) ;
17014}
17015
17016static int G__RootEventData_rootcint_470_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17017{
17018 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDocaIncl((Double_t) G__double(libp->para[0]));
17019 G__setnull(result7);
17020 return(1 || funcname || hash || result7 || libp) ;
17021}
17022
17023static int G__RootEventData_rootcint_470_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17024{
17025 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDocaExcl((Double_t) G__double(libp->para[0]));
17026 G__setnull(result7);
17027 return(1 || funcname || hash || result7 || libp) ;
17028}
17029
17030static int G__RootEventData_rootcint_470_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17031{
17032 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDD((Double_t) G__double(libp->para[0]));
17033 G__setnull(result7);
17034 return(1 || funcname || hash || result7 || libp) ;
17035}
17036
17037static int G__RootEventData_rootcint_470_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17038{
17039 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setEntra((Double_t) G__double(libp->para[0]));
17040 G__setnull(result7);
17041 return(1 || funcname || hash || result7 || libp) ;
17042}
17043
17044static int G__RootEventData_rootcint_470_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17045{
17046 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDT((Double_t) G__double(libp->para[0]));
17047 G__setnull(result7);
17048 return(1 || funcname || hash || result7 || libp) ;
17049}
17050
17051static int G__RootEventData_rootcint_470_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17052{
17053 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setHelixIncl((Double_t*) G__int(libp->para[0]));
17054 G__setnull(result7);
17055 return(1 || funcname || hash || result7 || libp) ;
17056}
17057
17058static int G__RootEventData_rootcint_470_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17059{
17060 ((TRecMdcKalHelixSeg*) G__getstructoffset())->setHelixExcl((Double_t*) G__int(libp->para[0]));
17061 G__setnull(result7);
17062 return(1 || funcname || hash || result7 || libp) ;
17063}
17064
17065static int G__RootEventData_rootcint_470_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17066{
17067 G__letint(result7, 85, (long) TRecMdcKalHelixSeg::Class());
17068 return(1 || funcname || hash || result7 || libp) ;
17069}
17070
17071static int G__RootEventData_rootcint_470_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17072{
17073 G__letint(result7, 67, (long) TRecMdcKalHelixSeg::Class_Name());
17074 return(1 || funcname || hash || result7 || libp) ;
17075}
17076
17077static int G__RootEventData_rootcint_470_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17078{
17079 G__letint(result7, 115, (long) TRecMdcKalHelixSeg::Class_Version());
17080 return(1 || funcname || hash || result7 || libp) ;
17081}
17082
17083static int G__RootEventData_rootcint_470_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17084{
17085 TRecMdcKalHelixSeg::Dictionary();
17086 G__setnull(result7);
17087 return(1 || funcname || hash || result7 || libp) ;
17088}
17089
17090static int G__RootEventData_rootcint_470_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17091{
17092 ((TRecMdcKalHelixSeg*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
17093 G__setnull(result7);
17094 return(1 || funcname || hash || result7 || libp) ;
17095}
17096
17097static int G__RootEventData_rootcint_470_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17098{
17099 G__letint(result7, 67, (long) TRecMdcKalHelixSeg::DeclFileName());
17100 return(1 || funcname || hash || result7 || libp) ;
17101}
17102
17103static int G__RootEventData_rootcint_470_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17104{
17105 G__letint(result7, 105, (long) TRecMdcKalHelixSeg::ImplFileLine());
17106 return(1 || funcname || hash || result7 || libp) ;
17107}
17108
17109static int G__RootEventData_rootcint_470_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17110{
17111 G__letint(result7, 67, (long) TRecMdcKalHelixSeg::ImplFileName());
17112 return(1 || funcname || hash || result7 || libp) ;
17113}
17114
17115static int G__RootEventData_rootcint_470_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17116{
17117 G__letint(result7, 105, (long) TRecMdcKalHelixSeg::DeclFileLine());
17118 return(1 || funcname || hash || result7 || libp) ;
17119}
17120
17121// automatic copy constructor
17122static int G__RootEventData_rootcint_470_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17123
17124{
17125 TRecMdcKalHelixSeg* p;
17126 void* tmp = (void*) G__int(libp->para[0]);
17127 p = new TRecMdcKalHelixSeg(*(TRecMdcKalHelixSeg*) tmp);
17128 result7->obj.i = (long) p;
17129 result7->ref = (long) p;
17130 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
17131 return(1 || funcname || hash || result7 || libp) ;
17132}
17133
17134// automatic destructor
17135typedef TRecMdcKalHelixSeg G__TTRecMdcKalHelixSeg;
17136static int G__RootEventData_rootcint_470_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17137{
17138 char* gvp = (char*) G__getgvp();
17139 long soff = G__getstructoffset();
17140 int n = G__getaryconstruct();
17141 //
17142 //has_a_delete: 1
17143 //has_own_delete1arg: 0
17144 //has_own_delete2arg: 0
17145 //
17146 if (!soff) {
17147 return(1);
17148 }
17149 if (n) {
17150 if (gvp == (char*)G__PVOID) {
17151 delete[] (TRecMdcKalHelixSeg*) soff;
17152 } else {
17153 G__setgvp((long) G__PVOID);
17154 for (int i = n - 1; i >= 0; --i) {
17155 ((TRecMdcKalHelixSeg*) (soff+(sizeof(TRecMdcKalHelixSeg)*i)))->~G__TTRecMdcKalHelixSeg();
17156 }
17157 G__setgvp((long)gvp);
17158 }
17159 } else {
17160 if (gvp == (char*)G__PVOID) {
17161 delete (TRecMdcKalHelixSeg*) soff;
17162 } else {
17163 G__setgvp((long) G__PVOID);
17164 ((TRecMdcKalHelixSeg*) (soff))->~G__TTRecMdcKalHelixSeg();
17165 G__setgvp((long)gvp);
17166 }
17167 }
17168 G__setnull(result7);
17169 return(1 || funcname || hash || result7 || libp) ;
17170}
17171
17172// automatic assignment operator
17173static int G__RootEventData_rootcint_470_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17174{
17175 TRecMdcKalHelixSeg* dest = (TRecMdcKalHelixSeg*) G__getstructoffset();
17176 *dest = *(TRecMdcKalHelixSeg*) libp->para[0].ref;
17177 const TRecMdcKalHelixSeg& obj = *dest;
17178 result7->ref = (long) (&obj);
17179 result7->obj.i = (long) (&obj);
17180 return(1 || funcname || hash || result7 || libp) ;
17181}
17182
17183
17184/* TRecZddChannel */
17185static int G__RootEventData_rootcint_471_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17186{
17187 TRecZddChannel* p = NULL;
17188 char* gvp = (char*) G__getgvp();
17189 int n = G__getaryconstruct();
17190 if (n) {
17191 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17192 p = new TRecZddChannel[n];
17193 } else {
17194 p = new((void*) gvp) TRecZddChannel[n];
17195 }
17196 } else {
17197 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17198 p = new TRecZddChannel;
17199 } else {
17200 p = new((void*) gvp) TRecZddChannel;
17201 }
17202 }
17203 result7->obj.i = (long) p;
17204 result7->ref = (long) p;
17205 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
17206 return(1 || funcname || hash || result7 || libp) ;
17207}
17208
17209static int G__RootEventData_rootcint_471_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17210{
17211 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->channelId());
17212 return(1 || funcname || hash || result7 || libp) ;
17213}
17214
17215static int G__RootEventData_rootcint_471_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17216{
17217 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->scanCode());
17218 return(1 || funcname || hash || result7 || libp) ;
17219}
17220
17221static int G__RootEventData_rootcint_471_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17222{
17223 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->baseLine());
17224 return(1 || funcname || hash || result7 || libp) ;
17225}
17226
17227static int G__RootEventData_rootcint_471_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17228{
17229 G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->phase());
17230 return(1 || funcname || hash || result7 || libp) ;
17231}
17232
17233static int G__RootEventData_rootcint_471_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17234{
17235 {
17236 const TRecZddChannel::Fragments& obj = ((const TRecZddChannel*) G__getstructoffset())->fragments();
17237 result7->ref = (long) (&obj);
17238 result7->obj.i = (long) (&obj);
17239 }
17240 return(1 || funcname || hash || result7 || libp) ;
17241}
17242
17243static int G__RootEventData_rootcint_471_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17244{
17245 ((TRecZddChannel*) G__getstructoffset())->setChannelId((int) G__int(libp->para[0]));
17246 G__setnull(result7);
17247 return(1 || funcname || hash || result7 || libp) ;
17248}
17249
17250static int G__RootEventData_rootcint_471_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17251{
17252 ((TRecZddChannel*) G__getstructoffset())->setScanCode((int) G__int(libp->para[0]));
17253 G__setnull(result7);
17254 return(1 || funcname || hash || result7 || libp) ;
17255}
17256
17257static int G__RootEventData_rootcint_471_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17258{
17259 ((TRecZddChannel*) G__getstructoffset())->setBaseLine((int) G__int(libp->para[0]));
17260 G__setnull(result7);
17261 return(1 || funcname || hash || result7 || libp) ;
17262}
17263
17264static int G__RootEventData_rootcint_471_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17265{
17266 ((TRecZddChannel*) G__getstructoffset())->setPhase((int) G__int(libp->para[0]));
17267 G__setnull(result7);
17268 return(1 || funcname || hash || result7 || libp) ;
17269}
17270
17271static int G__RootEventData_rootcint_471_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17272{
17273 ((TRecZddChannel*) G__getstructoffset())->setFragments(*(TRecZddChannel::Fragments*) libp->para[0].ref);
17274 G__setnull(result7);
17275 return(1 || funcname || hash || result7 || libp) ;
17276}
17277
17278static int G__RootEventData_rootcint_471_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17279{
17280 G__letint(result7, 85, (long) TRecZddChannel::Class());
17281 return(1 || funcname || hash || result7 || libp) ;
17282}
17283
17284static int G__RootEventData_rootcint_471_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17285{
17286 G__letint(result7, 67, (long) TRecZddChannel::Class_Name());
17287 return(1 || funcname || hash || result7 || libp) ;
17288}
17289
17290static int G__RootEventData_rootcint_471_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17291{
17292 G__letint(result7, 115, (long) TRecZddChannel::Class_Version());
17293 return(1 || funcname || hash || result7 || libp) ;
17294}
17295
17296static int G__RootEventData_rootcint_471_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17297{
17298 TRecZddChannel::Dictionary();
17299 G__setnull(result7);
17300 return(1 || funcname || hash || result7 || libp) ;
17301}
17302
17303static int G__RootEventData_rootcint_471_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17304{
17305 ((TRecZddChannel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
17306 G__setnull(result7);
17307 return(1 || funcname || hash || result7 || libp) ;
17308}
17309
17310static int G__RootEventData_rootcint_471_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17311{
17312 G__letint(result7, 67, (long) TRecZddChannel::DeclFileName());
17313 return(1 || funcname || hash || result7 || libp) ;
17314}
17315
17316static int G__RootEventData_rootcint_471_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17317{
17318 G__letint(result7, 105, (long) TRecZddChannel::ImplFileLine());
17319 return(1 || funcname || hash || result7 || libp) ;
17320}
17321
17322static int G__RootEventData_rootcint_471_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17323{
17324 G__letint(result7, 67, (long) TRecZddChannel::ImplFileName());
17325 return(1 || funcname || hash || result7 || libp) ;
17326}
17327
17328static int G__RootEventData_rootcint_471_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17329{
17330 G__letint(result7, 105, (long) TRecZddChannel::DeclFileLine());
17331 return(1 || funcname || hash || result7 || libp) ;
17332}
17333
17334// automatic copy constructor
17335static int G__RootEventData_rootcint_471_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17336
17337{
17338 TRecZddChannel* p;
17339 void* tmp = (void*) G__int(libp->para[0]);
17340 p = new TRecZddChannel(*(TRecZddChannel*) tmp);
17341 result7->obj.i = (long) p;
17342 result7->ref = (long) p;
17343 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
17344 return(1 || funcname || hash || result7 || libp) ;
17345}
17346
17347// automatic destructor
17348typedef TRecZddChannel G__TTRecZddChannel;
17349static int G__RootEventData_rootcint_471_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17350{
17351 char* gvp = (char*) G__getgvp();
17352 long soff = G__getstructoffset();
17353 int n = G__getaryconstruct();
17354 //
17355 //has_a_delete: 1
17356 //has_own_delete1arg: 0
17357 //has_own_delete2arg: 0
17358 //
17359 if (!soff) {
17360 return(1);
17361 }
17362 if (n) {
17363 if (gvp == (char*)G__PVOID) {
17364 delete[] (TRecZddChannel*) soff;
17365 } else {
17366 G__setgvp((long) G__PVOID);
17367 for (int i = n - 1; i >= 0; --i) {
17368 ((TRecZddChannel*) (soff+(sizeof(TRecZddChannel)*i)))->~G__TTRecZddChannel();
17369 }
17370 G__setgvp((long)gvp);
17371 }
17372 } else {
17373 if (gvp == (char*)G__PVOID) {
17374 delete (TRecZddChannel*) soff;
17375 } else {
17376 G__setgvp((long) G__PVOID);
17377 ((TRecZddChannel*) (soff))->~G__TTRecZddChannel();
17378 G__setgvp((long)gvp);
17379 }
17380 }
17381 G__setnull(result7);
17382 return(1 || funcname || hash || result7 || libp) ;
17383}
17384
17385// automatic assignment operator
17386static int G__RootEventData_rootcint_471_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17387{
17388 TRecZddChannel* dest = (TRecZddChannel*) G__getstructoffset();
17389 *dest = *(TRecZddChannel*) libp->para[0].ref;
17390 const TRecZddChannel& obj = *dest;
17391 result7->ref = (long) (&obj);
17392 result7->obj.i = (long) (&obj);
17393 return(1 || funcname || hash || result7 || libp) ;
17394}
17395
17396
17397/* TRecTrackEvent */
17398static int G__RootEventData_rootcint_477_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17399{
17400 TRecTrackEvent* p = NULL;
17401 char* gvp = (char*) G__getgvp();
17402 int n = G__getaryconstruct();
17403 if (n) {
17404 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17405 p = new TRecTrackEvent[n];
17406 } else {
17407 p = new((void*) gvp) TRecTrackEvent[n];
17408 }
17409 } else {
17410 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17411 p = new TRecTrackEvent;
17412 } else {
17413 p = new((void*) gvp) TRecTrackEvent;
17414 }
17415 }
17416 result7->obj.i = (long) p;
17417 result7->ref = (long) p;
17418 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
17419 return(1 || funcname || hash || result7 || libp) ;
17420}
17421
17422static int G__RootEventData_rootcint_477_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17423{
17424 ((TRecTrackEvent*) G__getstructoffset())->initialize();
17425 G__setnull(result7);
17426 return(1 || funcname || hash || result7 || libp) ;
17427}
17428
17429static int G__RootEventData_rootcint_477_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17430{
17431 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcTrackCol());
17432 return(1 || funcname || hash || result7 || libp) ;
17433}
17434
17435static int G__RootEventData_rootcint_477_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17436{
17437 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
17438 G__setnull(result7);
17439 return(1 || funcname || hash || result7 || libp) ;
17440}
17441
17442static int G__RootEventData_rootcint_477_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17443{
17444 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcTrack((Int_t) G__int(libp->para[0])));
17445 return(1 || funcname || hash || result7 || libp) ;
17446}
17447
17448static int G__RootEventData_rootcint_477_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17449{
17450 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcTrackCol();
17451 G__setnull(result7);
17452 return(1 || funcname || hash || result7 || libp) ;
17453}
17454
17455static int G__RootEventData_rootcint_477_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17456{
17457 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcHitCol());
17458 return(1 || funcname || hash || result7 || libp) ;
17459}
17460
17461static int G__RootEventData_rootcint_477_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17462{
17463 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
17464 G__setnull(result7);
17465 return(1 || funcname || hash || result7 || libp) ;
17466}
17467
17468static int G__RootEventData_rootcint_477_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17469{
17470 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcHit((Int_t) G__int(libp->para[0])));
17471 return(1 || funcname || hash || result7 || libp) ;
17472}
17473
17474static int G__RootEventData_rootcint_477_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17475{
17476 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcHitCol();
17477 G__setnull(result7);
17478 return(1 || funcname || hash || result7 || libp) ;
17479}
17480
17481static int G__RootEventData_rootcint_477_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17482{
17483 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getTofTrackCol());
17484 return(1 || funcname || hash || result7 || libp) ;
17485}
17486
17487static int G__RootEventData_rootcint_477_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17488{
17489 ((TRecTrackEvent*) G__getstructoffset())->addTofTrack((TRecTofTrack*) G__int(libp->para[0]));
17490 G__setnull(result7);
17491 return(1 || funcname || hash || result7 || libp) ;
17492}
17493
17494static int G__RootEventData_rootcint_477_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17495{
17496 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
17497 return(1 || funcname || hash || result7 || libp) ;
17498}
17499
17500static int G__RootEventData_rootcint_477_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17501{
17502 ((TRecTrackEvent*) G__getstructoffset())->clearTofTrackCol();
17503 G__setnull(result7);
17504 return(1 || funcname || hash || result7 || libp) ;
17505}
17506
17507static int G__RootEventData_rootcint_477_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17508{
17509 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcHitCol());
17510 return(1 || funcname || hash || result7 || libp) ;
17511}
17512
17513static int G__RootEventData_rootcint_477_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17514{
17515 ((TRecTrackEvent*) G__getstructoffset())->addEmcHit((TRecEmcHit*) G__int(libp->para[0]));
17516 G__setnull(result7);
17517 return(1 || funcname || hash || result7 || libp) ;
17518}
17519
17520static int G__RootEventData_rootcint_477_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17521{
17522 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcHit((Int_t) G__int(libp->para[0])));
17523 return(1 || funcname || hash || result7 || libp) ;
17524}
17525
17526static int G__RootEventData_rootcint_477_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17527{
17528 ((TRecTrackEvent*) G__getstructoffset())->clearEmcHitCol();
17529 G__setnull(result7);
17530 return(1 || funcname || hash || result7 || libp) ;
17531}
17532
17533static int G__RootEventData_rootcint_477_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17534{
17535 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcClusterCol());
17536 return(1 || funcname || hash || result7 || libp) ;
17537}
17538
17539static int G__RootEventData_rootcint_477_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17540{
17541 ((TRecTrackEvent*) G__getstructoffset())->addEmcCluster((TRecEmcCluster*) G__int(libp->para[0]));
17542 G__setnull(result7);
17543 return(1 || funcname || hash || result7 || libp) ;
17544}
17545
17546static int G__RootEventData_rootcint_477_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17547{
17548 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcCluster((Int_t) G__int(libp->para[0])));
17549 return(1 || funcname || hash || result7 || libp) ;
17550}
17551
17552static int G__RootEventData_rootcint_477_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17553{
17554 ((TRecTrackEvent*) G__getstructoffset())->clearEmcClusterCol();
17555 G__setnull(result7);
17556 return(1 || funcname || hash || result7 || libp) ;
17557}
17558
17559static int G__RootEventData_rootcint_477_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17560{
17561 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcShowerCol());
17562 return(1 || funcname || hash || result7 || libp) ;
17563}
17564
17565static int G__RootEventData_rootcint_477_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17566{
17567 ((TRecTrackEvent*) G__getstructoffset())->addEmcShower((TRecEmcShower*) G__int(libp->para[0]));
17568 G__setnull(result7);
17569 return(1 || funcname || hash || result7 || libp) ;
17570}
17571
17572static int G__RootEventData_rootcint_477_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17573{
17574 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcShower((Int_t) G__int(libp->para[0])));
17575 return(1 || funcname || hash || result7 || libp) ;
17576}
17577
17578static int G__RootEventData_rootcint_477_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17579{
17580 ((TRecTrackEvent*) G__getstructoffset())->clearEmcShowerCol();
17581 G__setnull(result7);
17582 return(1 || funcname || hash || result7 || libp) ;
17583}
17584
17585static int G__RootEventData_rootcint_477_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17586{
17587 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getMucTrackCol());
17588 return(1 || funcname || hash || result7 || libp) ;
17589}
17590
17591static int G__RootEventData_rootcint_477_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17592{
17593 ((TRecTrackEvent*) G__getstructoffset())->addMucTrack((TRecMucTrack*) G__int(libp->para[0]));
17594 G__setnull(result7);
17595 return(1 || funcname || hash || result7 || libp) ;
17596}
17597
17598static int G__RootEventData_rootcint_477_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17599{
17600 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
17601 return(1 || funcname || hash || result7 || libp) ;
17602}
17603
17604static int G__RootEventData_rootcint_477_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17605{
17606 ((TRecTrackEvent*) G__getstructoffset())->clearMucTrackCol();
17607 G__setnull(result7);
17608 return(1 || funcname || hash || result7 || libp) ;
17609}
17610
17611static int G__RootEventData_rootcint_477_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17612{
17613 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxCol());
17614 return(1 || funcname || hash || result7 || libp) ;
17615}
17616
17617static int G__RootEventData_rootcint_477_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17618{
17619 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcDedx((TRecMdcDedx*) G__int(libp->para[0]));
17620 G__setnull(result7);
17621 return(1 || funcname || hash || result7 || libp) ;
17622}
17623
17624static int G__RootEventData_rootcint_477_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17625{
17626 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedx((Int_t) G__int(libp->para[0])));
17627 return(1 || funcname || hash || result7 || libp) ;
17628}
17629
17630static int G__RootEventData_rootcint_477_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17631{
17632 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcDedxCol();
17633 G__setnull(result7);
17634 return(1 || funcname || hash || result7 || libp) ;
17635}
17636
17637static int G__RootEventData_rootcint_477_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17638{
17639 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxHitCol());
17640 return(1 || funcname || hash || result7 || libp) ;
17641}
17642
17643static int G__RootEventData_rootcint_477_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17644{
17645 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcDedxHit((TRecMdcDedxHit*) G__int(libp->para[0]));
17646 G__setnull(result7);
17647 return(1 || funcname || hash || result7 || libp) ;
17648}
17649
17650static int G__RootEventData_rootcint_477_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17651{
17652 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxHit((Int_t) G__int(libp->para[0])));
17653 return(1 || funcname || hash || result7 || libp) ;
17654}
17655
17656static int G__RootEventData_rootcint_477_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17657{
17658 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcDedxHitCol();
17659 G__setnull(result7);
17660 return(1 || funcname || hash || result7 || libp) ;
17661}
17662
17663static int G__RootEventData_rootcint_477_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17664{
17665 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getExtTrackCol());
17666 return(1 || funcname || hash || result7 || libp) ;
17667}
17668
17669static int G__RootEventData_rootcint_477_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17670{
17671 ((TRecTrackEvent*) G__getstructoffset())->addExtTrack((TRecExtTrack*) G__int(libp->para[0]));
17672 G__setnull(result7);
17673 return(1 || funcname || hash || result7 || libp) ;
17674}
17675
17676static int G__RootEventData_rootcint_477_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17677{
17678 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getExtTrack((Int_t) G__int(libp->para[0])));
17679 return(1 || funcname || hash || result7 || libp) ;
17680}
17681
17682static int G__RootEventData_rootcint_477_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17683{
17684 ((TRecTrackEvent*) G__getstructoffset())->clearExtTrackCol();
17685 G__setnull(result7);
17686 return(1 || funcname || hash || result7 || libp) ;
17687}
17688
17689static int G__RootEventData_rootcint_477_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17690{
17691 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalTrackCol());
17692 return(1 || funcname || hash || result7 || libp) ;
17693}
17694
17695static int G__RootEventData_rootcint_477_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17696{
17697 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcKalTrack((TRecMdcKalTrack*) G__int(libp->para[0]));
17698 G__setnull(result7);
17699 return(1 || funcname || hash || result7 || libp) ;
17700}
17701
17702static int G__RootEventData_rootcint_477_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17703{
17704 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalTrack((Int_t) G__int(libp->para[0])));
17705 return(1 || funcname || hash || result7 || libp) ;
17706}
17707
17708static int G__RootEventData_rootcint_477_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17709{
17710 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcKalTrackCol();
17711 G__setnull(result7);
17712 return(1 || funcname || hash || result7 || libp) ;
17713}
17714
17715static int G__RootEventData_rootcint_477_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17716{
17717 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalHelixSegCol());
17718 return(1 || funcname || hash || result7 || libp) ;
17719}
17720
17721static int G__RootEventData_rootcint_477_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17722{
17723 ((TRecTrackEvent*) G__getstructoffset())->addRecMdcKalHelixSeg((TRecMdcKalHelixSeg*) G__int(libp->para[0]));
17724 G__setnull(result7);
17725 return(1 || funcname || hash || result7 || libp) ;
17726}
17727
17728static int G__RootEventData_rootcint_477_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17729{
17730 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalHelixSeg((Int_t) G__int(libp->para[0])));
17731 return(1 || funcname || hash || result7 || libp) ;
17732}
17733
17734static int G__RootEventData_rootcint_477_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17735{
17736 ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcKalHelixSegCol();
17737 G__setnull(result7);
17738 return(1 || funcname || hash || result7 || libp) ;
17739}
17740
17741static int G__RootEventData_rootcint_477_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17742{
17743 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEvTimeCol());
17744 return(1 || funcname || hash || result7 || libp) ;
17745}
17746
17747static int G__RootEventData_rootcint_477_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17748{
17749 ((TRecTrackEvent*) G__getstructoffset())->addEvTime((TRecEvTime*) G__int(libp->para[0]));
17750 G__setnull(result7);
17751 return(1 || funcname || hash || result7 || libp) ;
17752}
17753
17754static int G__RootEventData_rootcint_477_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17755{
17756 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEvTime((Int_t) G__int(libp->para[0])));
17757 return(1 || funcname || hash || result7 || libp) ;
17758}
17759
17760static int G__RootEventData_rootcint_477_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17761{
17762 ((TRecTrackEvent*) G__getstructoffset())->clearEvTimeCol();
17763 G__setnull(result7);
17764 return(1 || funcname || hash || result7 || libp) ;
17765}
17766
17767static int G__RootEventData_rootcint_477_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17768{
17769 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecZddChannelCol());
17770 return(1 || funcname || hash || result7 || libp) ;
17771}
17772
17773static int G__RootEventData_rootcint_477_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17774{
17775 ((TRecTrackEvent*) G__getstructoffset())->addRecZddChannel((TRecZddChannel*) G__int(libp->para[0]));
17776 G__setnull(result7);
17777 return(1 || funcname || hash || result7 || libp) ;
17778}
17779
17780static int G__RootEventData_rootcint_477_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17781{
17782 G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecZddChannel((Int_t) G__int(libp->para[0])));
17783 return(1 || funcname || hash || result7 || libp) ;
17784}
17785
17786static int G__RootEventData_rootcint_477_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17787{
17788 ((TRecTrackEvent*) G__getstructoffset())->clearRecZddChannelCol();
17789 G__setnull(result7);
17790 return(1 || funcname || hash || result7 || libp) ;
17791}
17792
17793static int G__RootEventData_rootcint_477_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17794{
17795 G__letint(result7, 85, (long) TRecTrackEvent::Class());
17796 return(1 || funcname || hash || result7 || libp) ;
17797}
17798
17799static int G__RootEventData_rootcint_477_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17800{
17801 G__letint(result7, 67, (long) TRecTrackEvent::Class_Name());
17802 return(1 || funcname || hash || result7 || libp) ;
17803}
17804
17805static int G__RootEventData_rootcint_477_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17806{
17807 G__letint(result7, 115, (long) TRecTrackEvent::Class_Version());
17808 return(1 || funcname || hash || result7 || libp) ;
17809}
17810
17811static int G__RootEventData_rootcint_477_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17812{
17813 TRecTrackEvent::Dictionary();
17814 G__setnull(result7);
17815 return(1 || funcname || hash || result7 || libp) ;
17816}
17817
17818static int G__RootEventData_rootcint_477_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17819{
17820 ((TRecTrackEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
17821 G__setnull(result7);
17822 return(1 || funcname || hash || result7 || libp) ;
17823}
17824
17825static int G__RootEventData_rootcint_477_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17826{
17827 G__letint(result7, 67, (long) TRecTrackEvent::DeclFileName());
17828 return(1 || funcname || hash || result7 || libp) ;
17829}
17830
17831static int G__RootEventData_rootcint_477_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17832{
17833 G__letint(result7, 105, (long) TRecTrackEvent::ImplFileLine());
17834 return(1 || funcname || hash || result7 || libp) ;
17835}
17836
17837static int G__RootEventData_rootcint_477_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17838{
17839 G__letint(result7, 67, (long) TRecTrackEvent::ImplFileName());
17840 return(1 || funcname || hash || result7 || libp) ;
17841}
17842
17843static int G__RootEventData_rootcint_477_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17844{
17845 G__letint(result7, 105, (long) TRecTrackEvent::DeclFileLine());
17846 return(1 || funcname || hash || result7 || libp) ;
17847}
17848
17849// automatic copy constructor
17850static int G__RootEventData_rootcint_477_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17851
17852{
17853 TRecTrackEvent* p;
17854 void* tmp = (void*) G__int(libp->para[0]);
17855 p = new TRecTrackEvent(*(TRecTrackEvent*) tmp);
17856 result7->obj.i = (long) p;
17857 result7->ref = (long) p;
17858 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
17859 return(1 || funcname || hash || result7 || libp) ;
17860}
17861
17862// automatic destructor
17863typedef TRecTrackEvent G__TTRecTrackEvent;
17864static int G__RootEventData_rootcint_477_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17865{
17866 char* gvp = (char*) G__getgvp();
17867 long soff = G__getstructoffset();
17868 int n = G__getaryconstruct();
17869 //
17870 //has_a_delete: 1
17871 //has_own_delete1arg: 0
17872 //has_own_delete2arg: 0
17873 //
17874 if (!soff) {
17875 return(1);
17876 }
17877 if (n) {
17878 if (gvp == (char*)G__PVOID) {
17879 delete[] (TRecTrackEvent*) soff;
17880 } else {
17881 G__setgvp((long) G__PVOID);
17882 for (int i = n - 1; i >= 0; --i) {
17883 ((TRecTrackEvent*) (soff+(sizeof(TRecTrackEvent)*i)))->~G__TTRecTrackEvent();
17884 }
17885 G__setgvp((long)gvp);
17886 }
17887 } else {
17888 if (gvp == (char*)G__PVOID) {
17889 delete (TRecTrackEvent*) soff;
17890 } else {
17891 G__setgvp((long) G__PVOID);
17892 ((TRecTrackEvent*) (soff))->~G__TTRecTrackEvent();
17893 G__setgvp((long)gvp);
17894 }
17895 }
17896 G__setnull(result7);
17897 return(1 || funcname || hash || result7 || libp) ;
17898}
17899
17900// automatic assignment operator
17901static int G__RootEventData_rootcint_477_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17902{
17903 TRecTrackEvent* dest = (TRecTrackEvent*) G__getstructoffset();
17904 *dest = *(TRecTrackEvent*) libp->para[0].ref;
17905 const TRecTrackEvent& obj = *dest;
17906 result7->ref = (long) (&obj);
17907 result7->obj.i = (long) (&obj);
17908 return(1 || funcname || hash || result7 || libp) ;
17909}
17910
17911
17912/* TMdcTrack */
17913static int G__RootEventData_rootcint_478_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17914{
17915 TMdcTrack* p = NULL;
17916 char* gvp = (char*) G__getgvp();
17917 int n = G__getaryconstruct();
17918 if (n) {
17919 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17920 p = new TMdcTrack[n];
17921 } else {
17922 p = new((void*) gvp) TMdcTrack[n];
17923 }
17924 } else {
17925 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
17926 p = new TMdcTrack;
17927 } else {
17928 p = new((void*) gvp) TMdcTrack;
17929 }
17930 }
17931 result7->obj.i = (long) p;
17932 result7->ref = (long) p;
17933 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
17934 return(1 || funcname || hash || result7 || libp) ;
17935}
17936
17937static int G__RootEventData_rootcint_478_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17938{
17939 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->trackId());
17940 return(1 || funcname || hash || result7 || libp) ;
17941}
17942
17943static int G__RootEventData_rootcint_478_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17944{
17945 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->helix((Int_t) G__int(libp->para[0])));
17946 return(1 || funcname || hash || result7 || libp) ;
17947}
17948
17949static int G__RootEventData_rootcint_478_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17950{
17951 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->stat());
17952 return(1 || funcname || hash || result7 || libp) ;
17953}
17954
17955static int G__RootEventData_rootcint_478_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17956{
17957 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->chi2());
17958 return(1 || funcname || hash || result7 || libp) ;
17959}
17960
17961static int G__RootEventData_rootcint_478_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17962{
17963 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->ndof());
17964 return(1 || funcname || hash || result7 || libp) ;
17965}
17966
17967static int G__RootEventData_rootcint_478_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17968{
17969 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
17970 return(1 || funcname || hash || result7 || libp) ;
17971}
17972
17973static int G__RootEventData_rootcint_478_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17974{
17975 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->nster());
17976 return(1 || funcname || hash || result7 || libp) ;
17977}
17978
17979static int G__RootEventData_rootcint_478_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17980{
17981 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->nlayer());
17982 return(1 || funcname || hash || result7 || libp) ;
17983}
17984
17985static int G__RootEventData_rootcint_478_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17986{
17987 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->firstLayer());
17988 return(1 || funcname || hash || result7 || libp) ;
17989}
17990
17991static int G__RootEventData_rootcint_478_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17992{
17993 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->lastLayer());
17994 return(1 || funcname || hash || result7 || libp) ;
17995}
17996
17997static int G__RootEventData_rootcint_478_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
17998{
17999 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->x());
18000 return(1 || funcname || hash || result7 || libp) ;
18001}
18002
18003static int G__RootEventData_rootcint_478_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18004{
18005 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->y());
18006 return(1 || funcname || hash || result7 || libp) ;
18007}
18008
18009static int G__RootEventData_rootcint_478_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18010{
18011 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->z());
18012 return(1 || funcname || hash || result7 || libp) ;
18013}
18014
18015static int G__RootEventData_rootcint_478_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18016{
18017 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->r());
18018 return(1 || funcname || hash || result7 || libp) ;
18019}
18020
18021static int G__RootEventData_rootcint_478_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18022{
18023 G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->charge());
18024 return(1 || funcname || hash || result7 || libp) ;
18025}
18026
18027static int G__RootEventData_rootcint_478_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18028{
18029 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->pxy());
18030 return(1 || funcname || hash || result7 || libp) ;
18031}
18032
18033static int G__RootEventData_rootcint_478_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18034{
18035 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->px());
18036 return(1 || funcname || hash || result7 || libp) ;
18037}
18038
18039static int G__RootEventData_rootcint_478_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18040{
18041 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->py());
18042 return(1 || funcname || hash || result7 || libp) ;
18043}
18044
18045static int G__RootEventData_rootcint_478_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18046{
18047 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->pz());
18048 return(1 || funcname || hash || result7 || libp) ;
18049}
18050
18051static int G__RootEventData_rootcint_478_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18052{
18053 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->p());
18054 return(1 || funcname || hash || result7 || libp) ;
18055}
18056
18057static int G__RootEventData_rootcint_478_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18058{
18059 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->theta());
18060 return(1 || funcname || hash || result7 || libp) ;
18061}
18062
18063static int G__RootEventData_rootcint_478_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18064{
18065 G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->phi());
18066 return(1 || funcname || hash || result7 || libp) ;
18067}
18068
18069static int G__RootEventData_rootcint_478_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18070{
18071 ((TMdcTrack*) G__getstructoffset())->setHelix((Double_t*) G__int(libp->para[0]));
18072 G__setnull(result7);
18073 return(1 || funcname || hash || result7 || libp) ;
18074}
18075
18076static int G__RootEventData_rootcint_478_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18077{
18078 ((TMdcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
18079 G__setnull(result7);
18080 return(1 || funcname || hash || result7 || libp) ;
18081}
18082
18083static int G__RootEventData_rootcint_478_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18084{
18085 ((TMdcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
18086 G__setnull(result7);
18087 return(1 || funcname || hash || result7 || libp) ;
18088}
18089
18090static int G__RootEventData_rootcint_478_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18091{
18092 ((TMdcTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]));
18093 G__setnull(result7);
18094 return(1 || funcname || hash || result7 || libp) ;
18095}
18096
18097static int G__RootEventData_rootcint_478_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18098{
18099 ((TMdcTrack*) G__getstructoffset())->setChi2((const Double_t) G__double(libp->para[0]));
18100 G__setnull(result7);
18101 return(1 || funcname || hash || result7 || libp) ;
18102}
18103
18104static int G__RootEventData_rootcint_478_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18105{
18106 ((TMdcTrack*) G__getstructoffset())->setNdof((const Int_t) G__int(libp->para[0]));
18107 G__setnull(result7);
18108 return(1 || funcname || hash || result7 || libp) ;
18109}
18110
18111static int G__RootEventData_rootcint_478_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18112{
18113 ((TMdcTrack*) G__getstructoffset())->setNster((const Int_t) G__int(libp->para[0]));
18114 G__setnull(result7);
18115 return(1 || funcname || hash || result7 || libp) ;
18116}
18117
18118static int G__RootEventData_rootcint_478_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18119{
18120 ((TMdcTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]));
18121 G__setnull(result7);
18122 return(1 || funcname || hash || result7 || libp) ;
18123}
18124
18125static int G__RootEventData_rootcint_478_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18126{
18127 ((TMdcTrack*) G__getstructoffset())->setFirstLayer((const Int_t) G__int(libp->para[0]));
18128 G__setnull(result7);
18129 return(1 || funcname || hash || result7 || libp) ;
18130}
18131
18132static int G__RootEventData_rootcint_478_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18133{
18134 ((TMdcTrack*) G__getstructoffset())->setLastLayer((const Int_t) G__int(libp->para[0]));
18135 G__setnull(result7);
18136 return(1 || funcname || hash || result7 || libp) ;
18137}
18138
18139static int G__RootEventData_rootcint_478_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18140{
18141 G__letint(result7, 85, (long) TMdcTrack::Class());
18142 return(1 || funcname || hash || result7 || libp) ;
18143}
18144
18145static int G__RootEventData_rootcint_478_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18146{
18147 G__letint(result7, 67, (long) TMdcTrack::Class_Name());
18148 return(1 || funcname || hash || result7 || libp) ;
18149}
18150
18151static int G__RootEventData_rootcint_478_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18152{
18153 G__letint(result7, 115, (long) TMdcTrack::Class_Version());
18154 return(1 || funcname || hash || result7 || libp) ;
18155}
18156
18157static int G__RootEventData_rootcint_478_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18158{
18159 TMdcTrack::Dictionary();
18160 G__setnull(result7);
18161 return(1 || funcname || hash || result7 || libp) ;
18162}
18163
18164static int G__RootEventData_rootcint_478_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18165{
18166 ((TMdcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
18167 G__setnull(result7);
18168 return(1 || funcname || hash || result7 || libp) ;
18169}
18170
18171static int G__RootEventData_rootcint_478_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18172{
18173 G__letint(result7, 67, (long) TMdcTrack::DeclFileName());
18174 return(1 || funcname || hash || result7 || libp) ;
18175}
18176
18177static int G__RootEventData_rootcint_478_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18178{
18179 G__letint(result7, 105, (long) TMdcTrack::ImplFileLine());
18180 return(1 || funcname || hash || result7 || libp) ;
18181}
18182
18183static int G__RootEventData_rootcint_478_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18184{
18185 G__letint(result7, 67, (long) TMdcTrack::ImplFileName());
18186 return(1 || funcname || hash || result7 || libp) ;
18187}
18188
18189static int G__RootEventData_rootcint_478_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18190{
18191 G__letint(result7, 105, (long) TMdcTrack::DeclFileLine());
18192 return(1 || funcname || hash || result7 || libp) ;
18193}
18194
18195// automatic copy constructor
18196static int G__RootEventData_rootcint_478_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18197
18198{
18199 TMdcTrack* p;
18200 void* tmp = (void*) G__int(libp->para[0]);
18201 p = new TMdcTrack(*(TMdcTrack*) tmp);
18202 result7->obj.i = (long) p;
18203 result7->ref = (long) p;
18204 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
18205 return(1 || funcname || hash || result7 || libp) ;
18206}
18207
18208// automatic destructor
18209typedef TMdcTrack G__TTMdcTrack;
18210static int G__RootEventData_rootcint_478_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18211{
18212 char* gvp = (char*) G__getgvp();
18213 long soff = G__getstructoffset();
18214 int n = G__getaryconstruct();
18215 //
18216 //has_a_delete: 1
18217 //has_own_delete1arg: 0
18218 //has_own_delete2arg: 0
18219 //
18220 if (!soff) {
18221 return(1);
18222 }
18223 if (n) {
18224 if (gvp == (char*)G__PVOID) {
18225 delete[] (TMdcTrack*) soff;
18226 } else {
18227 G__setgvp((long) G__PVOID);
18228 for (int i = n - 1; i >= 0; --i) {
18229 ((TMdcTrack*) (soff+(sizeof(TMdcTrack)*i)))->~G__TTMdcTrack();
18230 }
18231 G__setgvp((long)gvp);
18232 }
18233 } else {
18234 if (gvp == (char*)G__PVOID) {
18235 delete (TMdcTrack*) soff;
18236 } else {
18237 G__setgvp((long) G__PVOID);
18238 ((TMdcTrack*) (soff))->~G__TTMdcTrack();
18239 G__setgvp((long)gvp);
18240 }
18241 }
18242 G__setnull(result7);
18243 return(1 || funcname || hash || result7 || libp) ;
18244}
18245
18246// automatic assignment operator
18247static int G__RootEventData_rootcint_478_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18248{
18249 TMdcTrack* dest = (TMdcTrack*) G__getstructoffset();
18250 *dest = *(TMdcTrack*) libp->para[0].ref;
18251 const TMdcTrack& obj = *dest;
18252 result7->ref = (long) (&obj);
18253 result7->obj.i = (long) (&obj);
18254 return(1 || funcname || hash || result7 || libp) ;
18255}
18256
18257
18258/* TEmcTrack */
18259static int G__RootEventData_rootcint_479_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18260{
18261 TEmcTrack* p = NULL;
18262 char* gvp = (char*) G__getgvp();
18263 int n = G__getaryconstruct();
18264 if (n) {
18265 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18266 p = new TEmcTrack[n];
18267 } else {
18268 p = new((void*) gvp) TEmcTrack[n];
18269 }
18270 } else {
18271 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18272 p = new TEmcTrack;
18273 } else {
18274 p = new((void*) gvp) TEmcTrack;
18275 }
18276 }
18277 result7->obj.i = (long) p;
18278 result7->ref = (long) p;
18279 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
18280 return(1 || funcname || hash || result7 || libp) ;
18281}
18282
18283static int G__RootEventData_rootcint_479_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18284{
18285 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->trackId());
18286 return(1 || funcname || hash || result7 || libp) ;
18287}
18288
18289static int G__RootEventData_rootcint_479_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18290{
18291 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->numHits());
18292 return(1 || funcname || hash || result7 || libp) ;
18293}
18294
18295static int G__RootEventData_rootcint_479_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18296{
18297 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->status());
18298 return(1 || funcname || hash || result7 || libp) ;
18299}
18300
18301static int G__RootEventData_rootcint_479_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18302{
18303 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->cellId());
18304 return(1 || funcname || hash || result7 || libp) ;
18305}
18306
18307static int G__RootEventData_rootcint_479_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18308{
18309 G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->module());
18310 return(1 || funcname || hash || result7 || libp) ;
18311}
18312
18313static int G__RootEventData_rootcint_479_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18314{
18315 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->x());
18316 return(1 || funcname || hash || result7 || libp) ;
18317}
18318
18319static int G__RootEventData_rootcint_479_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18320{
18321 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->y());
18322 return(1 || funcname || hash || result7 || libp) ;
18323}
18324
18325static int G__RootEventData_rootcint_479_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18326{
18327 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->z());
18328 return(1 || funcname || hash || result7 || libp) ;
18329}
18330
18331static int G__RootEventData_rootcint_479_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18332{
18333 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->theta());
18334 return(1 || funcname || hash || result7 || libp) ;
18335}
18336
18337static int G__RootEventData_rootcint_479_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18338{
18339 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->phi());
18340 return(1 || funcname || hash || result7 || libp) ;
18341}
18342
18343static int G__RootEventData_rootcint_479_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18344{
18345 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dx());
18346 return(1 || funcname || hash || result7 || libp) ;
18347}
18348
18349static int G__RootEventData_rootcint_479_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18350{
18351 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dy());
18352 return(1 || funcname || hash || result7 || libp) ;
18353}
18354
18355static int G__RootEventData_rootcint_479_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18356{
18357 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dz());
18358 return(1 || funcname || hash || result7 || libp) ;
18359}
18360
18361static int G__RootEventData_rootcint_479_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18362{
18363 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dtheta());
18364 return(1 || funcname || hash || result7 || libp) ;
18365}
18366
18367static int G__RootEventData_rootcint_479_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18368{
18369 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dphi());
18370 return(1 || funcname || hash || result7 || libp) ;
18371}
18372
18373static int G__RootEventData_rootcint_479_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18374{
18375 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->energy());
18376 return(1 || funcname || hash || result7 || libp) ;
18377}
18378
18379static int G__RootEventData_rootcint_479_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18380{
18381 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dE());
18382 return(1 || funcname || hash || result7 || libp) ;
18383}
18384
18385static int G__RootEventData_rootcint_479_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18386{
18387 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->eSeed());
18388 return(1 || funcname || hash || result7 || libp) ;
18389}
18390
18391static int G__RootEventData_rootcint_479_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18392{
18393 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->e3x3());
18394 return(1 || funcname || hash || result7 || libp) ;
18395}
18396
18397static int G__RootEventData_rootcint_479_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18398{
18399 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->e5x5());
18400 return(1 || funcname || hash || result7 || libp) ;
18401}
18402
18403static int G__RootEventData_rootcint_479_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18404{
18405 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->time());
18406 return(1 || funcname || hash || result7 || libp) ;
18407}
18408
18409static int G__RootEventData_rootcint_479_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18410{
18411 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->secondMoment());
18412 return(1 || funcname || hash || result7 || libp) ;
18413}
18414
18415static int G__RootEventData_rootcint_479_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18416{
18417 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->latMoment());
18418 return(1 || funcname || hash || result7 || libp) ;
18419}
18420
18421static int G__RootEventData_rootcint_479_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18422{
18423 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->a20Moment());
18424 return(1 || funcname || hash || result7 || libp) ;
18425}
18426
18427static int G__RootEventData_rootcint_479_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18428{
18429 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->a42Moment());
18430 return(1 || funcname || hash || result7 || libp) ;
18431}
18432
18433static int G__RootEventData_rootcint_479_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18434{
18435 G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
18436 return(1 || funcname || hash || result7 || libp) ;
18437}
18438
18439static int G__RootEventData_rootcint_479_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18440{
18441 ((TEmcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
18442 G__setnull(result7);
18443 return(1 || funcname || hash || result7 || libp) ;
18444}
18445
18446static int G__RootEventData_rootcint_479_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18447{
18448 ((TEmcTrack*) G__getstructoffset())->setNumHits((const Int_t) G__int(libp->para[0]));
18449 G__setnull(result7);
18450 return(1 || funcname || hash || result7 || libp) ;
18451}
18452
18453static int G__RootEventData_rootcint_479_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18454{
18455 ((TEmcTrack*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
18456 G__setnull(result7);
18457 return(1 || funcname || hash || result7 || libp) ;
18458}
18459
18460static int G__RootEventData_rootcint_479_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18461{
18462 ((TEmcTrack*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
18463 G__setnull(result7);
18464 return(1 || funcname || hash || result7 || libp) ;
18465}
18466
18467static int G__RootEventData_rootcint_479_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18468{
18469 ((TEmcTrack*) G__getstructoffset())->setModule((const Int_t) G__int(libp->para[0]));
18470 G__setnull(result7);
18471 return(1 || funcname || hash || result7 || libp) ;
18472}
18473
18474static int G__RootEventData_rootcint_479_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18475{
18476 ((TEmcTrack*) G__getstructoffset())->setX((const Double_t) G__double(libp->para[0]));
18477 G__setnull(result7);
18478 return(1 || funcname || hash || result7 || libp) ;
18479}
18480
18481static int G__RootEventData_rootcint_479_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18482{
18483 ((TEmcTrack*) G__getstructoffset())->setY((const Double_t) G__double(libp->para[0]));
18484 G__setnull(result7);
18485 return(1 || funcname || hash || result7 || libp) ;
18486}
18487
18488static int G__RootEventData_rootcint_479_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18489{
18490 ((TEmcTrack*) G__getstructoffset())->setZ((const Double_t) G__double(libp->para[0]));
18491 G__setnull(result7);
18492 return(1 || funcname || hash || result7 || libp) ;
18493}
18494
18495static int G__RootEventData_rootcint_479_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18496{
18497 ((TEmcTrack*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
18498 G__setnull(result7);
18499 return(1 || funcname || hash || result7 || libp) ;
18500}
18501
18502static int G__RootEventData_rootcint_479_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18503{
18504 ((TEmcTrack*) G__getstructoffset())->setDE((const Double_t) G__double(libp->para[0]));
18505 G__setnull(result7);
18506 return(1 || funcname || hash || result7 || libp) ;
18507}
18508
18509static int G__RootEventData_rootcint_479_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18510{
18511 ((TEmcTrack*) G__getstructoffset())->setDtheta((const Double_t) G__double(libp->para[0]));
18512 G__setnull(result7);
18513 return(1 || funcname || hash || result7 || libp) ;
18514}
18515
18516static int G__RootEventData_rootcint_479_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18517{
18518 ((TEmcTrack*) G__getstructoffset())->setDphi((const Double_t) G__double(libp->para[0]));
18519 G__setnull(result7);
18520 return(1 || funcname || hash || result7 || libp) ;
18521}
18522
18523static int G__RootEventData_rootcint_479_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18524{
18525 ((TEmcTrack*) G__getstructoffset())->setESeed((const Double_t) G__double(libp->para[0]));
18526 G__setnull(result7);
18527 return(1 || funcname || hash || result7 || libp) ;
18528}
18529
18530static int G__RootEventData_rootcint_479_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18531{
18532 ((TEmcTrack*) G__getstructoffset())->setE3x3((const Double_t) G__double(libp->para[0]));
18533 G__setnull(result7);
18534 return(1 || funcname || hash || result7 || libp) ;
18535}
18536
18537static int G__RootEventData_rootcint_479_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18538{
18539 ((TEmcTrack*) G__getstructoffset())->setE5x5((const Double_t) G__double(libp->para[0]));
18540 G__setnull(result7);
18541 return(1 || funcname || hash || result7 || libp) ;
18542}
18543
18544static int G__RootEventData_rootcint_479_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18545{
18546 ((TEmcTrack*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
18547 G__setnull(result7);
18548 return(1 || funcname || hash || result7 || libp) ;
18549}
18550
18551static int G__RootEventData_rootcint_479_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18552{
18553 ((TEmcTrack*) G__getstructoffset())->setSecondMoment((const Double_t) G__double(libp->para[0]));
18554 G__setnull(result7);
18555 return(1 || funcname || hash || result7 || libp) ;
18556}
18557
18558static int G__RootEventData_rootcint_479_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18559{
18560 ((TEmcTrack*) G__getstructoffset())->setLatMoment((const Double_t) G__double(libp->para[0]));
18561 G__setnull(result7);
18562 return(1 || funcname || hash || result7 || libp) ;
18563}
18564
18565static int G__RootEventData_rootcint_479_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18566{
18567 ((TEmcTrack*) G__getstructoffset())->setA20Moment((const Double_t) G__double(libp->para[0]));
18568 G__setnull(result7);
18569 return(1 || funcname || hash || result7 || libp) ;
18570}
18571
18572static int G__RootEventData_rootcint_479_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18573{
18574 ((TEmcTrack*) G__getstructoffset())->setA42Moment((const Double_t) G__double(libp->para[0]));
18575 G__setnull(result7);
18576 return(1 || funcname || hash || result7 || libp) ;
18577}
18578
18579static int G__RootEventData_rootcint_479_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18580{
18581 ((TEmcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
18582 G__setnull(result7);
18583 return(1 || funcname || hash || result7 || libp) ;
18584}
18585
18586static int G__RootEventData_rootcint_479_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18587{
18588 G__letint(result7, 85, (long) TEmcTrack::Class());
18589 return(1 || funcname || hash || result7 || libp) ;
18590}
18591
18592static int G__RootEventData_rootcint_479_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18593{
18594 G__letint(result7, 67, (long) TEmcTrack::Class_Name());
18595 return(1 || funcname || hash || result7 || libp) ;
18596}
18597
18598static int G__RootEventData_rootcint_479_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18599{
18600 G__letint(result7, 115, (long) TEmcTrack::Class_Version());
18601 return(1 || funcname || hash || result7 || libp) ;
18602}
18603
18604static int G__RootEventData_rootcint_479_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18605{
18606 TEmcTrack::Dictionary();
18607 G__setnull(result7);
18608 return(1 || funcname || hash || result7 || libp) ;
18609}
18610
18611static int G__RootEventData_rootcint_479_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18612{
18613 ((TEmcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
18614 G__setnull(result7);
18615 return(1 || funcname || hash || result7 || libp) ;
18616}
18617
18618static int G__RootEventData_rootcint_479_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18619{
18620 G__letint(result7, 67, (long) TEmcTrack::DeclFileName());
18621 return(1 || funcname || hash || result7 || libp) ;
18622}
18623
18624static int G__RootEventData_rootcint_479_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18625{
18626 G__letint(result7, 105, (long) TEmcTrack::ImplFileLine());
18627 return(1 || funcname || hash || result7 || libp) ;
18628}
18629
18630static int G__RootEventData_rootcint_479_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18631{
18632 G__letint(result7, 67, (long) TEmcTrack::ImplFileName());
18633 return(1 || funcname || hash || result7 || libp) ;
18634}
18635
18636static int G__RootEventData_rootcint_479_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18637{
18638 G__letint(result7, 105, (long) TEmcTrack::DeclFileLine());
18639 return(1 || funcname || hash || result7 || libp) ;
18640}
18641
18642// automatic copy constructor
18643static int G__RootEventData_rootcint_479_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18644
18645{
18646 TEmcTrack* p;
18647 void* tmp = (void*) G__int(libp->para[0]);
18648 p = new TEmcTrack(*(TEmcTrack*) tmp);
18649 result7->obj.i = (long) p;
18650 result7->ref = (long) p;
18651 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
18652 return(1 || funcname || hash || result7 || libp) ;
18653}
18654
18655// automatic destructor
18656typedef TEmcTrack G__TTEmcTrack;
18657static int G__RootEventData_rootcint_479_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18658{
18659 char* gvp = (char*) G__getgvp();
18660 long soff = G__getstructoffset();
18661 int n = G__getaryconstruct();
18662 //
18663 //has_a_delete: 1
18664 //has_own_delete1arg: 0
18665 //has_own_delete2arg: 0
18666 //
18667 if (!soff) {
18668 return(1);
18669 }
18670 if (n) {
18671 if (gvp == (char*)G__PVOID) {
18672 delete[] (TEmcTrack*) soff;
18673 } else {
18674 G__setgvp((long) G__PVOID);
18675 for (int i = n - 1; i >= 0; --i) {
18676 ((TEmcTrack*) (soff+(sizeof(TEmcTrack)*i)))->~G__TTEmcTrack();
18677 }
18678 G__setgvp((long)gvp);
18679 }
18680 } else {
18681 if (gvp == (char*)G__PVOID) {
18682 delete (TEmcTrack*) soff;
18683 } else {
18684 G__setgvp((long) G__PVOID);
18685 ((TEmcTrack*) (soff))->~G__TTEmcTrack();
18686 G__setgvp((long)gvp);
18687 }
18688 }
18689 G__setnull(result7);
18690 return(1 || funcname || hash || result7 || libp) ;
18691}
18692
18693// automatic assignment operator
18694static int G__RootEventData_rootcint_479_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18695{
18696 TEmcTrack* dest = (TEmcTrack*) G__getstructoffset();
18697 *dest = *(TEmcTrack*) libp->para[0].ref;
18698 const TEmcTrack& obj = *dest;
18699 result7->ref = (long) (&obj);
18700 result7->obj.i = (long) (&obj);
18701 return(1 || funcname || hash || result7 || libp) ;
18702}
18703
18704
18705/* TMucTrack */
18706static int G__RootEventData_rootcint_480_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18707{
18708 TMucTrack* p = NULL;
18709 char* gvp = (char*) G__getgvp();
18710 int n = G__getaryconstruct();
18711 if (n) {
18712 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18713 p = new TMucTrack[n];
18714 } else {
18715 p = new((void*) gvp) TMucTrack[n];
18716 }
18717 } else {
18718 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
18719 p = new TMucTrack;
18720 } else {
18721 p = new((void*) gvp) TMucTrack;
18722 }
18723 }
18724 result7->obj.i = (long) p;
18725 result7->ref = (long) p;
18726 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
18727 return(1 || funcname || hash || result7 || libp) ;
18728}
18729
18730static int G__RootEventData_rootcint_480_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18731{
18732 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->trackId());
18733 return(1 || funcname || hash || result7 || libp) ;
18734}
18735
18736static int G__RootEventData_rootcint_480_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18737{
18738 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->id());
18739 return(1 || funcname || hash || result7 || libp) ;
18740}
18741
18742static int G__RootEventData_rootcint_480_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18743{
18744 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->status());
18745 return(1 || funcname || hash || result7 || libp) ;
18746}
18747
18748static int G__RootEventData_rootcint_480_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18749{
18750 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->type());
18751 return(1 || funcname || hash || result7 || libp) ;
18752}
18753
18754static int G__RootEventData_rootcint_480_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18755{
18756 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->startPart());
18757 return(1 || funcname || hash || result7 || libp) ;
18758}
18759
18760static int G__RootEventData_rootcint_480_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18761{
18762 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->endPart());
18763 return(1 || funcname || hash || result7 || libp) ;
18764}
18765
18766static int G__RootEventData_rootcint_480_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18767{
18768 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->brLastLayer());
18769 return(1 || funcname || hash || result7 || libp) ;
18770}
18771
18772static int G__RootEventData_rootcint_480_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18773{
18774 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->ecLastLayer());
18775 return(1 || funcname || hash || result7 || libp) ;
18776}
18777
18778static int G__RootEventData_rootcint_480_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18779{
18780 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->numHits());
18781 return(1 || funcname || hash || result7 || libp) ;
18782}
18783
18784static int G__RootEventData_rootcint_480_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18785{
18786 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->numLayers());
18787 return(1 || funcname || hash || result7 || libp) ;
18788}
18789
18790static int G__RootEventData_rootcint_480_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18791{
18792 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->maxHitsInLayer());
18793 return(1 || funcname || hash || result7 || libp) ;
18794}
18795
18796static int G__RootEventData_rootcint_480_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18797{
18798 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->depth());
18799 return(1 || funcname || hash || result7 || libp) ;
18800}
18801
18802static int G__RootEventData_rootcint_480_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18803{
18804 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->chi2());
18805 return(1 || funcname || hash || result7 || libp) ;
18806}
18807
18808static int G__RootEventData_rootcint_480_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18809{
18810 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->dof());
18811 return(1 || funcname || hash || result7 || libp) ;
18812}
18813
18814static int G__RootEventData_rootcint_480_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18815{
18816 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->rms());
18817 return(1 || funcname || hash || result7 || libp) ;
18818}
18819
18820static int G__RootEventData_rootcint_480_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18821{
18822 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->xPos());
18823 return(1 || funcname || hash || result7 || libp) ;
18824}
18825
18826static int G__RootEventData_rootcint_480_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18827{
18828 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->yPos());
18829 return(1 || funcname || hash || result7 || libp) ;
18830}
18831
18832static int G__RootEventData_rootcint_480_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18833{
18834 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->zPos());
18835 return(1 || funcname || hash || result7 || libp) ;
18836}
18837
18838static int G__RootEventData_rootcint_480_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18839{
18840 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->xPosSigma());
18841 return(1 || funcname || hash || result7 || libp) ;
18842}
18843
18844static int G__RootEventData_rootcint_480_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18845{
18846 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->yPosSigma());
18847 return(1 || funcname || hash || result7 || libp) ;
18848}
18849
18850static int G__RootEventData_rootcint_480_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18851{
18852 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->zPosSigma());
18853 return(1 || funcname || hash || result7 || libp) ;
18854}
18855
18856static int G__RootEventData_rootcint_480_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18857{
18858 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->px());
18859 return(1 || funcname || hash || result7 || libp) ;
18860}
18861
18862static int G__RootEventData_rootcint_480_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18863{
18864 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->py());
18865 return(1 || funcname || hash || result7 || libp) ;
18866}
18867
18868static int G__RootEventData_rootcint_480_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18869{
18870 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->pz());
18871 return(1 || funcname || hash || result7 || libp) ;
18872}
18873
18874static int G__RootEventData_rootcint_480_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18875{
18876 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->distance());
18877 return(1 || funcname || hash || result7 || libp) ;
18878}
18879
18880static int G__RootEventData_rootcint_480_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18881{
18882 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->deltaPhi());
18883 return(1 || funcname || hash || result7 || libp) ;
18884}
18885
18886static int G__RootEventData_rootcint_480_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18887{
18888 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->kalRechi2());
18889 return(1 || funcname || hash || result7 || libp) ;
18890}
18891
18892static int G__RootEventData_rootcint_480_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18893{
18894 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kaldof());
18895 return(1 || funcname || hash || result7 || libp) ;
18896}
18897
18898static int G__RootEventData_rootcint_480_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18899{
18900 G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->kaldepth());
18901 return(1 || funcname || hash || result7 || libp) ;
18902}
18903
18904static int G__RootEventData_rootcint_480_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18905{
18906 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kalbrLastLayer());
18907 return(1 || funcname || hash || result7 || libp) ;
18908}
18909
18910static int G__RootEventData_rootcint_480_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18911{
18912 G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kalecLastLayer());
18913 return(1 || funcname || hash || result7 || libp) ;
18914}
18915
18916static int G__RootEventData_rootcint_480_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18917{
18918 ((TMucTrack*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
18919 G__setnull(result7);
18920 return(1 || funcname || hash || result7 || libp) ;
18921}
18922
18923static int G__RootEventData_rootcint_480_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18924{
18925 ((TMucTrack*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
18926 G__setnull(result7);
18927 return(1 || funcname || hash || result7 || libp) ;
18928}
18929
18930static int G__RootEventData_rootcint_480_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18931{
18932 ((TMucTrack*) G__getstructoffset())->setStatus((Int_t) G__int(libp->para[0]));
18933 G__setnull(result7);
18934 return(1 || funcname || hash || result7 || libp) ;
18935}
18936
18937static int G__RootEventData_rootcint_480_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18938{
18939 ((TMucTrack*) G__getstructoffset())->setType((Int_t) G__int(libp->para[0]));
18940 G__setnull(result7);
18941 return(1 || funcname || hash || result7 || libp) ;
18942}
18943
18944static int G__RootEventData_rootcint_480_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18945{
18946 ((TMucTrack*) G__getstructoffset())->setStartPart((Int_t) G__int(libp->para[0]));
18947 G__setnull(result7);
18948 return(1 || funcname || hash || result7 || libp) ;
18949}
18950
18951static int G__RootEventData_rootcint_480_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18952{
18953 ((TMucTrack*) G__getstructoffset())->setEndPart((Int_t) G__int(libp->para[0]));
18954 G__setnull(result7);
18955 return(1 || funcname || hash || result7 || libp) ;
18956}
18957
18958static int G__RootEventData_rootcint_480_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18959{
18960 ((TMucTrack*) G__getstructoffset())->setBrLastLayer((Int_t) G__int(libp->para[0]));
18961 G__setnull(result7);
18962 return(1 || funcname || hash || result7 || libp) ;
18963}
18964
18965static int G__RootEventData_rootcint_480_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18966{
18967 ((TMucTrack*) G__getstructoffset())->setEcLastLayer((Int_t) G__int(libp->para[0]));
18968 G__setnull(result7);
18969 return(1 || funcname || hash || result7 || libp) ;
18970}
18971
18972static int G__RootEventData_rootcint_480_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18973{
18974 ((TMucTrack*) G__getstructoffset())->setNumHits((Int_t) G__int(libp->para[0]));
18975 G__setnull(result7);
18976 return(1 || funcname || hash || result7 || libp) ;
18977}
18978
18979static int G__RootEventData_rootcint_480_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18980{
18981 ((TMucTrack*) G__getstructoffset())->setNumLayers((Int_t) G__int(libp->para[0]));
18982 G__setnull(result7);
18983 return(1 || funcname || hash || result7 || libp) ;
18984}
18985
18986static int G__RootEventData_rootcint_480_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18987{
18988 ((TMucTrack*) G__getstructoffset())->setMaxHitsInLayer((Int_t) G__int(libp->para[0]));
18989 G__setnull(result7);
18990 return(1 || funcname || hash || result7 || libp) ;
18991}
18992
18993static int G__RootEventData_rootcint_480_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
18994{
18995 ((TMucTrack*) G__getstructoffset())->setDepth((Double_t) G__double(libp->para[0]));
18996 G__setnull(result7);
18997 return(1 || funcname || hash || result7 || libp) ;
18998}
18999
19000static int G__RootEventData_rootcint_480_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19001{
19002 ((TMucTrack*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
19003 G__setnull(result7);
19004 return(1 || funcname || hash || result7 || libp) ;
19005}
19006
19007static int G__RootEventData_rootcint_480_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19008{
19009 ((TMucTrack*) G__getstructoffset())->setDof((Int_t) G__int(libp->para[0]));
19010 G__setnull(result7);
19011 return(1 || funcname || hash || result7 || libp) ;
19012}
19013
19014static int G__RootEventData_rootcint_480_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19015{
19016 ((TMucTrack*) G__getstructoffset())->setRms((Double_t) G__double(libp->para[0]));
19017 G__setnull(result7);
19018 return(1 || funcname || hash || result7 || libp) ;
19019}
19020
19021static int G__RootEventData_rootcint_480_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19022{
19023 ((TMucTrack*) G__getstructoffset())->setXPos((Double_t) G__double(libp->para[0]));
19024 G__setnull(result7);
19025 return(1 || funcname || hash || result7 || libp) ;
19026}
19027
19028static int G__RootEventData_rootcint_480_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19029{
19030 ((TMucTrack*) G__getstructoffset())->setYPos((Double_t) G__double(libp->para[0]));
19031 G__setnull(result7);
19032 return(1 || funcname || hash || result7 || libp) ;
19033}
19034
19035static int G__RootEventData_rootcint_480_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19036{
19037 ((TMucTrack*) G__getstructoffset())->setZPos((Double_t) G__double(libp->para[0]));
19038 G__setnull(result7);
19039 return(1 || funcname || hash || result7 || libp) ;
19040}
19041
19042static int G__RootEventData_rootcint_480_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19043{
19044 ((TMucTrack*) G__getstructoffset())->setXPosSigma((Double_t) G__double(libp->para[0]));
19045 G__setnull(result7);
19046 return(1 || funcname || hash || result7 || libp) ;
19047}
19048
19049static int G__RootEventData_rootcint_480_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19050{
19051 ((TMucTrack*) G__getstructoffset())->setYPosSigma((Double_t) G__double(libp->para[0]));
19052 G__setnull(result7);
19053 return(1 || funcname || hash || result7 || libp) ;
19054}
19055
19056static int G__RootEventData_rootcint_480_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19057{
19058 ((TMucTrack*) G__getstructoffset())->setZPosSigma((Double_t) G__double(libp->para[0]));
19059 G__setnull(result7);
19060 return(1 || funcname || hash || result7 || libp) ;
19061}
19062
19063static int G__RootEventData_rootcint_480_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19064{
19065 ((TMucTrack*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
19066 G__setnull(result7);
19067 return(1 || funcname || hash || result7 || libp) ;
19068}
19069
19070static int G__RootEventData_rootcint_480_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19071{
19072 ((TMucTrack*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
19073 G__setnull(result7);
19074 return(1 || funcname || hash || result7 || libp) ;
19075}
19076
19077static int G__RootEventData_rootcint_480_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19078{
19079 ((TMucTrack*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
19080 G__setnull(result7);
19081 return(1 || funcname || hash || result7 || libp) ;
19082}
19083
19084static int G__RootEventData_rootcint_480_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19085{
19086 ((TMucTrack*) G__getstructoffset())->setDistance((double) G__double(libp->para[0]));
19087 G__setnull(result7);
19088 return(1 || funcname || hash || result7 || libp) ;
19089}
19090
19091static int G__RootEventData_rootcint_480_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19092{
19093 ((TMucTrack*) G__getstructoffset())->setDeltaPhi((double) G__double(libp->para[0]));
19094 G__setnull(result7);
19095 return(1 || funcname || hash || result7 || libp) ;
19096}
19097
19098static int G__RootEventData_rootcint_480_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19099{
19100 ((TMucTrack*) G__getstructoffset())->setkalRechi2((Double_t) G__double(libp->para[0]));
19101 G__setnull(result7);
19102 return(1 || funcname || hash || result7 || libp) ;
19103}
19104
19105static int G__RootEventData_rootcint_480_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19106{
19107 ((TMucTrack*) G__getstructoffset())->setkalDof((Int_t) G__int(libp->para[0]));
19108 G__setnull(result7);
19109 return(1 || funcname || hash || result7 || libp) ;
19110}
19111
19112static int G__RootEventData_rootcint_480_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19113{
19114 ((TMucTrack*) G__getstructoffset())->setkalDepth((Double_t) G__double(libp->para[0]));
19115 G__setnull(result7);
19116 return(1 || funcname || hash || result7 || libp) ;
19117}
19118
19119static int G__RootEventData_rootcint_480_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19120{
19121 ((TMucTrack*) G__getstructoffset())->setkalbrLastLayer((Int_t) G__int(libp->para[0]));
19122 G__setnull(result7);
19123 return(1 || funcname || hash || result7 || libp) ;
19124}
19125
19126static int G__RootEventData_rootcint_480_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19127{
19128 ((TMucTrack*) G__getstructoffset())->setkalecLastLayer((Int_t) G__int(libp->para[0]));
19129 G__setnull(result7);
19130 return(1 || funcname || hash || result7 || libp) ;
19131}
19132
19133static int G__RootEventData_rootcint_480_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19134{
19135 G__letint(result7, 85, (long) TMucTrack::Class());
19136 return(1 || funcname || hash || result7 || libp) ;
19137}
19138
19139static int G__RootEventData_rootcint_480_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19140{
19141 G__letint(result7, 67, (long) TMucTrack::Class_Name());
19142 return(1 || funcname || hash || result7 || libp) ;
19143}
19144
19145static int G__RootEventData_rootcint_480_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19146{
19147 G__letint(result7, 115, (long) TMucTrack::Class_Version());
19148 return(1 || funcname || hash || result7 || libp) ;
19149}
19150
19151static int G__RootEventData_rootcint_480_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19152{
19153 TMucTrack::Dictionary();
19154 G__setnull(result7);
19155 return(1 || funcname || hash || result7 || libp) ;
19156}
19157
19158static int G__RootEventData_rootcint_480_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19159{
19160 ((TMucTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
19161 G__setnull(result7);
19162 return(1 || funcname || hash || result7 || libp) ;
19163}
19164
19165static int G__RootEventData_rootcint_480_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19166{
19167 G__letint(result7, 67, (long) TMucTrack::DeclFileName());
19168 return(1 || funcname || hash || result7 || libp) ;
19169}
19170
19171static int G__RootEventData_rootcint_480_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19172{
19173 G__letint(result7, 105, (long) TMucTrack::ImplFileLine());
19174 return(1 || funcname || hash || result7 || libp) ;
19175}
19176
19177static int G__RootEventData_rootcint_480_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19178{
19179 G__letint(result7, 67, (long) TMucTrack::ImplFileName());
19180 return(1 || funcname || hash || result7 || libp) ;
19181}
19182
19183static int G__RootEventData_rootcint_480_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19184{
19185 G__letint(result7, 105, (long) TMucTrack::DeclFileLine());
19186 return(1 || funcname || hash || result7 || libp) ;
19187}
19188
19189// automatic copy constructor
19190static int G__RootEventData_rootcint_480_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19191
19192{
19193 TMucTrack* p;
19194 void* tmp = (void*) G__int(libp->para[0]);
19195 p = new TMucTrack(*(TMucTrack*) tmp);
19196 result7->obj.i = (long) p;
19197 result7->ref = (long) p;
19198 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
19199 return(1 || funcname || hash || result7 || libp) ;
19200}
19201
19202// automatic destructor
19203typedef TMucTrack G__TTMucTrack;
19204static int G__RootEventData_rootcint_480_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19205{
19206 char* gvp = (char*) G__getgvp();
19207 long soff = G__getstructoffset();
19208 int n = G__getaryconstruct();
19209 //
19210 //has_a_delete: 1
19211 //has_own_delete1arg: 0
19212 //has_own_delete2arg: 0
19213 //
19214 if (!soff) {
19215 return(1);
19216 }
19217 if (n) {
19218 if (gvp == (char*)G__PVOID) {
19219 delete[] (TMucTrack*) soff;
19220 } else {
19221 G__setgvp((long) G__PVOID);
19222 for (int i = n - 1; i >= 0; --i) {
19223 ((TMucTrack*) (soff+(sizeof(TMucTrack)*i)))->~G__TTMucTrack();
19224 }
19225 G__setgvp((long)gvp);
19226 }
19227 } else {
19228 if (gvp == (char*)G__PVOID) {
19229 delete (TMucTrack*) soff;
19230 } else {
19231 G__setgvp((long) G__PVOID);
19232 ((TMucTrack*) (soff))->~G__TTMucTrack();
19233 G__setgvp((long)gvp);
19234 }
19235 }
19236 G__setnull(result7);
19237 return(1 || funcname || hash || result7 || libp) ;
19238}
19239
19240// automatic assignment operator
19241static int G__RootEventData_rootcint_480_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19242{
19243 TMucTrack* dest = (TMucTrack*) G__getstructoffset();
19244 *dest = *(TMucTrack*) libp->para[0].ref;
19245 const TMucTrack& obj = *dest;
19246 result7->ref = (long) (&obj);
19247 result7->obj.i = (long) (&obj);
19248 return(1 || funcname || hash || result7 || libp) ;
19249}
19250
19251
19252/* TMdcDedx */
19253static int G__RootEventData_rootcint_481_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19254{
19255 TMdcDedx* p = NULL;
19256 char* gvp = (char*) G__getgvp();
19257 int n = G__getaryconstruct();
19258 if (n) {
19259 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19260 p = new TMdcDedx[n];
19261 } else {
19262 p = new((void*) gvp) TMdcDedx[n];
19263 }
19264 } else {
19265 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19266 p = new TMdcDedx;
19267 } else {
19268 p = new((void*) gvp) TMdcDedx;
19269 }
19270 }
19271 result7->obj.i = (long) p;
19272 result7->ref = (long) p;
19273 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
19274 return(1 || funcname || hash || result7 || libp) ;
19275}
19276
19277static int G__RootEventData_rootcint_481_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19278{
19279 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->trackId());
19280 return(1 || funcname || hash || result7 || libp) ;
19281}
19282
19283static int G__RootEventData_rootcint_481_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19284{
19285 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->particleId());
19286 return(1 || funcname || hash || result7 || libp) ;
19287}
19288
19289static int G__RootEventData_rootcint_481_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19290{
19291 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->status());
19292 return(1 || funcname || hash || result7 || libp) ;
19293}
19294
19295static int G__RootEventData_rootcint_481_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19296{
19297 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->truncAlg());
19298 return(1 || funcname || hash || result7 || libp) ;
19299}
19300
19301static int G__RootEventData_rootcint_481_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19302{
19303 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chi((int) G__int(libp->para[0])));
19304 return(1 || funcname || hash || result7 || libp) ;
19305}
19306
19307static int G__RootEventData_rootcint_481_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19308{
19309 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiE());
19310 return(1 || funcname || hash || result7 || libp) ;
19311}
19312
19313static int G__RootEventData_rootcint_481_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19314{
19315 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiMu());
19316 return(1 || funcname || hash || result7 || libp) ;
19317}
19318
19319static int G__RootEventData_rootcint_481_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19320{
19321 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiPi());
19322 return(1 || funcname || hash || result7 || libp) ;
19323}
19324
19325static int G__RootEventData_rootcint_481_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19326{
19327 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiK());
19328 return(1 || funcname || hash || result7 || libp) ;
19329}
19330
19331static int G__RootEventData_rootcint_481_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19332{
19333 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiP());
19334 return(1 || funcname || hash || result7 || libp) ;
19335}
19336
19337static int G__RootEventData_rootcint_481_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19338{
19339 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->numGoodHits());
19340 return(1 || funcname || hash || result7 || libp) ;
19341}
19342
19343static int G__RootEventData_rootcint_481_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19344{
19345 G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->numTotalHits());
19346 return(1 || funcname || hash || result7 || libp) ;
19347}
19348
19349static int G__RootEventData_rootcint_481_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19350{
19351 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->probPH());
19352 return(1 || funcname || hash || result7 || libp) ;
19353}
19354
19355static int G__RootEventData_rootcint_481_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19356{
19357 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->normPH());
19358 return(1 || funcname || hash || result7 || libp) ;
19359}
19360
19361static int G__RootEventData_rootcint_481_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19362{
19363 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->errorPH());
19364 return(1 || funcname || hash || result7 || libp) ;
19365}
19366
19367static int G__RootEventData_rootcint_481_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19368{
19369 G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->twentyPH());
19370 return(1 || funcname || hash || result7 || libp) ;
19371}
19372
19373static int G__RootEventData_rootcint_481_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19374{
19375 ((TMdcDedx*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
19376 G__setnull(result7);
19377 return(1 || funcname || hash || result7 || libp) ;
19378}
19379
19380static int G__RootEventData_rootcint_481_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19381{
19382 ((TMdcDedx*) G__getstructoffset())->setParticleId((const Int_t) G__int(libp->para[0]));
19383 G__setnull(result7);
19384 return(1 || funcname || hash || result7 || libp) ;
19385}
19386
19387static int G__RootEventData_rootcint_481_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19388{
19389 ((TMdcDedx*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
19390 G__setnull(result7);
19391 return(1 || funcname || hash || result7 || libp) ;
19392}
19393
19394static int G__RootEventData_rootcint_481_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19395{
19396 ((TMdcDedx*) G__getstructoffset())->setTruncAlg((const Int_t) G__int(libp->para[0]));
19397 G__setnull(result7);
19398 return(1 || funcname || hash || result7 || libp) ;
19399}
19400
19401static int G__RootEventData_rootcint_481_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19402{
19403 ((TMdcDedx*) G__getstructoffset())->setChiE((const Double_t) G__double(libp->para[0]));
19404 G__setnull(result7);
19405 return(1 || funcname || hash || result7 || libp) ;
19406}
19407
19408static int G__RootEventData_rootcint_481_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19409{
19410 ((TMdcDedx*) G__getstructoffset())->setChiMu((const Double_t) G__double(libp->para[0]));
19411 G__setnull(result7);
19412 return(1 || funcname || hash || result7 || libp) ;
19413}
19414
19415static int G__RootEventData_rootcint_481_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19416{
19417 ((TMdcDedx*) G__getstructoffset())->setChiPi((const Double_t) G__double(libp->para[0]));
19418 G__setnull(result7);
19419 return(1 || funcname || hash || result7 || libp) ;
19420}
19421
19422static int G__RootEventData_rootcint_481_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19423{
19424 ((TMdcDedx*) G__getstructoffset())->setChiK((const Double_t) G__double(libp->para[0]));
19425 G__setnull(result7);
19426 return(1 || funcname || hash || result7 || libp) ;
19427}
19428
19429static int G__RootEventData_rootcint_481_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19430{
19431 ((TMdcDedx*) G__getstructoffset())->setChiP((const Double_t) G__double(libp->para[0]));
19432 G__setnull(result7);
19433 return(1 || funcname || hash || result7 || libp) ;
19434}
19435
19436static int G__RootEventData_rootcint_481_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19437{
19438 ((TMdcDedx*) G__getstructoffset())->setNumGoodHits((const Int_t) G__int(libp->para[0]));
19439 G__setnull(result7);
19440 return(1 || funcname || hash || result7 || libp) ;
19441}
19442
19443static int G__RootEventData_rootcint_481_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19444{
19445 ((TMdcDedx*) G__getstructoffset())->setNumTotalHits((const Int_t) G__int(libp->para[0]));
19446 G__setnull(result7);
19447 return(1 || funcname || hash || result7 || libp) ;
19448}
19449
19450static int G__RootEventData_rootcint_481_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19451{
19452 ((TMdcDedx*) G__getstructoffset())->setProbPH((const Double_t) G__double(libp->para[0]));
19453 G__setnull(result7);
19454 return(1 || funcname || hash || result7 || libp) ;
19455}
19456
19457static int G__RootEventData_rootcint_481_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19458{
19459 ((TMdcDedx*) G__getstructoffset())->setNormPH((const Double_t) G__double(libp->para[0]));
19460 G__setnull(result7);
19461 return(1 || funcname || hash || result7 || libp) ;
19462}
19463
19464static int G__RootEventData_rootcint_481_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19465{
19466 ((TMdcDedx*) G__getstructoffset())->setErrorPH((const Double_t) G__double(libp->para[0]));
19467 G__setnull(result7);
19468 return(1 || funcname || hash || result7 || libp) ;
19469}
19470
19471static int G__RootEventData_rootcint_481_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19472{
19473 ((TMdcDedx*) G__getstructoffset())->setTwentyPH((const Double_t) G__double(libp->para[0]));
19474 G__setnull(result7);
19475 return(1 || funcname || hash || result7 || libp) ;
19476}
19477
19478static int G__RootEventData_rootcint_481_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19479{
19480 G__letint(result7, 85, (long) TMdcDedx::Class());
19481 return(1 || funcname || hash || result7 || libp) ;
19482}
19483
19484static int G__RootEventData_rootcint_481_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19485{
19486 G__letint(result7, 67, (long) TMdcDedx::Class_Name());
19487 return(1 || funcname || hash || result7 || libp) ;
19488}
19489
19490static int G__RootEventData_rootcint_481_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19491{
19492 G__letint(result7, 115, (long) TMdcDedx::Class_Version());
19493 return(1 || funcname || hash || result7 || libp) ;
19494}
19495
19496static int G__RootEventData_rootcint_481_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19497{
19498 TMdcDedx::Dictionary();
19499 G__setnull(result7);
19500 return(1 || funcname || hash || result7 || libp) ;
19501}
19502
19503static int G__RootEventData_rootcint_481_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19504{
19505 ((TMdcDedx*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
19506 G__setnull(result7);
19507 return(1 || funcname || hash || result7 || libp) ;
19508}
19509
19510static int G__RootEventData_rootcint_481_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19511{
19512 G__letint(result7, 67, (long) TMdcDedx::DeclFileName());
19513 return(1 || funcname || hash || result7 || libp) ;
19514}
19515
19516static int G__RootEventData_rootcint_481_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19517{
19518 G__letint(result7, 105, (long) TMdcDedx::ImplFileLine());
19519 return(1 || funcname || hash || result7 || libp) ;
19520}
19521
19522static int G__RootEventData_rootcint_481_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19523{
19524 G__letint(result7, 67, (long) TMdcDedx::ImplFileName());
19525 return(1 || funcname || hash || result7 || libp) ;
19526}
19527
19528static int G__RootEventData_rootcint_481_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19529{
19530 G__letint(result7, 105, (long) TMdcDedx::DeclFileLine());
19531 return(1 || funcname || hash || result7 || libp) ;
19532}
19533
19534// automatic copy constructor
19535static int G__RootEventData_rootcint_481_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19536
19537{
19538 TMdcDedx* p;
19539 void* tmp = (void*) G__int(libp->para[0]);
19540 p = new TMdcDedx(*(TMdcDedx*) tmp);
19541 result7->obj.i = (long) p;
19542 result7->ref = (long) p;
19543 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
19544 return(1 || funcname || hash || result7 || libp) ;
19545}
19546
19547// automatic destructor
19548typedef TMdcDedx G__TTMdcDedx;
19549static int G__RootEventData_rootcint_481_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19550{
19551 char* gvp = (char*) G__getgvp();
19552 long soff = G__getstructoffset();
19553 int n = G__getaryconstruct();
19554 //
19555 //has_a_delete: 1
19556 //has_own_delete1arg: 0
19557 //has_own_delete2arg: 0
19558 //
19559 if (!soff) {
19560 return(1);
19561 }
19562 if (n) {
19563 if (gvp == (char*)G__PVOID) {
19564 delete[] (TMdcDedx*) soff;
19565 } else {
19566 G__setgvp((long) G__PVOID);
19567 for (int i = n - 1; i >= 0; --i) {
19568 ((TMdcDedx*) (soff+(sizeof(TMdcDedx)*i)))->~G__TTMdcDedx();
19569 }
19570 G__setgvp((long)gvp);
19571 }
19572 } else {
19573 if (gvp == (char*)G__PVOID) {
19574 delete (TMdcDedx*) soff;
19575 } else {
19576 G__setgvp((long) G__PVOID);
19577 ((TMdcDedx*) (soff))->~G__TTMdcDedx();
19578 G__setgvp((long)gvp);
19579 }
19580 }
19581 G__setnull(result7);
19582 return(1 || funcname || hash || result7 || libp) ;
19583}
19584
19585// automatic assignment operator
19586static int G__RootEventData_rootcint_481_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19587{
19588 TMdcDedx* dest = (TMdcDedx*) G__getstructoffset();
19589 *dest = *(TMdcDedx*) libp->para[0].ref;
19590 const TMdcDedx& obj = *dest;
19591 result7->ref = (long) (&obj);
19592 result7->obj.i = (long) (&obj);
19593 return(1 || funcname || hash || result7 || libp) ;
19594}
19595
19596
19597/* TExtTrack */
19598static int G__RootEventData_rootcint_483_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19599{
19600 TExtTrack* p = NULL;
19601 char* gvp = (char*) G__getgvp();
19602 int n = G__getaryconstruct();
19603 if (n) {
19604 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19605 p = new TExtTrack[n];
19606 } else {
19607 p = new((void*) gvp) TExtTrack[n];
19608 }
19609 } else {
19610 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
19611 p = new TExtTrack;
19612 } else {
19613 p = new((void*) gvp) TExtTrack;
19614 }
19615 }
19616 result7->obj.i = (long) p;
19617 result7->ref = (long) p;
19618 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
19619 return(1 || funcname || hash || result7 || libp) ;
19620}
19621
19622static int G__RootEventData_rootcint_483_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19623{
19624 ((TExtTrack*) G__getstructoffset())->SetTrackId((const Int_t) G__int(libp->para[0]));
19625 G__setnull(result7);
19626 return(1 || funcname || hash || result7 || libp) ;
19627}
19628
19629static int G__RootEventData_rootcint_483_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19630{
19631 ((TExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]));
19632 G__setnull(result7);
19633 return(1 || funcname || hash || result7 || libp) ;
19634}
19635
19636static int G__RootEventData_rootcint_483_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19637{
19638 ((TExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]));
19639 G__setnull(result7);
19640 return(1 || funcname || hash || result7 || libp) ;
19641}
19642
19643static int G__RootEventData_rootcint_483_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19644{
19645 ((TExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]));
19646 G__setnull(result7);
19647 return(1 || funcname || hash || result7 || libp) ;
19648}
19649
19650static int G__RootEventData_rootcint_483_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19651{
19652 ((TExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]));
19653 G__setnull(result7);
19654 return(1 || funcname || hash || result7 || libp) ;
19655}
19656
19657static int G__RootEventData_rootcint_483_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19658{
19659 ((TExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]));
19660 G__setnull(result7);
19661 return(1 || funcname || hash || result7 || libp) ;
19662}
19663
19664static int G__RootEventData_rootcint_483_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19665{
19666 ((TExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]));
19667 G__setnull(result7);
19668 return(1 || funcname || hash || result7 || libp) ;
19669}
19670
19671static int G__RootEventData_rootcint_483_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19672{
19673 ((TExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])));
19674 G__setnull(result7);
19675 return(1 || funcname || hash || result7 || libp) ;
19676}
19677
19678static int G__RootEventData_rootcint_483_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19679{
19680 ((TExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]));
19681 G__setnull(result7);
19682 return(1 || funcname || hash || result7 || libp) ;
19683}
19684
19685static int G__RootEventData_rootcint_483_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19686{
19687 ((TExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]));
19688 G__setnull(result7);
19689 return(1 || funcname || hash || result7 || libp) ;
19690}
19691
19692static int G__RootEventData_rootcint_483_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19693{
19694 ((TExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]));
19695 G__setnull(result7);
19696 return(1 || funcname || hash || result7 || libp) ;
19697}
19698
19699static int G__RootEventData_rootcint_483_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19700{
19701 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
19702 G__setnull(result7);
19703 return(1 || funcname || hash || result7 || libp) ;
19704}
19705
19706static int G__RootEventData_rootcint_483_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19707{
19708 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
19709 G__setnull(result7);
19710 return(1 || funcname || hash || result7 || libp) ;
19711}
19712
19713static int G__RootEventData_rootcint_483_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19714{
19715 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
19716 G__setnull(result7);
19717 return(1 || funcname || hash || result7 || libp) ;
19718}
19719
19720static int G__RootEventData_rootcint_483_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19721{
19722 ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
19723 G__setnull(result7);
19724 return(1 || funcname || hash || result7 || libp) ;
19725}
19726
19727static int G__RootEventData_rootcint_483_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19728{
19729 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
19730 ((TExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a);
19731 G__setnull(result7);
19732 return(1 || funcname || hash || result7 || libp) ;
19733}
19734
19735static int G__RootEventData_rootcint_483_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19736{
19737 ((TExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]));
19738 G__setnull(result7);
19739 return(1 || funcname || hash || result7 || libp) ;
19740}
19741
19742static int G__RootEventData_rootcint_483_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19743{
19744 ((TExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]));
19745 G__setnull(result7);
19746 return(1 || funcname || hash || result7 || libp) ;
19747}
19748
19749static int G__RootEventData_rootcint_483_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19750{
19751 ((TExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]));
19752 G__setnull(result7);
19753 return(1 || funcname || hash || result7 || libp) ;
19754}
19755
19756static int G__RootEventData_rootcint_483_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19757{
19758 ((TExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]));
19759 G__setnull(result7);
19760 return(1 || funcname || hash || result7 || libp) ;
19761}
19762
19763static int G__RootEventData_rootcint_483_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19764{
19765 ((TExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]));
19766 G__setnull(result7);
19767 return(1 || funcname || hash || result7 || libp) ;
19768}
19769
19770static int G__RootEventData_rootcint_483_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19771{
19772 ((TExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]));
19773 G__setnull(result7);
19774 return(1 || funcname || hash || result7 || libp) ;
19775}
19776
19777static int G__RootEventData_rootcint_483_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19778{
19779 ((TExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])));
19780 G__setnull(result7);
19781 return(1 || funcname || hash || result7 || libp) ;
19782}
19783
19784static int G__RootEventData_rootcint_483_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19785{
19786 ((TExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]));
19787 G__setnull(result7);
19788 return(1 || funcname || hash || result7 || libp) ;
19789}
19790
19791static int G__RootEventData_rootcint_483_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19792{
19793 ((TExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]));
19794 G__setnull(result7);
19795 return(1 || funcname || hash || result7 || libp) ;
19796}
19797
19798static int G__RootEventData_rootcint_483_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19799{
19800 ((TExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]));
19801 G__setnull(result7);
19802 return(1 || funcname || hash || result7 || libp) ;
19803}
19804
19805static int G__RootEventData_rootcint_483_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19806{
19807 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
19808 G__setnull(result7);
19809 return(1 || funcname || hash || result7 || libp) ;
19810}
19811
19812static int G__RootEventData_rootcint_483_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19813{
19814 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
19815 G__setnull(result7);
19816 return(1 || funcname || hash || result7 || libp) ;
19817}
19818
19819static int G__RootEventData_rootcint_483_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19820{
19821 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
19822 G__setnull(result7);
19823 return(1 || funcname || hash || result7 || libp) ;
19824}
19825
19826static int G__RootEventData_rootcint_483_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19827{
19828 ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
19829 G__setnull(result7);
19830 return(1 || funcname || hash || result7 || libp) ;
19831}
19832
19833static int G__RootEventData_rootcint_483_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19834{
19835 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
19836 ((TExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a);
19837 G__setnull(result7);
19838 return(1 || funcname || hash || result7 || libp) ;
19839}
19840
19841static int G__RootEventData_rootcint_483_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19842{
19843 ((TExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]));
19844 G__setnull(result7);
19845 return(1 || funcname || hash || result7 || libp) ;
19846}
19847
19848static int G__RootEventData_rootcint_483_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19849{
19850 ((TExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]));
19851 G__setnull(result7);
19852 return(1 || funcname || hash || result7 || libp) ;
19853}
19854
19855static int G__RootEventData_rootcint_483_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19856{
19857 ((TExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]));
19858 G__setnull(result7);
19859 return(1 || funcname || hash || result7 || libp) ;
19860}
19861
19862static int G__RootEventData_rootcint_483_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19863{
19864 ((TExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]));
19865 G__setnull(result7);
19866 return(1 || funcname || hash || result7 || libp) ;
19867}
19868
19869static int G__RootEventData_rootcint_483_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19870{
19871 ((TExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]));
19872 G__setnull(result7);
19873 return(1 || funcname || hash || result7 || libp) ;
19874}
19875
19876static int G__RootEventData_rootcint_483_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19877{
19878 ((TExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]));
19879 G__setnull(result7);
19880 return(1 || funcname || hash || result7 || libp) ;
19881}
19882
19883static int G__RootEventData_rootcint_483_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19884{
19885 ((TExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])));
19886 G__setnull(result7);
19887 return(1 || funcname || hash || result7 || libp) ;
19888}
19889
19890static int G__RootEventData_rootcint_483_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19891{
19892 ((TExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]));
19893 G__setnull(result7);
19894 return(1 || funcname || hash || result7 || libp) ;
19895}
19896
19897static int G__RootEventData_rootcint_483_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19898{
19899 ((TExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]));
19900 G__setnull(result7);
19901 return(1 || funcname || hash || result7 || libp) ;
19902}
19903
19904static int G__RootEventData_rootcint_483_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19905{
19906 ((TExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]));
19907 G__setnull(result7);
19908 return(1 || funcname || hash || result7 || libp) ;
19909}
19910
19911static int G__RootEventData_rootcint_483_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19912{
19913 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
19914 ((TExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a);
19915 G__setnull(result7);
19916 return(1 || funcname || hash || result7 || libp) ;
19917}
19918
19919static int G__RootEventData_rootcint_483_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19920{
19921 ((TExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]));
19922 G__setnull(result7);
19923 return(1 || funcname || hash || result7 || libp) ;
19924}
19925
19926static int G__RootEventData_rootcint_483_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19927{
19928 ((TExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]));
19929 G__setnull(result7);
19930 return(1 || funcname || hash || result7 || libp) ;
19931}
19932
19933static int G__RootEventData_rootcint_483_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19934{
19935 ((TExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]));
19936 G__setnull(result7);
19937 return(1 || funcname || hash || result7 || libp) ;
19938}
19939
19940static int G__RootEventData_rootcint_483_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19941{
19942 ((TExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]));
19943 G__setnull(result7);
19944 return(1 || funcname || hash || result7 || libp) ;
19945}
19946
19947static int G__RootEventData_rootcint_483_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19948{
19949 ((TExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]));
19950 G__setnull(result7);
19951 return(1 || funcname || hash || result7 || libp) ;
19952}
19953
19954static int G__RootEventData_rootcint_483_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19955{
19956 ((TExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]));
19957 G__setnull(result7);
19958 return(1 || funcname || hash || result7 || libp) ;
19959}
19960
19961static int G__RootEventData_rootcint_483_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19962{
19963 ((TExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]));
19964 G__setnull(result7);
19965 return(1 || funcname || hash || result7 || libp) ;
19966}
19967
19968static int G__RootEventData_rootcint_483_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19969{
19970 ((TExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])));
19971 G__setnull(result7);
19972 return(1 || funcname || hash || result7 || libp) ;
19973}
19974
19975static int G__RootEventData_rootcint_483_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19976{
19977 ((TExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]));
19978 G__setnull(result7);
19979 return(1 || funcname || hash || result7 || libp) ;
19980}
19981
19982static int G__RootEventData_rootcint_483_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19983{
19984 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
19985 G__setnull(result7);
19986 return(1 || funcname || hash || result7 || libp) ;
19987}
19988
19989static int G__RootEventData_rootcint_483_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19990{
19991 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]));
19992 G__setnull(result7);
19993 return(1 || funcname || hash || result7 || libp) ;
19994}
19995
19996static int G__RootEventData_rootcint_483_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
19997{
19998 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]));
19999 G__setnull(result7);
20000 return(1 || funcname || hash || result7 || libp) ;
20001}
20002
20003static int G__RootEventData_rootcint_483_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20004{
20005 ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]));
20006 G__setnull(result7);
20007 return(1 || funcname || hash || result7 || libp) ;
20008}
20009
20010static int G__RootEventData_rootcint_483_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20011{
20012 struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20013 ((TExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a);
20014 G__setnull(result7);
20015 return(1 || funcname || hash || result7 || libp) ;
20016}
20017
20018static int G__RootEventData_rootcint_483_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20019{
20020 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTrackId());
20021 return(1 || funcname || hash || result7 || libp) ;
20022}
20023
20024static int G__RootEventData_rootcint_483_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20025{
20026 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionX());
20027 return(1 || funcname || hash || result7 || libp) ;
20028}
20029
20030static int G__RootEventData_rootcint_483_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20031{
20032 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionY());
20033 return(1 || funcname || hash || result7 || libp) ;
20034}
20035
20036static int G__RootEventData_rootcint_483_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20037{
20038 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionZ());
20039 return(1 || funcname || hash || result7 || libp) ;
20040}
20041
20042static int G__RootEventData_rootcint_483_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20043{
20044 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumX());
20045 return(1 || funcname || hash || result7 || libp) ;
20046}
20047
20048static int G__RootEventData_rootcint_483_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20049{
20050 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumY());
20051 return(1 || funcname || hash || result7 || libp) ;
20052}
20053
20054static int G__RootEventData_rootcint_483_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20055{
20056 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumZ());
20057 return(1 || funcname || hash || result7 || libp) ;
20058}
20059
20060static int G__RootEventData_rootcint_483_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20061{
20062 {
20063 const TString* pobj;
20064 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetTof1VolumeName();
20065 pobj = new TString(xobj);
20066 result7->obj.i = (long) ((void*) pobj);
20067 result7->ref = result7->obj.i;
20068 G__store_tempobject(*result7);
20069 }
20070 return(1 || funcname || hash || result7 || libp) ;
20071}
20072
20073static int G__RootEventData_rootcint_483_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20074{
20075 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTof1VolumeNumber());
20076 return(1 || funcname || hash || result7 || libp) ;
20077}
20078
20079static int G__RootEventData_rootcint_483_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20080{
20081 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1());
20082 return(1 || funcname || hash || result7 || libp) ;
20083}
20084
20085static int G__RootEventData_rootcint_483_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20086{
20087 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1Path());
20088 return(1 || funcname || hash || result7 || libp) ;
20089}
20090
20091static int G__RootEventData_rootcint_483_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20092{
20093 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ());
20094 return(1 || funcname || hash || result7 || libp) ;
20095}
20096
20097static int G__RootEventData_rootcint_483_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20098{
20099 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT());
20100 return(1 || funcname || hash || result7 || libp) ;
20101}
20102
20103static int G__RootEventData_rootcint_483_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20104{
20105 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX());
20106 return(1 || funcname || hash || result7 || libp) ;
20107}
20108
20109static int G__RootEventData_rootcint_483_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20110{
20111 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY());
20112 return(1 || funcname || hash || result7 || libp) ;
20113}
20114
20115static int G__RootEventData_rootcint_483_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20116{
20117 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20118 return(1 || funcname || hash || result7 || libp) ;
20119}
20120
20121static int G__RootEventData_rootcint_483_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20122{
20123 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionX());
20124 return(1 || funcname || hash || result7 || libp) ;
20125}
20126
20127static int G__RootEventData_rootcint_483_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20128{
20129 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionY());
20130 return(1 || funcname || hash || result7 || libp) ;
20131}
20132
20133static int G__RootEventData_rootcint_483_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20134{
20135 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionZ());
20136 return(1 || funcname || hash || result7 || libp) ;
20137}
20138
20139static int G__RootEventData_rootcint_483_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20140{
20141 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumX());
20142 return(1 || funcname || hash || result7 || libp) ;
20143}
20144
20145static int G__RootEventData_rootcint_483_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20146{
20147 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumY());
20148 return(1 || funcname || hash || result7 || libp) ;
20149}
20150
20151static int G__RootEventData_rootcint_483_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20152{
20153 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumZ());
20154 return(1 || funcname || hash || result7 || libp) ;
20155}
20156
20157static int G__RootEventData_rootcint_483_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20158{
20159 {
20160 const TString* pobj;
20161 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetTof2VolumeName();
20162 pobj = new TString(xobj);
20163 result7->obj.i = (long) ((void*) pobj);
20164 result7->ref = result7->obj.i;
20165 G__store_tempobject(*result7);
20166 }
20167 return(1 || funcname || hash || result7 || libp) ;
20168}
20169
20170static int G__RootEventData_rootcint_483_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20171{
20172 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTof2VolumeNumber());
20173 return(1 || funcname || hash || result7 || libp) ;
20174}
20175
20176static int G__RootEventData_rootcint_483_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20177{
20178 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2());
20179 return(1 || funcname || hash || result7 || libp) ;
20180}
20181
20182static int G__RootEventData_rootcint_483_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20183{
20184 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2Path());
20185 return(1 || funcname || hash || result7 || libp) ;
20186}
20187
20188static int G__RootEventData_rootcint_483_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20189{
20190 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ());
20191 return(1 || funcname || hash || result7 || libp) ;
20192}
20193
20194static int G__RootEventData_rootcint_483_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20195{
20196 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT());
20197 return(1 || funcname || hash || result7 || libp) ;
20198}
20199
20200static int G__RootEventData_rootcint_483_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20201{
20202 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX());
20203 return(1 || funcname || hash || result7 || libp) ;
20204}
20205
20206static int G__RootEventData_rootcint_483_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20207{
20208 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY());
20209 return(1 || funcname || hash || result7 || libp) ;
20210}
20211
20212static int G__RootEventData_rootcint_483_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20213{
20214 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20215 return(1 || funcname || hash || result7 || libp) ;
20216}
20217
20218static int G__RootEventData_rootcint_483_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20219{
20220 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionX());
20221 return(1 || funcname || hash || result7 || libp) ;
20222}
20223
20224static int G__RootEventData_rootcint_483_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20225{
20226 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionY());
20227 return(1 || funcname || hash || result7 || libp) ;
20228}
20229
20230static int G__RootEventData_rootcint_483_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20231{
20232 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionZ());
20233 return(1 || funcname || hash || result7 || libp) ;
20234}
20235
20236static int G__RootEventData_rootcint_483_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20237{
20238 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumX());
20239 return(1 || funcname || hash || result7 || libp) ;
20240}
20241
20242static int G__RootEventData_rootcint_483_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20243{
20244 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumY());
20245 return(1 || funcname || hash || result7 || libp) ;
20246}
20247
20248static int G__RootEventData_rootcint_483_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20249{
20250 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumZ());
20251 return(1 || funcname || hash || result7 || libp) ;
20252}
20253
20254static int G__RootEventData_rootcint_483_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20255{
20256 {
20257 const TString* pobj;
20258 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetEmcVolumeName();
20259 pobj = new TString(xobj);
20260 result7->obj.i = (long) ((void*) pobj);
20261 result7->ref = result7->obj.i;
20262 G__store_tempobject(*result7);
20263 }
20264 return(1 || funcname || hash || result7 || libp) ;
20265}
20266
20267static int G__RootEventData_rootcint_483_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20268{
20269 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetEmcVolumeNumber());
20270 return(1 || funcname || hash || result7 || libp) ;
20271}
20272
20273static int G__RootEventData_rootcint_483_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20274{
20275 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta());
20276 return(1 || funcname || hash || result7 || libp) ;
20277}
20278
20279static int G__RootEventData_rootcint_483_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20280{
20281 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi());
20282 return(1 || funcname || hash || result7 || libp) ;
20283}
20284
20285static int G__RootEventData_rootcint_483_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20286{
20287 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20288 return(1 || funcname || hash || result7 || libp) ;
20289}
20290
20291static int G__RootEventData_rootcint_483_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20292{
20293 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->emcPath());
20294 return(1 || funcname || hash || result7 || libp) ;
20295}
20296
20297static int G__RootEventData_rootcint_483_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20298{
20299 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionX());
20300 return(1 || funcname || hash || result7 || libp) ;
20301}
20302
20303static int G__RootEventData_rootcint_483_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20304{
20305 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionY());
20306 return(1 || funcname || hash || result7 || libp) ;
20307}
20308
20309static int G__RootEventData_rootcint_483_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20310{
20311 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionZ());
20312 return(1 || funcname || hash || result7 || libp) ;
20313}
20314
20315static int G__RootEventData_rootcint_483_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20316{
20317 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumX());
20318 return(1 || funcname || hash || result7 || libp) ;
20319}
20320
20321static int G__RootEventData_rootcint_483_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20322{
20323 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumY());
20324 return(1 || funcname || hash || result7 || libp) ;
20325}
20326
20327static int G__RootEventData_rootcint_483_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20328{
20329 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumZ());
20330 return(1 || funcname || hash || result7 || libp) ;
20331}
20332
20333static int G__RootEventData_rootcint_483_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20334{
20335 {
20336 const TString* pobj;
20337 const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetMucVolumeName();
20338 pobj = new TString(xobj);
20339 result7->obj.i = (long) ((void*) pobj);
20340 result7->ref = result7->obj.i;
20341 G__store_tempobject(*result7);
20342 }
20343 return(1 || funcname || hash || result7 || libp) ;
20344}
20345
20346static int G__RootEventData_rootcint_483_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20347{
20348 G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetMucVolumeNumber());
20349 return(1 || funcname || hash || result7 || libp) ;
20350}
20351
20352static int G__RootEventData_rootcint_483_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20353{
20354 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ());
20355 return(1 || funcname || hash || result7 || libp) ;
20356}
20357
20358static int G__RootEventData_rootcint_483_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20359{
20360 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT());
20361 return(1 || funcname || hash || result7 || libp) ;
20362}
20363
20364static int G__RootEventData_rootcint_483_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20365{
20366 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX());
20367 return(1 || funcname || hash || result7 || libp) ;
20368}
20369
20370static int G__RootEventData_rootcint_483_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20371{
20372 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY());
20373 return(1 || funcname || hash || result7 || libp) ;
20374}
20375
20376static int G__RootEventData_rootcint_483_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20377{
20378 G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20379 return(1 || funcname || hash || result7 || libp) ;
20380}
20381
20382static int G__RootEventData_rootcint_483_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20383{
20384 G__letint(result7, 85, (long) TExtTrack::Class());
20385 return(1 || funcname || hash || result7 || libp) ;
20386}
20387
20388static int G__RootEventData_rootcint_483_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20389{
20390 G__letint(result7, 67, (long) TExtTrack::Class_Name());
20391 return(1 || funcname || hash || result7 || libp) ;
20392}
20393
20394static int G__RootEventData_rootcint_483_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20395{
20396 G__letint(result7, 115, (long) TExtTrack::Class_Version());
20397 return(1 || funcname || hash || result7 || libp) ;
20398}
20399
20400static int G__RootEventData_rootcint_483_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20401{
20402 TExtTrack::Dictionary();
20403 G__setnull(result7);
20404 return(1 || funcname || hash || result7 || libp) ;
20405}
20406
20407static int G__RootEventData_rootcint_483_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20408{
20409 ((TExtTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
20410 G__setnull(result7);
20411 return(1 || funcname || hash || result7 || libp) ;
20412}
20413
20414static int G__RootEventData_rootcint_483_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20415{
20416 G__letint(result7, 67, (long) TExtTrack::DeclFileName());
20417 return(1 || funcname || hash || result7 || libp) ;
20418}
20419
20420static int G__RootEventData_rootcint_483_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20421{
20422 G__letint(result7, 105, (long) TExtTrack::ImplFileLine());
20423 return(1 || funcname || hash || result7 || libp) ;
20424}
20425
20426static int G__RootEventData_rootcint_483_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20427{
20428 G__letint(result7, 67, (long) TExtTrack::ImplFileName());
20429 return(1 || funcname || hash || result7 || libp) ;
20430}
20431
20432static int G__RootEventData_rootcint_483_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20433{
20434 G__letint(result7, 105, (long) TExtTrack::DeclFileLine());
20435 return(1 || funcname || hash || result7 || libp) ;
20436}
20437
20438// automatic copy constructor
20439static int G__RootEventData_rootcint_483_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20440
20441{
20442 TExtTrack* p;
20443 void* tmp = (void*) G__int(libp->para[0]);
20444 p = new TExtTrack(*(TExtTrack*) tmp);
20445 result7->obj.i = (long) p;
20446 result7->ref = (long) p;
20447 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
20448 return(1 || funcname || hash || result7 || libp) ;
20449}
20450
20451// automatic destructor
20452typedef TExtTrack G__TTExtTrack;
20453static int G__RootEventData_rootcint_483_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20454{
20455 char* gvp = (char*) G__getgvp();
20456 long soff = G__getstructoffset();
20457 int n = G__getaryconstruct();
20458 //
20459 //has_a_delete: 1
20460 //has_own_delete1arg: 0
20461 //has_own_delete2arg: 0
20462 //
20463 if (!soff) {
20464 return(1);
20465 }
20466 if (n) {
20467 if (gvp == (char*)G__PVOID) {
20468 delete[] (TExtTrack*) soff;
20469 } else {
20470 G__setgvp((long) G__PVOID);
20471 for (int i = n - 1; i >= 0; --i) {
20472 ((TExtTrack*) (soff+(sizeof(TExtTrack)*i)))->~G__TTExtTrack();
20473 }
20474 G__setgvp((long)gvp);
20475 }
20476 } else {
20477 if (gvp == (char*)G__PVOID) {
20478 delete (TExtTrack*) soff;
20479 } else {
20480 G__setgvp((long) G__PVOID);
20481 ((TExtTrack*) (soff))->~G__TTExtTrack();
20482 G__setgvp((long)gvp);
20483 }
20484 }
20485 G__setnull(result7);
20486 return(1 || funcname || hash || result7 || libp) ;
20487}
20488
20489// automatic assignment operator
20490static int G__RootEventData_rootcint_483_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20491{
20492 TExtTrack* dest = (TExtTrack*) G__getstructoffset();
20493 *dest = *(TExtTrack*) libp->para[0].ref;
20494 const TExtTrack& obj = *dest;
20495 result7->ref = (long) (&obj);
20496 result7->obj.i = (long) (&obj);
20497 return(1 || funcname || hash || result7 || libp) ;
20498}
20499
20500
20501/* TMdcKalTrack */
20502static int G__RootEventData_rootcint_484_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20503{
20504 TMdcKalTrack* p = NULL;
20505 char* gvp = (char*) G__getgvp();
20506 int n = G__getaryconstruct();
20507 if (n) {
20508 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
20509 p = new TMdcKalTrack[n];
20510 } else {
20511 p = new((void*) gvp) TMdcKalTrack[n];
20512 }
20513 } else {
20514 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
20515 p = new TMdcKalTrack;
20516 } else {
20517 p = new((void*) gvp) TMdcKalTrack;
20518 }
20519 }
20520 result7->obj.i = (long) p;
20521 result7->ref = (long) p;
20522 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
20523 return(1 || funcname || hash || result7 || libp) ;
20524}
20525
20526static int G__RootEventData_rootcint_484_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20527{
20528 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getTrackId());
20529 return(1 || funcname || hash || result7 || libp) ;
20530}
20531
20532static int G__RootEventData_rootcint_484_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20533{
20534 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getStat((const Int_t) G__int(libp->para[0])));
20535 return(1 || funcname || hash || result7 || libp) ;
20536}
20537
20538static int G__RootEventData_rootcint_484_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20539{
20540 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getStat2((const Int_t) G__int(libp->para[0])));
20541 return(1 || funcname || hash || result7 || libp) ;
20542}
20543
20544static int G__RootEventData_rootcint_484_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20545{
20546 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getChisq((const Int_t) G__int(libp->para[0])));
20547 return(1 || funcname || hash || result7 || libp) ;
20548}
20549
20550static int G__RootEventData_rootcint_484_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20551{
20552 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getNdf((const Int_t) G__int(libp->para[0])));
20553 return(1 || funcname || hash || result7 || libp) ;
20554}
20555
20556static int G__RootEventData_rootcint_484_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20557{
20558 G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getNlayer((const Int_t) G__int(libp->para[0])));
20559 return(1 || funcname || hash || result7 || libp) ;
20560}
20561
20562static int G__RootEventData_rootcint_484_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20563{
20564 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelix((Int_t) G__int(libp->para[0])));
20565 return(1 || funcname || hash || result7 || libp) ;
20566}
20567
20568static int G__RootEventData_rootcint_484_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20569{
20570 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20571 return(1 || funcname || hash || result7 || libp) ;
20572}
20573
20574static int G__RootEventData_rootcint_484_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20575{
20576 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixE((Int_t) G__int(libp->para[0])));
20577 return(1 || funcname || hash || result7 || libp) ;
20578}
20579
20580static int G__RootEventData_rootcint_484_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20581{
20582 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20583 return(1 || funcname || hash || result7 || libp) ;
20584}
20585
20586static int G__RootEventData_rootcint_484_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20587{
20588 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixMu((Int_t) G__int(libp->para[0])));
20589 return(1 || funcname || hash || result7 || libp) ;
20590}
20591
20592static int G__RootEventData_rootcint_484_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20593{
20594 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20595 return(1 || funcname || hash || result7 || libp) ;
20596}
20597
20598static int G__RootEventData_rootcint_484_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20599{
20600 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixK((Int_t) G__int(libp->para[0])));
20601 return(1 || funcname || hash || result7 || libp) ;
20602}
20603
20604static int G__RootEventData_rootcint_484_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20605{
20606 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20607 return(1 || funcname || hash || result7 || libp) ;
20608}
20609
20610static int G__RootEventData_rootcint_484_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20611{
20612 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixP((Int_t) G__int(libp->para[0])));
20613 return(1 || funcname || hash || result7 || libp) ;
20614}
20615
20616static int G__RootEventData_rootcint_484_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20617{
20618 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20619 return(1 || funcname || hash || result7 || libp) ;
20620}
20621
20622static int G__RootEventData_rootcint_484_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20623{
20624 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelix((Int_t) G__int(libp->para[0])));
20625 return(1 || funcname || hash || result7 || libp) ;
20626}
20627
20628static int G__RootEventData_rootcint_484_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20629{
20630 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20631 return(1 || funcname || hash || result7 || libp) ;
20632}
20633
20634static int G__RootEventData_rootcint_484_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20635{
20636 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixE((Int_t) G__int(libp->para[0])));
20637 return(1 || funcname || hash || result7 || libp) ;
20638}
20639
20640static int G__RootEventData_rootcint_484_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20641{
20642 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20643 return(1 || funcname || hash || result7 || libp) ;
20644}
20645
20646static int G__RootEventData_rootcint_484_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20647{
20648 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixMu((Int_t) G__int(libp->para[0])));
20649 return(1 || funcname || hash || result7 || libp) ;
20650}
20651
20652static int G__RootEventData_rootcint_484_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20653{
20654 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20655 return(1 || funcname || hash || result7 || libp) ;
20656}
20657
20658static int G__RootEventData_rootcint_484_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20659{
20660 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixK((Int_t) G__int(libp->para[0])));
20661 return(1 || funcname || hash || result7 || libp) ;
20662}
20663
20664static int G__RootEventData_rootcint_484_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20665{
20666 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20667 return(1 || funcname || hash || result7 || libp) ;
20668}
20669
20670static int G__RootEventData_rootcint_484_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20671{
20672 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixP((Int_t) G__int(libp->para[0])));
20673 return(1 || funcname || hash || result7 || libp) ;
20674}
20675
20676static int G__RootEventData_rootcint_484_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20677{
20678 G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
20679 return(1 || funcname || hash || result7 || libp) ;
20680}
20681
20682static int G__RootEventData_rootcint_484_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20683{
20684 ((TMdcKalTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
20685 G__setnull(result7);
20686 return(1 || funcname || hash || result7 || libp) ;
20687}
20688
20689static int G__RootEventData_rootcint_484_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20690{
20691 ((TMdcKalTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20692 G__setnull(result7);
20693 return(1 || funcname || hash || result7 || libp) ;
20694}
20695
20696static int G__RootEventData_rootcint_484_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20697{
20698 ((TMdcKalTrack*) G__getstructoffset())->setStat2((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20699 G__setnull(result7);
20700 return(1 || funcname || hash || result7 || libp) ;
20701}
20702
20703static int G__RootEventData_rootcint_484_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20704{
20705 ((TMdcKalTrack*) G__getstructoffset())->setChisq((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20706 G__setnull(result7);
20707 return(1 || funcname || hash || result7 || libp) ;
20708}
20709
20710static int G__RootEventData_rootcint_484_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20711{
20712 ((TMdcKalTrack*) G__getstructoffset())->setNdf((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20713 G__setnull(result7);
20714 return(1 || funcname || hash || result7 || libp) ;
20715}
20716
20717static int G__RootEventData_rootcint_484_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20718{
20719 ((TMdcKalTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
20720 G__setnull(result7);
20721 return(1 || funcname || hash || result7 || libp) ;
20722}
20723
20724static int G__RootEventData_rootcint_484_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20725{
20726 ((TMdcKalTrack*) G__getstructoffset())->setZHelix((Double_t*) G__int(libp->para[0]));
20727 G__setnull(result7);
20728 return(1 || funcname || hash || result7 || libp) ;
20729}
20730
20731static int G__RootEventData_rootcint_484_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20732{
20733 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20734 ((TMdcKalTrack*) G__getstructoffset())->setZError(G__Ap0->a);
20735 G__setnull(result7);
20736 return(1 || funcname || hash || result7 || libp) ;
20737}
20738
20739static int G__RootEventData_rootcint_484_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20740{
20741 ((TMdcKalTrack*) G__getstructoffset())->setZHelixE((Double_t*) G__int(libp->para[0]));
20742 G__setnull(result7);
20743 return(1 || funcname || hash || result7 || libp) ;
20744}
20745
20746static int G__RootEventData_rootcint_484_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20747{
20748 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20749 ((TMdcKalTrack*) G__getstructoffset())->setZErrorE(G__Ap0->a);
20750 G__setnull(result7);
20751 return(1 || funcname || hash || result7 || libp) ;
20752}
20753
20754static int G__RootEventData_rootcint_484_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20755{
20756 ((TMdcKalTrack*) G__getstructoffset())->setZHelixMu((Double_t*) G__int(libp->para[0]));
20757 G__setnull(result7);
20758 return(1 || funcname || hash || result7 || libp) ;
20759}
20760
20761static int G__RootEventData_rootcint_484_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20762{
20763 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20764 ((TMdcKalTrack*) G__getstructoffset())->setZErrorMu(G__Ap0->a);
20765 G__setnull(result7);
20766 return(1 || funcname || hash || result7 || libp) ;
20767}
20768
20769static int G__RootEventData_rootcint_484_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20770{
20771 ((TMdcKalTrack*) G__getstructoffset())->setZHelixK((Double_t*) G__int(libp->para[0]));
20772 G__setnull(result7);
20773 return(1 || funcname || hash || result7 || libp) ;
20774}
20775
20776static int G__RootEventData_rootcint_484_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20777{
20778 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20779 ((TMdcKalTrack*) G__getstructoffset())->setZErrorK(G__Ap0->a);
20780 G__setnull(result7);
20781 return(1 || funcname || hash || result7 || libp) ;
20782}
20783
20784static int G__RootEventData_rootcint_484_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20785{
20786 ((TMdcKalTrack*) G__getstructoffset())->setZHelixP((Double_t*) G__int(libp->para[0]));
20787 G__setnull(result7);
20788 return(1 || funcname || hash || result7 || libp) ;
20789}
20790
20791static int G__RootEventData_rootcint_484_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20792{
20793 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20794 ((TMdcKalTrack*) G__getstructoffset())->setZErrorP(G__Ap0->a);
20795 G__setnull(result7);
20796 return(1 || funcname || hash || result7 || libp) ;
20797}
20798
20799static int G__RootEventData_rootcint_484_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20800{
20801 ((TMdcKalTrack*) G__getstructoffset())->setFHelix((Double_t*) G__int(libp->para[0]));
20802 G__setnull(result7);
20803 return(1 || funcname || hash || result7 || libp) ;
20804}
20805
20806static int G__RootEventData_rootcint_484_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20807{
20808 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20809 ((TMdcKalTrack*) G__getstructoffset())->setFError(G__Ap0->a);
20810 G__setnull(result7);
20811 return(1 || funcname || hash || result7 || libp) ;
20812}
20813
20814static int G__RootEventData_rootcint_484_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20815{
20816 ((TMdcKalTrack*) G__getstructoffset())->setFHelixE((Double_t*) G__int(libp->para[0]));
20817 G__setnull(result7);
20818 return(1 || funcname || hash || result7 || libp) ;
20819}
20820
20821static int G__RootEventData_rootcint_484_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20822{
20823 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20824 ((TMdcKalTrack*) G__getstructoffset())->setFErrorE(G__Ap0->a);
20825 G__setnull(result7);
20826 return(1 || funcname || hash || result7 || libp) ;
20827}
20828
20829static int G__RootEventData_rootcint_484_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20830{
20831 ((TMdcKalTrack*) G__getstructoffset())->setFHelixMu((Double_t*) G__int(libp->para[0]));
20832 G__setnull(result7);
20833 return(1 || funcname || hash || result7 || libp) ;
20834}
20835
20836static int G__RootEventData_rootcint_484_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20837{
20838 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20839 ((TMdcKalTrack*) G__getstructoffset())->setFErrorMu(G__Ap0->a);
20840 G__setnull(result7);
20841 return(1 || funcname || hash || result7 || libp) ;
20842}
20843
20844static int G__RootEventData_rootcint_484_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20845{
20846 ((TMdcKalTrack*) G__getstructoffset())->setFHelixK((Double_t*) G__int(libp->para[0]));
20847 G__setnull(result7);
20848 return(1 || funcname || hash || result7 || libp) ;
20849}
20850
20851static int G__RootEventData_rootcint_484_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20852{
20853 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20854 ((TMdcKalTrack*) G__getstructoffset())->setFErrorK(G__Ap0->a);
20855 G__setnull(result7);
20856 return(1 || funcname || hash || result7 || libp) ;
20857}
20858
20859static int G__RootEventData_rootcint_484_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20860{
20861 ((TMdcKalTrack*) G__getstructoffset())->setFHelixP((Double_t*) G__int(libp->para[0]));
20862 G__setnull(result7);
20863 return(1 || funcname || hash || result7 || libp) ;
20864}
20865
20866static int G__RootEventData_rootcint_484_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20867{
20868 struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
20869 ((TMdcKalTrack*) G__getstructoffset())->setFErrorP(G__Ap0->a);
20870 G__setnull(result7);
20871 return(1 || funcname || hash || result7 || libp) ;
20872}
20873
20874static int G__RootEventData_rootcint_484_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20875{
20876 G__letint(result7, 85, (long) TMdcKalTrack::Class());
20877 return(1 || funcname || hash || result7 || libp) ;
20878}
20879
20880static int G__RootEventData_rootcint_484_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20881{
20882 G__letint(result7, 67, (long) TMdcKalTrack::Class_Name());
20883 return(1 || funcname || hash || result7 || libp) ;
20884}
20885
20886static int G__RootEventData_rootcint_484_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20887{
20888 G__letint(result7, 115, (long) TMdcKalTrack::Class_Version());
20889 return(1 || funcname || hash || result7 || libp) ;
20890}
20891
20892static int G__RootEventData_rootcint_484_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20893{
20894 TMdcKalTrack::Dictionary();
20895 G__setnull(result7);
20896 return(1 || funcname || hash || result7 || libp) ;
20897}
20898
20899static int G__RootEventData_rootcint_484_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20900{
20901 ((TMdcKalTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
20902 G__setnull(result7);
20903 return(1 || funcname || hash || result7 || libp) ;
20904}
20905
20906static int G__RootEventData_rootcint_484_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20907{
20908 G__letint(result7, 67, (long) TMdcKalTrack::DeclFileName());
20909 return(1 || funcname || hash || result7 || libp) ;
20910}
20911
20912static int G__RootEventData_rootcint_484_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20913{
20914 G__letint(result7, 105, (long) TMdcKalTrack::ImplFileLine());
20915 return(1 || funcname || hash || result7 || libp) ;
20916}
20917
20918static int G__RootEventData_rootcint_484_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20919{
20920 G__letint(result7, 67, (long) TMdcKalTrack::ImplFileName());
20921 return(1 || funcname || hash || result7 || libp) ;
20922}
20923
20924static int G__RootEventData_rootcint_484_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20925{
20926 G__letint(result7, 105, (long) TMdcKalTrack::DeclFileLine());
20927 return(1 || funcname || hash || result7 || libp) ;
20928}
20929
20930// automatic copy constructor
20931static int G__RootEventData_rootcint_484_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20932
20933{
20934 TMdcKalTrack* p;
20935 void* tmp = (void*) G__int(libp->para[0]);
20936 p = new TMdcKalTrack(*(TMdcKalTrack*) tmp);
20937 result7->obj.i = (long) p;
20938 result7->ref = (long) p;
20939 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
20940 return(1 || funcname || hash || result7 || libp) ;
20941}
20942
20943// automatic destructor
20944typedef TMdcKalTrack G__TTMdcKalTrack;
20945static int G__RootEventData_rootcint_484_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20946{
20947 char* gvp = (char*) G__getgvp();
20948 long soff = G__getstructoffset();
20949 int n = G__getaryconstruct();
20950 //
20951 //has_a_delete: 1
20952 //has_own_delete1arg: 0
20953 //has_own_delete2arg: 0
20954 //
20955 if (!soff) {
20956 return(1);
20957 }
20958 if (n) {
20959 if (gvp == (char*)G__PVOID) {
20960 delete[] (TMdcKalTrack*) soff;
20961 } else {
20962 G__setgvp((long) G__PVOID);
20963 for (int i = n - 1; i >= 0; --i) {
20964 ((TMdcKalTrack*) (soff+(sizeof(TMdcKalTrack)*i)))->~G__TTMdcKalTrack();
20965 }
20966 G__setgvp((long)gvp);
20967 }
20968 } else {
20969 if (gvp == (char*)G__PVOID) {
20970 delete (TMdcKalTrack*) soff;
20971 } else {
20972 G__setgvp((long) G__PVOID);
20973 ((TMdcKalTrack*) (soff))->~G__TTMdcKalTrack();
20974 G__setgvp((long)gvp);
20975 }
20976 }
20977 G__setnull(result7);
20978 return(1 || funcname || hash || result7 || libp) ;
20979}
20980
20981// automatic assignment operator
20982static int G__RootEventData_rootcint_484_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20983{
20984 TMdcKalTrack* dest = (TMdcKalTrack*) G__getstructoffset();
20985 *dest = *(TMdcKalTrack*) libp->para[0].ref;
20986 const TMdcKalTrack& obj = *dest;
20987 result7->ref = (long) (&obj);
20988 result7->obj.i = (long) (&obj);
20989 return(1 || funcname || hash || result7 || libp) ;
20990}
20991
20992
20993/* TDstEvent */
20994static int G__RootEventData_rootcint_485_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
20995{
20996 TDstEvent* p = NULL;
20997 char* gvp = (char*) G__getgvp();
20998 int n = G__getaryconstruct();
20999 if (n) {
21000 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21001 p = new TDstEvent[n];
21002 } else {
21003 p = new((void*) gvp) TDstEvent[n];
21004 }
21005 } else {
21006 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21007 p = new TDstEvent;
21008 } else {
21009 p = new((void*) gvp) TDstEvent;
21010 }
21011 }
21012 result7->obj.i = (long) p;
21013 result7->ref = (long) p;
21014 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
21015 return(1 || funcname || hash || result7 || libp) ;
21016}
21017
21018static int G__RootEventData_rootcint_485_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21019{
21020 ((TDstEvent*) G__getstructoffset())->initialize();
21021 G__setnull(result7);
21022 return(1 || funcname || hash || result7 || libp) ;
21023}
21024
21025static int G__RootEventData_rootcint_485_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21026{
21027 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcTrackCol());
21028 return(1 || funcname || hash || result7 || libp) ;
21029}
21030
21031static int G__RootEventData_rootcint_485_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21032{
21033 ((TDstEvent*) G__getstructoffset())->addMdcTrack((TMdcTrack*) G__int(libp->para[0]));
21034 G__setnull(result7);
21035 return(1 || funcname || hash || result7 || libp) ;
21036}
21037
21038static int G__RootEventData_rootcint_485_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21039{
21040 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcTrack((Int_t) G__int(libp->para[0])));
21041 return(1 || funcname || hash || result7 || libp) ;
21042}
21043
21044static int G__RootEventData_rootcint_485_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21045{
21046 ((TDstEvent*) G__getstructoffset())->clearMdcTrackCol();
21047 G__setnull(result7);
21048 return(1 || funcname || hash || result7 || libp) ;
21049}
21050
21051static int G__RootEventData_rootcint_485_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21052{
21053 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getEmcTrackCol());
21054 return(1 || funcname || hash || result7 || libp) ;
21055}
21056
21057static int G__RootEventData_rootcint_485_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21058{
21059 ((TDstEvent*) G__getstructoffset())->addEmcTrack((TEmcTrack*) G__int(libp->para[0]));
21060 G__setnull(result7);
21061 return(1 || funcname || hash || result7 || libp) ;
21062}
21063
21064static int G__RootEventData_rootcint_485_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21065{
21066 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getEmcTrack((Int_t) G__int(libp->para[0])));
21067 return(1 || funcname || hash || result7 || libp) ;
21068}
21069
21070static int G__RootEventData_rootcint_485_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21071{
21072 ((TDstEvent*) G__getstructoffset())->clearEmcTrackCol();
21073 G__setnull(result7);
21074 return(1 || funcname || hash || result7 || libp) ;
21075}
21076
21077static int G__RootEventData_rootcint_485_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21078{
21079 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getTofTrackCol());
21080 return(1 || funcname || hash || result7 || libp) ;
21081}
21082
21083static int G__RootEventData_rootcint_485_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21084{
21085 ((TDstEvent*) G__getstructoffset())->addTofTrack((TTofTrack*) G__int(libp->para[0]));
21086 G__setnull(result7);
21087 return(1 || funcname || hash || result7 || libp) ;
21088}
21089
21090static int G__RootEventData_rootcint_485_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21091{
21092 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
21093 return(1 || funcname || hash || result7 || libp) ;
21094}
21095
21096static int G__RootEventData_rootcint_485_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21097{
21098 ((TDstEvent*) G__getstructoffset())->clearTofTrackCol();
21099 G__setnull(result7);
21100 return(1 || funcname || hash || result7 || libp) ;
21101}
21102
21103static int G__RootEventData_rootcint_485_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21104{
21105 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMucTrackCol());
21106 return(1 || funcname || hash || result7 || libp) ;
21107}
21108
21109static int G__RootEventData_rootcint_485_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21110{
21111 ((TDstEvent*) G__getstructoffset())->addMucTrack((TMucTrack*) G__int(libp->para[0]));
21112 G__setnull(result7);
21113 return(1 || funcname || hash || result7 || libp) ;
21114}
21115
21116static int G__RootEventData_rootcint_485_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21117{
21118 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
21119 return(1 || funcname || hash || result7 || libp) ;
21120}
21121
21122static int G__RootEventData_rootcint_485_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21123{
21124 ((TDstEvent*) G__getstructoffset())->clearMucTrackCol();
21125 G__setnull(result7);
21126 return(1 || funcname || hash || result7 || libp) ;
21127}
21128
21129static int G__RootEventData_rootcint_485_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21130{
21131 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcDedxCol());
21132 return(1 || funcname || hash || result7 || libp) ;
21133}
21134
21135static int G__RootEventData_rootcint_485_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21136{
21137 ((TDstEvent*) G__getstructoffset())->addMdcDedx((TMdcDedx*) G__int(libp->para[0]));
21138 G__setnull(result7);
21139 return(1 || funcname || hash || result7 || libp) ;
21140}
21141
21142static int G__RootEventData_rootcint_485_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21143{
21144 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcDedx((Int_t) G__int(libp->para[0])));
21145 return(1 || funcname || hash || result7 || libp) ;
21146}
21147
21148static int G__RootEventData_rootcint_485_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21149{
21150 ((TDstEvent*) G__getstructoffset())->clearMdcDedxCol();
21151 G__setnull(result7);
21152 return(1 || funcname || hash || result7 || libp) ;
21153}
21154
21155static int G__RootEventData_rootcint_485_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21156{
21157 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getExtTrackCol());
21158 return(1 || funcname || hash || result7 || libp) ;
21159}
21160
21161static int G__RootEventData_rootcint_485_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21162{
21163 ((TDstEvent*) G__getstructoffset())->addExtTrack((TExtTrack*) G__int(libp->para[0]));
21164 G__setnull(result7);
21165 return(1 || funcname || hash || result7 || libp) ;
21166}
21167
21168static int G__RootEventData_rootcint_485_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21169{
21170 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getExtTrack((Int_t) G__int(libp->para[0])));
21171 return(1 || funcname || hash || result7 || libp) ;
21172}
21173
21174static int G__RootEventData_rootcint_485_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21175{
21176 ((TDstEvent*) G__getstructoffset())->clearExtTrackCol();
21177 G__setnull(result7);
21178 return(1 || funcname || hash || result7 || libp) ;
21179}
21180
21181static int G__RootEventData_rootcint_485_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21182{
21183 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcKalTrackCol());
21184 return(1 || funcname || hash || result7 || libp) ;
21185}
21186
21187static int G__RootEventData_rootcint_485_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21188{
21189 ((TDstEvent*) G__getstructoffset())->addMdcKalTrack((TMdcKalTrack*) G__int(libp->para[0]));
21190 G__setnull(result7);
21191 return(1 || funcname || hash || result7 || libp) ;
21192}
21193
21194static int G__RootEventData_rootcint_485_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21195{
21196 G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcKalTrack((Int_t) G__int(libp->para[0])));
21197 return(1 || funcname || hash || result7 || libp) ;
21198}
21199
21200static int G__RootEventData_rootcint_485_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21201{
21202 ((TDstEvent*) G__getstructoffset())->clearMdcKalTrackCol();
21203 G__setnull(result7);
21204 return(1 || funcname || hash || result7 || libp) ;
21205}
21206
21207static int G__RootEventData_rootcint_485_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21208{
21209 G__letint(result7, 85, (long) TDstEvent::Class());
21210 return(1 || funcname || hash || result7 || libp) ;
21211}
21212
21213static int G__RootEventData_rootcint_485_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21214{
21215 G__letint(result7, 67, (long) TDstEvent::Class_Name());
21216 return(1 || funcname || hash || result7 || libp) ;
21217}
21218
21219static int G__RootEventData_rootcint_485_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21220{
21221 G__letint(result7, 115, (long) TDstEvent::Class_Version());
21222 return(1 || funcname || hash || result7 || libp) ;
21223}
21224
21225static int G__RootEventData_rootcint_485_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21226{
21227 TDstEvent::Dictionary();
21228 G__setnull(result7);
21229 return(1 || funcname || hash || result7 || libp) ;
21230}
21231
21232static int G__RootEventData_rootcint_485_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21233{
21234 ((TDstEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
21235 G__setnull(result7);
21236 return(1 || funcname || hash || result7 || libp) ;
21237}
21238
21239static int G__RootEventData_rootcint_485_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21240{
21241 G__letint(result7, 67, (long) TDstEvent::DeclFileName());
21242 return(1 || funcname || hash || result7 || libp) ;
21243}
21244
21245static int G__RootEventData_rootcint_485_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21246{
21247 G__letint(result7, 105, (long) TDstEvent::ImplFileLine());
21248 return(1 || funcname || hash || result7 || libp) ;
21249}
21250
21251static int G__RootEventData_rootcint_485_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21252{
21253 G__letint(result7, 67, (long) TDstEvent::ImplFileName());
21254 return(1 || funcname || hash || result7 || libp) ;
21255}
21256
21257static int G__RootEventData_rootcint_485_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21258{
21259 G__letint(result7, 105, (long) TDstEvent::DeclFileLine());
21260 return(1 || funcname || hash || result7 || libp) ;
21261}
21262
21263// automatic copy constructor
21264static int G__RootEventData_rootcint_485_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21265
21266{
21267 TDstEvent* p;
21268 void* tmp = (void*) G__int(libp->para[0]);
21269 p = new TDstEvent(*(TDstEvent*) tmp);
21270 result7->obj.i = (long) p;
21271 result7->ref = (long) p;
21272 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
21273 return(1 || funcname || hash || result7 || libp) ;
21274}
21275
21276// automatic destructor
21277typedef TDstEvent G__TTDstEvent;
21278static int G__RootEventData_rootcint_485_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21279{
21280 char* gvp = (char*) G__getgvp();
21281 long soff = G__getstructoffset();
21282 int n = G__getaryconstruct();
21283 //
21284 //has_a_delete: 1
21285 //has_own_delete1arg: 0
21286 //has_own_delete2arg: 0
21287 //
21288 if (!soff) {
21289 return(1);
21290 }
21291 if (n) {
21292 if (gvp == (char*)G__PVOID) {
21293 delete[] (TDstEvent*) soff;
21294 } else {
21295 G__setgvp((long) G__PVOID);
21296 for (int i = n - 1; i >= 0; --i) {
21297 ((TDstEvent*) (soff+(sizeof(TDstEvent)*i)))->~G__TTDstEvent();
21298 }
21299 G__setgvp((long)gvp);
21300 }
21301 } else {
21302 if (gvp == (char*)G__PVOID) {
21303 delete (TDstEvent*) soff;
21304 } else {
21305 G__setgvp((long) G__PVOID);
21306 ((TDstEvent*) (soff))->~G__TTDstEvent();
21307 G__setgvp((long)gvp);
21308 }
21309 }
21310 G__setnull(result7);
21311 return(1 || funcname || hash || result7 || libp) ;
21312}
21313
21314// automatic assignment operator
21315static int G__RootEventData_rootcint_485_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21316{
21317 TDstEvent* dest = (TDstEvent*) G__getstructoffset();
21318 *dest = *(TDstEvent*) libp->para[0].ref;
21319 const TDstEvent& obj = *dest;
21320 result7->ref = (long) (&obj);
21321 result7->obj.i = (long) (&obj);
21322 return(1 || funcname || hash || result7 || libp) ;
21323}
21324
21325
21326/* TMdcMc */
21327static int G__RootEventData_rootcint_486_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21328{
21329 TMdcMc* p = NULL;
21330 char* gvp = (char*) G__getgvp();
21331 int n = G__getaryconstruct();
21332 if (n) {
21333 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21334 p = new TMdcMc[n];
21335 } else {
21336 p = new((void*) gvp) TMdcMc[n];
21337 }
21338 } else {
21339 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21340 p = new TMdcMc;
21341 } else {
21342 p = new((void*) gvp) TMdcMc;
21343 }
21344 }
21345 result7->obj.i = (long) p;
21346 result7->ref = (long) p;
21347 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
21348 return(1 || funcname || hash || result7 || libp) ;
21349}
21350
21351static int G__RootEventData_rootcint_486_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21352{
21353 G__letint(result7, 104, (long) ((const TMdcMc*) G__getstructoffset())->getId());
21354 return(1 || funcname || hash || result7 || libp) ;
21355}
21356
21357static int G__RootEventData_rootcint_486_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21358{
21359 G__letint(result7, 104, (long) ((const TMdcMc*) G__getstructoffset())->getTrackIndex());
21360 return(1 || funcname || hash || result7 || libp) ;
21361}
21362
21363static int G__RootEventData_rootcint_486_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21364{
21365 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionX());
21366 return(1 || funcname || hash || result7 || libp) ;
21367}
21368
21369static int G__RootEventData_rootcint_486_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21370{
21371 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionY());
21372 return(1 || funcname || hash || result7 || libp) ;
21373}
21374
21375static int G__RootEventData_rootcint_486_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21376{
21377 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionZ());
21378 return(1 || funcname || hash || result7 || libp) ;
21379}
21380
21381static int G__RootEventData_rootcint_486_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21382{
21383 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getDriftDistance());
21384 return(1 || funcname || hash || result7 || libp) ;
21385}
21386
21387static int G__RootEventData_rootcint_486_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21388{
21389 G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getDepositEnergy());
21390 return(1 || funcname || hash || result7 || libp) ;
21391}
21392
21393static int G__RootEventData_rootcint_486_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21394{
21395 G__letint(result7, 105, (long) ((const TMdcMc*) G__getstructoffset())->getPositionFlag());
21396 return(1 || funcname || hash || result7 || libp) ;
21397}
21398
21399static int G__RootEventData_rootcint_486_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21400{
21401 ((TMdcMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
21402 G__setnull(result7);
21403 return(1 || funcname || hash || result7 || libp) ;
21404}
21405
21406static int G__RootEventData_rootcint_486_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21407{
21408 ((TMdcMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
21409 G__setnull(result7);
21410 return(1 || funcname || hash || result7 || libp) ;
21411}
21412
21413static int G__RootEventData_rootcint_486_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21414{
21415 ((TMdcMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
21416 G__setnull(result7);
21417 return(1 || funcname || hash || result7 || libp) ;
21418}
21419
21420static int G__RootEventData_rootcint_486_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21421{
21422 ((TMdcMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
21423 G__setnull(result7);
21424 return(1 || funcname || hash || result7 || libp) ;
21425}
21426
21427static int G__RootEventData_rootcint_486_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21428{
21429 ((TMdcMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
21430 G__setnull(result7);
21431 return(1 || funcname || hash || result7 || libp) ;
21432}
21433
21434static int G__RootEventData_rootcint_486_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21435{
21436 ((TMdcMc*) G__getstructoffset())->setDriftDistance((Double_t) G__double(libp->para[0]));
21437 G__setnull(result7);
21438 return(1 || funcname || hash || result7 || libp) ;
21439}
21440
21441static int G__RootEventData_rootcint_486_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21442{
21443 ((TMdcMc*) G__getstructoffset())->setDepositEnergy((Double_t) G__double(libp->para[0]));
21444 G__setnull(result7);
21445 return(1 || funcname || hash || result7 || libp) ;
21446}
21447
21448static int G__RootEventData_rootcint_486_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21449{
21450 ((TMdcMc*) G__getstructoffset())->setPositionFlag((Int_t) G__int(libp->para[0]));
21451 G__setnull(result7);
21452 return(1 || funcname || hash || result7 || libp) ;
21453}
21454
21455static int G__RootEventData_rootcint_486_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21456{
21457 G__letint(result7, 85, (long) TMdcMc::Class());
21458 return(1 || funcname || hash || result7 || libp) ;
21459}
21460
21461static int G__RootEventData_rootcint_486_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21462{
21463 G__letint(result7, 67, (long) TMdcMc::Class_Name());
21464 return(1 || funcname || hash || result7 || libp) ;
21465}
21466
21467static int G__RootEventData_rootcint_486_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21468{
21469 G__letint(result7, 115, (long) TMdcMc::Class_Version());
21470 return(1 || funcname || hash || result7 || libp) ;
21471}
21472
21473static int G__RootEventData_rootcint_486_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21474{
21475 TMdcMc::Dictionary();
21476 G__setnull(result7);
21477 return(1 || funcname || hash || result7 || libp) ;
21478}
21479
21480static int G__RootEventData_rootcint_486_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21481{
21482 ((TMdcMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
21483 G__setnull(result7);
21484 return(1 || funcname || hash || result7 || libp) ;
21485}
21486
21487static int G__RootEventData_rootcint_486_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21488{
21489 G__letint(result7, 67, (long) TMdcMc::DeclFileName());
21490 return(1 || funcname || hash || result7 || libp) ;
21491}
21492
21493static int G__RootEventData_rootcint_486_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21494{
21495 G__letint(result7, 105, (long) TMdcMc::ImplFileLine());
21496 return(1 || funcname || hash || result7 || libp) ;
21497}
21498
21499static int G__RootEventData_rootcint_486_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21500{
21501 G__letint(result7, 67, (long) TMdcMc::ImplFileName());
21502 return(1 || funcname || hash || result7 || libp) ;
21503}
21504
21505static int G__RootEventData_rootcint_486_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21506{
21507 G__letint(result7, 105, (long) TMdcMc::DeclFileLine());
21508 return(1 || funcname || hash || result7 || libp) ;
21509}
21510
21511// automatic copy constructor
21512static int G__RootEventData_rootcint_486_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21513
21514{
21515 TMdcMc* p;
21516 void* tmp = (void*) G__int(libp->para[0]);
21517 p = new TMdcMc(*(TMdcMc*) tmp);
21518 result7->obj.i = (long) p;
21519 result7->ref = (long) p;
21520 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
21521 return(1 || funcname || hash || result7 || libp) ;
21522}
21523
21524// automatic destructor
21525typedef TMdcMc G__TTMdcMc;
21526static int G__RootEventData_rootcint_486_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21527{
21528 char* gvp = (char*) G__getgvp();
21529 long soff = G__getstructoffset();
21530 int n = G__getaryconstruct();
21531 //
21532 //has_a_delete: 1
21533 //has_own_delete1arg: 0
21534 //has_own_delete2arg: 0
21535 //
21536 if (!soff) {
21537 return(1);
21538 }
21539 if (n) {
21540 if (gvp == (char*)G__PVOID) {
21541 delete[] (TMdcMc*) soff;
21542 } else {
21543 G__setgvp((long) G__PVOID);
21544 for (int i = n - 1; i >= 0; --i) {
21545 ((TMdcMc*) (soff+(sizeof(TMdcMc)*i)))->~G__TTMdcMc();
21546 }
21547 G__setgvp((long)gvp);
21548 }
21549 } else {
21550 if (gvp == (char*)G__PVOID) {
21551 delete (TMdcMc*) soff;
21552 } else {
21553 G__setgvp((long) G__PVOID);
21554 ((TMdcMc*) (soff))->~G__TTMdcMc();
21555 G__setgvp((long)gvp);
21556 }
21557 }
21558 G__setnull(result7);
21559 return(1 || funcname || hash || result7 || libp) ;
21560}
21561
21562// automatic assignment operator
21563static int G__RootEventData_rootcint_486_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21564{
21565 TMdcMc* dest = (TMdcMc*) G__getstructoffset();
21566 *dest = *(TMdcMc*) libp->para[0].ref;
21567 const TMdcMc& obj = *dest;
21568 result7->ref = (long) (&obj);
21569 result7->obj.i = (long) (&obj);
21570 return(1 || funcname || hash || result7 || libp) ;
21571}
21572
21573
21574/* TEmcMc */
21575static int G__RootEventData_rootcint_487_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21576{
21577 TEmcMc* p = NULL;
21578 char* gvp = (char*) G__getgvp();
21579 int n = G__getaryconstruct();
21580 if (n) {
21581 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21582 p = new TEmcMc[n];
21583 } else {
21584 p = new((void*) gvp) TEmcMc[n];
21585 }
21586 } else {
21587 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21588 p = new TEmcMc;
21589 } else {
21590 p = new((void*) gvp) TEmcMc;
21591 }
21592 }
21593 result7->obj.i = (long) p;
21594 result7->ref = (long) p;
21595 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
21596 return(1 || funcname || hash || result7 || libp) ;
21597}
21598
21599static int G__RootEventData_rootcint_487_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21600{
21601 {
21602 const map<Int_t,Double_t>* pobj;
21603 const map<Int_t,Double_t> xobj = ((const TEmcMc*) G__getstructoffset())->getHitMap();
21604 pobj = new map<Int_t,Double_t>(xobj);
21605 result7->obj.i = (long) ((void*) pobj);
21606 result7->ref = result7->obj.i;
21607 G__store_tempobject(*result7);
21608 }
21609 return(1 || funcname || hash || result7 || libp) ;
21610}
21611
21612static int G__RootEventData_rootcint_487_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21613{
21614 G__letint(result7, 105, (long) ((const TEmcMc*) G__getstructoffset())->getHitEmc());
21615 return(1 || funcname || hash || result7 || libp) ;
21616}
21617
21618static int G__RootEventData_rootcint_487_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21619{
21620 G__letint(result7, 105, (long) ((const TEmcMc*) G__getstructoffset())->getPDGCode());
21621 return(1 || funcname || hash || result7 || libp) ;
21622}
21623
21624static int G__RootEventData_rootcint_487_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21625{
21626 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPDGCharge());
21627 return(1 || funcname || hash || result7 || libp) ;
21628}
21629
21630static int G__RootEventData_rootcint_487_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21631{
21632 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getTime());
21633 return(1 || funcname || hash || result7 || libp) ;
21634}
21635
21636static int G__RootEventData_rootcint_487_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21637{
21638 G__letint(result7, 104, (long) ((const TEmcMc*) G__getstructoffset())->getId());
21639 return(1 || funcname || hash || result7 || libp) ;
21640}
21641
21642static int G__RootEventData_rootcint_487_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21643{
21644 G__letint(result7, 104, (long) ((const TEmcMc*) G__getstructoffset())->getTrackIndex());
21645 return(1 || funcname || hash || result7 || libp) ;
21646}
21647
21648static int G__RootEventData_rootcint_487_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21649{
21650 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionX());
21651 return(1 || funcname || hash || result7 || libp) ;
21652}
21653
21654static int G__RootEventData_rootcint_487_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21655{
21656 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionY());
21657 return(1 || funcname || hash || result7 || libp) ;
21658}
21659
21660static int G__RootEventData_rootcint_487_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21661{
21662 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionZ());
21663 return(1 || funcname || hash || result7 || libp) ;
21664}
21665
21666static int G__RootEventData_rootcint_487_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21667{
21668 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPx());
21669 return(1 || funcname || hash || result7 || libp) ;
21670}
21671
21672static int G__RootEventData_rootcint_487_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21673{
21674 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPy());
21675 return(1 || funcname || hash || result7 || libp) ;
21676}
21677
21678static int G__RootEventData_rootcint_487_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21679{
21680 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPz());
21681 return(1 || funcname || hash || result7 || libp) ;
21682}
21683
21684static int G__RootEventData_rootcint_487_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21685{
21686 G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getDepositEnergy());
21687 return(1 || funcname || hash || result7 || libp) ;
21688}
21689
21690static int G__RootEventData_rootcint_487_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21691{
21692 ((TEmcMc*) G__getstructoffset())->setHitMap(*((map<Int_t,Double_t>*) G__int(libp->para[0])));
21693 G__setnull(result7);
21694 return(1 || funcname || hash || result7 || libp) ;
21695}
21696
21697static int G__RootEventData_rootcint_487_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21698{
21699 ((TEmcMc*) G__getstructoffset())->setHitEmc((int) G__int(libp->para[0]));
21700 G__setnull(result7);
21701 return(1 || funcname || hash || result7 || libp) ;
21702}
21703
21704static int G__RootEventData_rootcint_487_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21705{
21706 ((TEmcMc*) G__getstructoffset())->setPDGCode((int) G__int(libp->para[0]));
21707 G__setnull(result7);
21708 return(1 || funcname || hash || result7 || libp) ;
21709}
21710
21711static int G__RootEventData_rootcint_487_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21712{
21713 ((TEmcMc*) G__getstructoffset())->setPDGCharge((double) G__double(libp->para[0]));
21714 G__setnull(result7);
21715 return(1 || funcname || hash || result7 || libp) ;
21716}
21717
21718static int G__RootEventData_rootcint_487_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21719{
21720 ((TEmcMc*) G__getstructoffset())->setTime((double) G__double(libp->para[0]));
21721 G__setnull(result7);
21722 return(1 || funcname || hash || result7 || libp) ;
21723}
21724
21725static int G__RootEventData_rootcint_487_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21726{
21727 ((TEmcMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
21728 G__setnull(result7);
21729 return(1 || funcname || hash || result7 || libp) ;
21730}
21731
21732static int G__RootEventData_rootcint_487_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21733{
21734 ((TEmcMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
21735 G__setnull(result7);
21736 return(1 || funcname || hash || result7 || libp) ;
21737}
21738
21739static int G__RootEventData_rootcint_487_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21740{
21741 ((TEmcMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
21742 G__setnull(result7);
21743 return(1 || funcname || hash || result7 || libp) ;
21744}
21745
21746static int G__RootEventData_rootcint_487_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21747{
21748 ((TEmcMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
21749 G__setnull(result7);
21750 return(1 || funcname || hash || result7 || libp) ;
21751}
21752
21753static int G__RootEventData_rootcint_487_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21754{
21755 ((TEmcMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
21756 G__setnull(result7);
21757 return(1 || funcname || hash || result7 || libp) ;
21758}
21759
21760static int G__RootEventData_rootcint_487_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21761{
21762 ((TEmcMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
21763 G__setnull(result7);
21764 return(1 || funcname || hash || result7 || libp) ;
21765}
21766
21767static int G__RootEventData_rootcint_487_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21768{
21769 ((TEmcMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
21770 G__setnull(result7);
21771 return(1 || funcname || hash || result7 || libp) ;
21772}
21773
21774static int G__RootEventData_rootcint_487_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21775{
21776 ((TEmcMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
21777 G__setnull(result7);
21778 return(1 || funcname || hash || result7 || libp) ;
21779}
21780
21781static int G__RootEventData_rootcint_487_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21782{
21783 ((TEmcMc*) G__getstructoffset())->setDepositEnergy((Double_t) G__double(libp->para[0]));
21784 G__setnull(result7);
21785 return(1 || funcname || hash || result7 || libp) ;
21786}
21787
21788static int G__RootEventData_rootcint_487_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21789{
21790 G__letint(result7, 85, (long) TEmcMc::Class());
21791 return(1 || funcname || hash || result7 || libp) ;
21792}
21793
21794static int G__RootEventData_rootcint_487_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21795{
21796 G__letint(result7, 67, (long) TEmcMc::Class_Name());
21797 return(1 || funcname || hash || result7 || libp) ;
21798}
21799
21800static int G__RootEventData_rootcint_487_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21801{
21802 G__letint(result7, 115, (long) TEmcMc::Class_Version());
21803 return(1 || funcname || hash || result7 || libp) ;
21804}
21805
21806static int G__RootEventData_rootcint_487_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21807{
21808 TEmcMc::Dictionary();
21809 G__setnull(result7);
21810 return(1 || funcname || hash || result7 || libp) ;
21811}
21812
21813static int G__RootEventData_rootcint_487_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21814{
21815 ((TEmcMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
21816 G__setnull(result7);
21817 return(1 || funcname || hash || result7 || libp) ;
21818}
21819
21820static int G__RootEventData_rootcint_487_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21821{
21822 G__letint(result7, 67, (long) TEmcMc::DeclFileName());
21823 return(1 || funcname || hash || result7 || libp) ;
21824}
21825
21826static int G__RootEventData_rootcint_487_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21827{
21828 G__letint(result7, 105, (long) TEmcMc::ImplFileLine());
21829 return(1 || funcname || hash || result7 || libp) ;
21830}
21831
21832static int G__RootEventData_rootcint_487_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21833{
21834 G__letint(result7, 67, (long) TEmcMc::ImplFileName());
21835 return(1 || funcname || hash || result7 || libp) ;
21836}
21837
21838static int G__RootEventData_rootcint_487_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21839{
21840 G__letint(result7, 105, (long) TEmcMc::DeclFileLine());
21841 return(1 || funcname || hash || result7 || libp) ;
21842}
21843
21844// automatic copy constructor
21845static int G__RootEventData_rootcint_487_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21846
21847{
21848 TEmcMc* p;
21849 void* tmp = (void*) G__int(libp->para[0]);
21850 p = new TEmcMc(*(TEmcMc*) tmp);
21851 result7->obj.i = (long) p;
21852 result7->ref = (long) p;
21853 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
21854 return(1 || funcname || hash || result7 || libp) ;
21855}
21856
21857// automatic destructor
21858typedef TEmcMc G__TTEmcMc;
21859static int G__RootEventData_rootcint_487_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21860{
21861 char* gvp = (char*) G__getgvp();
21862 long soff = G__getstructoffset();
21863 int n = G__getaryconstruct();
21864 //
21865 //has_a_delete: 1
21866 //has_own_delete1arg: 0
21867 //has_own_delete2arg: 0
21868 //
21869 if (!soff) {
21870 return(1);
21871 }
21872 if (n) {
21873 if (gvp == (char*)G__PVOID) {
21874 delete[] (TEmcMc*) soff;
21875 } else {
21876 G__setgvp((long) G__PVOID);
21877 for (int i = n - 1; i >= 0; --i) {
21878 ((TEmcMc*) (soff+(sizeof(TEmcMc)*i)))->~G__TTEmcMc();
21879 }
21880 G__setgvp((long)gvp);
21881 }
21882 } else {
21883 if (gvp == (char*)G__PVOID) {
21884 delete (TEmcMc*) soff;
21885 } else {
21886 G__setgvp((long) G__PVOID);
21887 ((TEmcMc*) (soff))->~G__TTEmcMc();
21888 G__setgvp((long)gvp);
21889 }
21890 }
21891 G__setnull(result7);
21892 return(1 || funcname || hash || result7 || libp) ;
21893}
21894
21895// automatic assignment operator
21896static int G__RootEventData_rootcint_487_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21897{
21898 TEmcMc* dest = (TEmcMc*) G__getstructoffset();
21899 *dest = *(TEmcMc*) libp->para[0].ref;
21900 const TEmcMc& obj = *dest;
21901 result7->ref = (long) (&obj);
21902 result7->obj.i = (long) (&obj);
21903 return(1 || funcname || hash || result7 || libp) ;
21904}
21905
21906
21907/* TTofMc */
21908static int G__RootEventData_rootcint_488_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21909{
21910 TTofMc* p = NULL;
21911 char* gvp = (char*) G__getgvp();
21912 int n = G__getaryconstruct();
21913 if (n) {
21914 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21915 p = new TTofMc[n];
21916 } else {
21917 p = new((void*) gvp) TTofMc[n];
21918 }
21919 } else {
21920 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
21921 p = new TTofMc;
21922 } else {
21923 p = new((void*) gvp) TTofMc;
21924 }
21925 }
21926 result7->obj.i = (long) p;
21927 result7->ref = (long) p;
21928 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
21929 return(1 || funcname || hash || result7 || libp) ;
21930}
21931
21932static int G__RootEventData_rootcint_488_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21933{
21934 G__letint(result7, 104, (long) ((const TTofMc*) G__getstructoffset())->getId());
21935 return(1 || funcname || hash || result7 || libp) ;
21936}
21937
21938static int G__RootEventData_rootcint_488_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21939{
21940 G__letint(result7, 104, (long) ((const TTofMc*) G__getstructoffset())->getTrackIndex());
21941 return(1 || funcname || hash || result7 || libp) ;
21942}
21943
21944static int G__RootEventData_rootcint_488_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21945{
21946 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionX());
21947 return(1 || funcname || hash || result7 || libp) ;
21948}
21949
21950static int G__RootEventData_rootcint_488_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21951{
21952 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionY());
21953 return(1 || funcname || hash || result7 || libp) ;
21954}
21955
21956static int G__RootEventData_rootcint_488_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21957{
21958 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionZ());
21959 return(1 || funcname || hash || result7 || libp) ;
21960}
21961
21962static int G__RootEventData_rootcint_488_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21963{
21964 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPx());
21965 return(1 || funcname || hash || result7 || libp) ;
21966}
21967
21968static int G__RootEventData_rootcint_488_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21969{
21970 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPy());
21971 return(1 || funcname || hash || result7 || libp) ;
21972}
21973
21974static int G__RootEventData_rootcint_488_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21975{
21976 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPz());
21977 return(1 || funcname || hash || result7 || libp) ;
21978}
21979
21980static int G__RootEventData_rootcint_488_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21981{
21982 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getTrackLength());
21983 return(1 || funcname || hash || result7 || libp) ;
21984}
21985
21986static int G__RootEventData_rootcint_488_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21987{
21988 G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getFlightTime());
21989 return(1 || funcname || hash || result7 || libp) ;
21990}
21991
21992static int G__RootEventData_rootcint_488_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
21993{
21994 ((TTofMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
21995 G__setnull(result7);
21996 return(1 || funcname || hash || result7 || libp) ;
21997}
21998
21999static int G__RootEventData_rootcint_488_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22000{
22001 ((TTofMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
22002 G__setnull(result7);
22003 return(1 || funcname || hash || result7 || libp) ;
22004}
22005
22006static int G__RootEventData_rootcint_488_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22007{
22008 ((TTofMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
22009 G__setnull(result7);
22010 return(1 || funcname || hash || result7 || libp) ;
22011}
22012
22013static int G__RootEventData_rootcint_488_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22014{
22015 ((TTofMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
22016 G__setnull(result7);
22017 return(1 || funcname || hash || result7 || libp) ;
22018}
22019
22020static int G__RootEventData_rootcint_488_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22021{
22022 ((TTofMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
22023 G__setnull(result7);
22024 return(1 || funcname || hash || result7 || libp) ;
22025}
22026
22027static int G__RootEventData_rootcint_488_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22028{
22029 ((TTofMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
22030 G__setnull(result7);
22031 return(1 || funcname || hash || result7 || libp) ;
22032}
22033
22034static int G__RootEventData_rootcint_488_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22035{
22036 ((TTofMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
22037 G__setnull(result7);
22038 return(1 || funcname || hash || result7 || libp) ;
22039}
22040
22041static int G__RootEventData_rootcint_488_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22042{
22043 ((TTofMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
22044 G__setnull(result7);
22045 return(1 || funcname || hash || result7 || libp) ;
22046}
22047
22048static int G__RootEventData_rootcint_488_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22049{
22050 ((TTofMc*) G__getstructoffset())->setTrackLength((Double_t) G__double(libp->para[0]));
22051 G__setnull(result7);
22052 return(1 || funcname || hash || result7 || libp) ;
22053}
22054
22055static int G__RootEventData_rootcint_488_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22056{
22057 ((TTofMc*) G__getstructoffset())->setFlightTime((Double_t) G__double(libp->para[0]));
22058 G__setnull(result7);
22059 return(1 || funcname || hash || result7 || libp) ;
22060}
22061
22062static int G__RootEventData_rootcint_488_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22063{
22064 G__letint(result7, 85, (long) TTofMc::Class());
22065 return(1 || funcname || hash || result7 || libp) ;
22066}
22067
22068static int G__RootEventData_rootcint_488_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22069{
22070 G__letint(result7, 67, (long) TTofMc::Class_Name());
22071 return(1 || funcname || hash || result7 || libp) ;
22072}
22073
22074static int G__RootEventData_rootcint_488_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22075{
22076 G__letint(result7, 115, (long) TTofMc::Class_Version());
22077 return(1 || funcname || hash || result7 || libp) ;
22078}
22079
22080static int G__RootEventData_rootcint_488_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22081{
22082 TTofMc::Dictionary();
22083 G__setnull(result7);
22084 return(1 || funcname || hash || result7 || libp) ;
22085}
22086
22087static int G__RootEventData_rootcint_488_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22088{
22089 ((TTofMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
22090 G__setnull(result7);
22091 return(1 || funcname || hash || result7 || libp) ;
22092}
22093
22094static int G__RootEventData_rootcint_488_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22095{
22096 G__letint(result7, 67, (long) TTofMc::DeclFileName());
22097 return(1 || funcname || hash || result7 || libp) ;
22098}
22099
22100static int G__RootEventData_rootcint_488_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22101{
22102 G__letint(result7, 105, (long) TTofMc::ImplFileLine());
22103 return(1 || funcname || hash || result7 || libp) ;
22104}
22105
22106static int G__RootEventData_rootcint_488_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22107{
22108 G__letint(result7, 67, (long) TTofMc::ImplFileName());
22109 return(1 || funcname || hash || result7 || libp) ;
22110}
22111
22112static int G__RootEventData_rootcint_488_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22113{
22114 G__letint(result7, 105, (long) TTofMc::DeclFileLine());
22115 return(1 || funcname || hash || result7 || libp) ;
22116}
22117
22118// automatic copy constructor
22119static int G__RootEventData_rootcint_488_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22120
22121{
22122 TTofMc* p;
22123 void* tmp = (void*) G__int(libp->para[0]);
22124 p = new TTofMc(*(TTofMc*) tmp);
22125 result7->obj.i = (long) p;
22126 result7->ref = (long) p;
22127 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
22128 return(1 || funcname || hash || result7 || libp) ;
22129}
22130
22131// automatic destructor
22132typedef TTofMc G__TTTofMc;
22133static int G__RootEventData_rootcint_488_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22134{
22135 char* gvp = (char*) G__getgvp();
22136 long soff = G__getstructoffset();
22137 int n = G__getaryconstruct();
22138 //
22139 //has_a_delete: 1
22140 //has_own_delete1arg: 0
22141 //has_own_delete2arg: 0
22142 //
22143 if (!soff) {
22144 return(1);
22145 }
22146 if (n) {
22147 if (gvp == (char*)G__PVOID) {
22148 delete[] (TTofMc*) soff;
22149 } else {
22150 G__setgvp((long) G__PVOID);
22151 for (int i = n - 1; i >= 0; --i) {
22152 ((TTofMc*) (soff+(sizeof(TTofMc)*i)))->~G__TTTofMc();
22153 }
22154 G__setgvp((long)gvp);
22155 }
22156 } else {
22157 if (gvp == (char*)G__PVOID) {
22158 delete (TTofMc*) soff;
22159 } else {
22160 G__setgvp((long) G__PVOID);
22161 ((TTofMc*) (soff))->~G__TTTofMc();
22162 G__setgvp((long)gvp);
22163 }
22164 }
22165 G__setnull(result7);
22166 return(1 || funcname || hash || result7 || libp) ;
22167}
22168
22169// automatic assignment operator
22170static int G__RootEventData_rootcint_488_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22171{
22172 TTofMc* dest = (TTofMc*) G__getstructoffset();
22173 *dest = *(TTofMc*) libp->para[0].ref;
22174 const TTofMc& obj = *dest;
22175 result7->ref = (long) (&obj);
22176 result7->obj.i = (long) (&obj);
22177 return(1 || funcname || hash || result7 || libp) ;
22178}
22179
22180
22181/* TMucMc */
22182static int G__RootEventData_rootcint_489_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22183{
22184 TMucMc* p = NULL;
22185 char* gvp = (char*) G__getgvp();
22186 int n = G__getaryconstruct();
22187 if (n) {
22188 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22189 p = new TMucMc[n];
22190 } else {
22191 p = new((void*) gvp) TMucMc[n];
22192 }
22193 } else {
22194 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22195 p = new TMucMc;
22196 } else {
22197 p = new((void*) gvp) TMucMc;
22198 }
22199 }
22200 result7->obj.i = (long) p;
22201 result7->ref = (long) p;
22202 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
22203 return(1 || funcname || hash || result7 || libp) ;
22204}
22205
22206static int G__RootEventData_rootcint_489_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22207{
22208 G__letint(result7, 104, (long) ((const TMucMc*) G__getstructoffset())->getId());
22209 return(1 || funcname || hash || result7 || libp) ;
22210}
22211
22212static int G__RootEventData_rootcint_489_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22213{
22214 G__letint(result7, 104, (long) ((const TMucMc*) G__getstructoffset())->getTrackIndex());
22215 return(1 || funcname || hash || result7 || libp) ;
22216}
22217
22218static int G__RootEventData_rootcint_489_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22219{
22220 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionX());
22221 return(1 || funcname || hash || result7 || libp) ;
22222}
22223
22224static int G__RootEventData_rootcint_489_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22225{
22226 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionY());
22227 return(1 || funcname || hash || result7 || libp) ;
22228}
22229
22230static int G__RootEventData_rootcint_489_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22231{
22232 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionZ());
22233 return(1 || funcname || hash || result7 || libp) ;
22234}
22235
22236static int G__RootEventData_rootcint_489_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22237{
22238 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPx());
22239 return(1 || funcname || hash || result7 || libp) ;
22240}
22241
22242static int G__RootEventData_rootcint_489_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22243{
22244 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPy());
22245 return(1 || funcname || hash || result7 || libp) ;
22246}
22247
22248static int G__RootEventData_rootcint_489_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22249{
22250 G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPz());
22251 return(1 || funcname || hash || result7 || libp) ;
22252}
22253
22254static int G__RootEventData_rootcint_489_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22255{
22256 ((TMucMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
22257 G__setnull(result7);
22258 return(1 || funcname || hash || result7 || libp) ;
22259}
22260
22261static int G__RootEventData_rootcint_489_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22262{
22263 ((TMucMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
22264 G__setnull(result7);
22265 return(1 || funcname || hash || result7 || libp) ;
22266}
22267
22268static int G__RootEventData_rootcint_489_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22269{
22270 ((TMucMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
22271 G__setnull(result7);
22272 return(1 || funcname || hash || result7 || libp) ;
22273}
22274
22275static int G__RootEventData_rootcint_489_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22276{
22277 ((TMucMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
22278 G__setnull(result7);
22279 return(1 || funcname || hash || result7 || libp) ;
22280}
22281
22282static int G__RootEventData_rootcint_489_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22283{
22284 ((TMucMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
22285 G__setnull(result7);
22286 return(1 || funcname || hash || result7 || libp) ;
22287}
22288
22289static int G__RootEventData_rootcint_489_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22290{
22291 ((TMucMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
22292 G__setnull(result7);
22293 return(1 || funcname || hash || result7 || libp) ;
22294}
22295
22296static int G__RootEventData_rootcint_489_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22297{
22298 ((TMucMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
22299 G__setnull(result7);
22300 return(1 || funcname || hash || result7 || libp) ;
22301}
22302
22303static int G__RootEventData_rootcint_489_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22304{
22305 ((TMucMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
22306 G__setnull(result7);
22307 return(1 || funcname || hash || result7 || libp) ;
22308}
22309
22310static int G__RootEventData_rootcint_489_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22311{
22312 G__letint(result7, 85, (long) TMucMc::Class());
22313 return(1 || funcname || hash || result7 || libp) ;
22314}
22315
22316static int G__RootEventData_rootcint_489_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22317{
22318 G__letint(result7, 67, (long) TMucMc::Class_Name());
22319 return(1 || funcname || hash || result7 || libp) ;
22320}
22321
22322static int G__RootEventData_rootcint_489_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22323{
22324 G__letint(result7, 115, (long) TMucMc::Class_Version());
22325 return(1 || funcname || hash || result7 || libp) ;
22326}
22327
22328static int G__RootEventData_rootcint_489_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22329{
22330 TMucMc::Dictionary();
22331 G__setnull(result7);
22332 return(1 || funcname || hash || result7 || libp) ;
22333}
22334
22335static int G__RootEventData_rootcint_489_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22336{
22337 ((TMucMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
22338 G__setnull(result7);
22339 return(1 || funcname || hash || result7 || libp) ;
22340}
22341
22342static int G__RootEventData_rootcint_489_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22343{
22344 G__letint(result7, 67, (long) TMucMc::DeclFileName());
22345 return(1 || funcname || hash || result7 || libp) ;
22346}
22347
22348static int G__RootEventData_rootcint_489_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22349{
22350 G__letint(result7, 105, (long) TMucMc::ImplFileLine());
22351 return(1 || funcname || hash || result7 || libp) ;
22352}
22353
22354static int G__RootEventData_rootcint_489_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22355{
22356 G__letint(result7, 67, (long) TMucMc::ImplFileName());
22357 return(1 || funcname || hash || result7 || libp) ;
22358}
22359
22360static int G__RootEventData_rootcint_489_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22361{
22362 G__letint(result7, 105, (long) TMucMc::DeclFileLine());
22363 return(1 || funcname || hash || result7 || libp) ;
22364}
22365
22366// automatic copy constructor
22367static int G__RootEventData_rootcint_489_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22368
22369{
22370 TMucMc* p;
22371 void* tmp = (void*) G__int(libp->para[0]);
22372 p = new TMucMc(*(TMucMc*) tmp);
22373 result7->obj.i = (long) p;
22374 result7->ref = (long) p;
22375 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
22376 return(1 || funcname || hash || result7 || libp) ;
22377}
22378
22379// automatic destructor
22380typedef TMucMc G__TTMucMc;
22381static int G__RootEventData_rootcint_489_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22382{
22383 char* gvp = (char*) G__getgvp();
22384 long soff = G__getstructoffset();
22385 int n = G__getaryconstruct();
22386 //
22387 //has_a_delete: 1
22388 //has_own_delete1arg: 0
22389 //has_own_delete2arg: 0
22390 //
22391 if (!soff) {
22392 return(1);
22393 }
22394 if (n) {
22395 if (gvp == (char*)G__PVOID) {
22396 delete[] (TMucMc*) soff;
22397 } else {
22398 G__setgvp((long) G__PVOID);
22399 for (int i = n - 1; i >= 0; --i) {
22400 ((TMucMc*) (soff+(sizeof(TMucMc)*i)))->~G__TTMucMc();
22401 }
22402 G__setgvp((long)gvp);
22403 }
22404 } else {
22405 if (gvp == (char*)G__PVOID) {
22406 delete (TMucMc*) soff;
22407 } else {
22408 G__setgvp((long) G__PVOID);
22409 ((TMucMc*) (soff))->~G__TTMucMc();
22410 G__setgvp((long)gvp);
22411 }
22412 }
22413 G__setnull(result7);
22414 return(1 || funcname || hash || result7 || libp) ;
22415}
22416
22417// automatic assignment operator
22418static int G__RootEventData_rootcint_489_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22419{
22420 TMucMc* dest = (TMucMc*) G__getstructoffset();
22421 *dest = *(TMucMc*) libp->para[0].ref;
22422 const TMucMc& obj = *dest;
22423 result7->ref = (long) (&obj);
22424 result7->obj.i = (long) (&obj);
22425 return(1 || funcname || hash || result7 || libp) ;
22426}
22427
22428
22429/* TMcParticle */
22430static int G__RootEventData_rootcint_490_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22431{
22432 TMcParticle* p = NULL;
22433 char* gvp = (char*) G__getgvp();
22434 int n = G__getaryconstruct();
22435 if (n) {
22436 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22437 p = new TMcParticle[n];
22438 } else {
22439 p = new((void*) gvp) TMcParticle[n];
22440 }
22441 } else {
22442 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22443 p = new TMcParticle;
22444 } else {
22445 p = new((void*) gvp) TMcParticle;
22446 }
22447 }
22448 result7->obj.i = (long) p;
22449 result7->ref = (long) p;
22450 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
22451 return(1 || funcname || hash || result7 || libp) ;
22452}
22453
22454static int G__RootEventData_rootcint_490_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22455{
22456 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getParticleID());
22457 return(1 || funcname || hash || result7 || libp) ;
22458}
22459
22460static int G__RootEventData_rootcint_490_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22461{
22462 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getTrackIndex());
22463 return(1 || funcname || hash || result7 || libp) ;
22464}
22465
22466static int G__RootEventData_rootcint_490_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22467{
22468 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getVertexIndex0());
22469 return(1 || funcname || hash || result7 || libp) ;
22470}
22471
22472static int G__RootEventData_rootcint_490_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22473{
22474 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getVertexIndex1());
22475 return(1 || funcname || hash || result7 || libp) ;
22476}
22477
22478static int G__RootEventData_rootcint_490_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22479{
22480 G__letint(result7, 104, (long) ((const TMcParticle*) G__getstructoffset())->getStatusFlags());
22481 return(1 || funcname || hash || result7 || libp) ;
22482}
22483
22484static int G__RootEventData_rootcint_490_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22485{
22486 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionX());
22487 return(1 || funcname || hash || result7 || libp) ;
22488}
22489
22490static int G__RootEventData_rootcint_490_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22491{
22492 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionY());
22493 return(1 || funcname || hash || result7 || libp) ;
22494}
22495
22496static int G__RootEventData_rootcint_490_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22497{
22498 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionZ());
22499 return(1 || funcname || hash || result7 || libp) ;
22500}
22501
22502static int G__RootEventData_rootcint_490_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22503{
22504 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionT());
22505 return(1 || funcname || hash || result7 || libp) ;
22506}
22507
22508static int G__RootEventData_rootcint_490_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22509{
22510 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionX());
22511 return(1 || funcname || hash || result7 || libp) ;
22512}
22513
22514static int G__RootEventData_rootcint_490_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22515{
22516 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionY());
22517 return(1 || funcname || hash || result7 || libp) ;
22518}
22519
22520static int G__RootEventData_rootcint_490_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22521{
22522 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionZ());
22523 return(1 || funcname || hash || result7 || libp) ;
22524}
22525
22526static int G__RootEventData_rootcint_490_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22527{
22528 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionT());
22529 return(1 || funcname || hash || result7 || libp) ;
22530}
22531
22532static int G__RootEventData_rootcint_490_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22533{
22534 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumX());
22535 return(1 || funcname || hash || result7 || libp) ;
22536}
22537
22538static int G__RootEventData_rootcint_490_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22539{
22540 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumY());
22541 return(1 || funcname || hash || result7 || libp) ;
22542}
22543
22544static int G__RootEventData_rootcint_490_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22545{
22546 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumZ());
22547 return(1 || funcname || hash || result7 || libp) ;
22548}
22549
22550static int G__RootEventData_rootcint_490_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22551{
22552 G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumE());
22553 return(1 || funcname || hash || result7 || libp) ;
22554}
22555
22556static int G__RootEventData_rootcint_490_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22557{
22558 G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getMother());
22559 return(1 || funcname || hash || result7 || libp) ;
22560}
22561
22562static int G__RootEventData_rootcint_490_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22563{
22564 {
22565 const vector<Int_t>* pobj;
22566 const vector<Int_t> xobj = ((const TMcParticle*) G__getstructoffset())->getDaughters();
22567 pobj = new vector<Int_t>(xobj);
22568 result7->obj.i = (long) ((void*) pobj);
22569 result7->ref = result7->obj.i;
22570 G__store_tempobject(*result7);
22571 }
22572 return(1 || funcname || hash || result7 || libp) ;
22573}
22574
22575static int G__RootEventData_rootcint_490_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22576{
22577 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->primaryParticle());
22578 return(1 || funcname || hash || result7 || libp) ;
22579}
22580
22581static int G__RootEventData_rootcint_490_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22582{
22583 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->leafParticle());
22584 return(1 || funcname || hash || result7 || libp) ;
22585}
22586
22587static int G__RootEventData_rootcint_490_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22588{
22589 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->decayFromGenerator());
22590 return(1 || funcname || hash || result7 || libp) ;
22591}
22592
22593static int G__RootEventData_rootcint_490_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22594{
22595 G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->decayInFlight());
22596 return(1 || funcname || hash || result7 || libp) ;
22597}
22598
22599static int G__RootEventData_rootcint_490_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22600{
22601 ((TMcParticle*) G__getstructoffset())->setParticleID((Int_t) G__int(libp->para[0]));
22602 G__setnull(result7);
22603 return(1 || funcname || hash || result7 || libp) ;
22604}
22605
22606static int G__RootEventData_rootcint_490_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22607{
22608 ((TMcParticle*) G__getstructoffset())->setTrackIndex((Int_t) G__int(libp->para[0]));
22609 G__setnull(result7);
22610 return(1 || funcname || hash || result7 || libp) ;
22611}
22612
22613static int G__RootEventData_rootcint_490_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22614{
22615 ((TMcParticle*) G__getstructoffset())->setVertexIndex0((Int_t) G__int(libp->para[0]));
22616 G__setnull(result7);
22617 return(1 || funcname || hash || result7 || libp) ;
22618}
22619
22620static int G__RootEventData_rootcint_490_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22621{
22622 ((TMcParticle*) G__getstructoffset())->setVertexIndex1((Int_t) G__int(libp->para[0]));
22623 G__setnull(result7);
22624 return(1 || funcname || hash || result7 || libp) ;
22625}
22626
22627static int G__RootEventData_rootcint_490_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22628{
22629 ((TMcParticle*) G__getstructoffset())->setStatusFlags((UInt_t) G__int(libp->para[0]));
22630 G__setnull(result7);
22631 return(1 || funcname || hash || result7 || libp) ;
22632}
22633
22634static int G__RootEventData_rootcint_490_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22635{
22636 ((TMcParticle*) G__getstructoffset())->setInitialPositionX((Double_t) G__double(libp->para[0]));
22637 G__setnull(result7);
22638 return(1 || funcname || hash || result7 || libp) ;
22639}
22640
22641static int G__RootEventData_rootcint_490_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22642{
22643 ((TMcParticle*) G__getstructoffset())->setInitialPositionY((Double_t) G__double(libp->para[0]));
22644 G__setnull(result7);
22645 return(1 || funcname || hash || result7 || libp) ;
22646}
22647
22648static int G__RootEventData_rootcint_490_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22649{
22650 ((TMcParticle*) G__getstructoffset())->setInitialPositionZ((Double_t) G__double(libp->para[0]));
22651 G__setnull(result7);
22652 return(1 || funcname || hash || result7 || libp) ;
22653}
22654
22655static int G__RootEventData_rootcint_490_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22656{
22657 ((TMcParticle*) G__getstructoffset())->setInitialPositionT((Double_t) G__double(libp->para[0]));
22658 G__setnull(result7);
22659 return(1 || funcname || hash || result7 || libp) ;
22660}
22661
22662static int G__RootEventData_rootcint_490_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22663{
22664 ((TMcParticle*) G__getstructoffset())->setFinalPositionX((Double_t) G__double(libp->para[0]));
22665 G__setnull(result7);
22666 return(1 || funcname || hash || result7 || libp) ;
22667}
22668
22669static int G__RootEventData_rootcint_490_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22670{
22671 ((TMcParticle*) G__getstructoffset())->setFinalPositionY((Double_t) G__double(libp->para[0]));
22672 G__setnull(result7);
22673 return(1 || funcname || hash || result7 || libp) ;
22674}
22675
22676static int G__RootEventData_rootcint_490_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22677{
22678 ((TMcParticle*) G__getstructoffset())->setFinalPositionZ((Double_t) G__double(libp->para[0]));
22679 G__setnull(result7);
22680 return(1 || funcname || hash || result7 || libp) ;
22681}
22682
22683static int G__RootEventData_rootcint_490_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22684{
22685 ((TMcParticle*) G__getstructoffset())->setFinalPositionT((Double_t) G__double(libp->para[0]));
22686 G__setnull(result7);
22687 return(1 || funcname || hash || result7 || libp) ;
22688}
22689
22690static int G__RootEventData_rootcint_490_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22691{
22692 ((TMcParticle*) G__getstructoffset())->setInitialMomentumX((Double_t) G__double(libp->para[0]));
22693 G__setnull(result7);
22694 return(1 || funcname || hash || result7 || libp) ;
22695}
22696
22697static int G__RootEventData_rootcint_490_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22698{
22699 ((TMcParticle*) G__getstructoffset())->setInitialMomentumY((Double_t) G__double(libp->para[0]));
22700 G__setnull(result7);
22701 return(1 || funcname || hash || result7 || libp) ;
22702}
22703
22704static int G__RootEventData_rootcint_490_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22705{
22706 ((TMcParticle*) G__getstructoffset())->setInitialMomentumZ((Double_t) G__double(libp->para[0]));
22707 G__setnull(result7);
22708 return(1 || funcname || hash || result7 || libp) ;
22709}
22710
22711static int G__RootEventData_rootcint_490_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22712{
22713 ((TMcParticle*) G__getstructoffset())->setInitialMomentumE((Double_t) G__double(libp->para[0]));
22714 G__setnull(result7);
22715 return(1 || funcname || hash || result7 || libp) ;
22716}
22717
22718static int G__RootEventData_rootcint_490_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22719{
22720 ((TMcParticle*) G__getstructoffset())->setMother((Int_t) G__int(libp->para[0]));
22721 G__setnull(result7);
22722 return(1 || funcname || hash || result7 || libp) ;
22723}
22724
22725static int G__RootEventData_rootcint_490_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22726{
22727 ((TMcParticle*) G__getstructoffset())->setDaughters(*(vector<Int_t>*) libp->para[0].ref);
22728 G__setnull(result7);
22729 return(1 || funcname || hash || result7 || libp) ;
22730}
22731
22732static int G__RootEventData_rootcint_490_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22733{
22734 G__letint(result7, 85, (long) TMcParticle::Class());
22735 return(1 || funcname || hash || result7 || libp) ;
22736}
22737
22738static int G__RootEventData_rootcint_490_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22739{
22740 G__letint(result7, 67, (long) TMcParticle::Class_Name());
22741 return(1 || funcname || hash || result7 || libp) ;
22742}
22743
22744static int G__RootEventData_rootcint_490_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22745{
22746 G__letint(result7, 115, (long) TMcParticle::Class_Version());
22747 return(1 || funcname || hash || result7 || libp) ;
22748}
22749
22750static int G__RootEventData_rootcint_490_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22751{
22752 TMcParticle::Dictionary();
22753 G__setnull(result7);
22754 return(1 || funcname || hash || result7 || libp) ;
22755}
22756
22757static int G__RootEventData_rootcint_490_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22758{
22759 ((TMcParticle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
22760 G__setnull(result7);
22761 return(1 || funcname || hash || result7 || libp) ;
22762}
22763
22764static int G__RootEventData_rootcint_490_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22765{
22766 G__letint(result7, 67, (long) TMcParticle::DeclFileName());
22767 return(1 || funcname || hash || result7 || libp) ;
22768}
22769
22770static int G__RootEventData_rootcint_490_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22771{
22772 G__letint(result7, 105, (long) TMcParticle::ImplFileLine());
22773 return(1 || funcname || hash || result7 || libp) ;
22774}
22775
22776static int G__RootEventData_rootcint_490_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22777{
22778 G__letint(result7, 67, (long) TMcParticle::ImplFileName());
22779 return(1 || funcname || hash || result7 || libp) ;
22780}
22781
22782static int G__RootEventData_rootcint_490_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22783{
22784 G__letint(result7, 105, (long) TMcParticle::DeclFileLine());
22785 return(1 || funcname || hash || result7 || libp) ;
22786}
22787
22788// automatic copy constructor
22789static int G__RootEventData_rootcint_490_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22790
22791{
22792 TMcParticle* p;
22793 void* tmp = (void*) G__int(libp->para[0]);
22794 p = new TMcParticle(*(TMcParticle*) tmp);
22795 result7->obj.i = (long) p;
22796 result7->ref = (long) p;
22797 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
22798 return(1 || funcname || hash || result7 || libp) ;
22799}
22800
22801// automatic destructor
22802typedef TMcParticle G__TTMcParticle;
22803static int G__RootEventData_rootcint_490_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22804{
22805 char* gvp = (char*) G__getgvp();
22806 long soff = G__getstructoffset();
22807 int n = G__getaryconstruct();
22808 //
22809 //has_a_delete: 1
22810 //has_own_delete1arg: 0
22811 //has_own_delete2arg: 0
22812 //
22813 if (!soff) {
22814 return(1);
22815 }
22816 if (n) {
22817 if (gvp == (char*)G__PVOID) {
22818 delete[] (TMcParticle*) soff;
22819 } else {
22820 G__setgvp((long) G__PVOID);
22821 for (int i = n - 1; i >= 0; --i) {
22822 ((TMcParticle*) (soff+(sizeof(TMcParticle)*i)))->~G__TTMcParticle();
22823 }
22824 G__setgvp((long)gvp);
22825 }
22826 } else {
22827 if (gvp == (char*)G__PVOID) {
22828 delete (TMcParticle*) soff;
22829 } else {
22830 G__setgvp((long) G__PVOID);
22831 ((TMcParticle*) (soff))->~G__TTMcParticle();
22832 G__setgvp((long)gvp);
22833 }
22834 }
22835 G__setnull(result7);
22836 return(1 || funcname || hash || result7 || libp) ;
22837}
22838
22839// automatic assignment operator
22840static int G__RootEventData_rootcint_490_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22841{
22842 TMcParticle* dest = (TMcParticle*) G__getstructoffset();
22843 *dest = *(TMcParticle*) libp->para[0].ref;
22844 const TMcParticle& obj = *dest;
22845 result7->ref = (long) (&obj);
22846 result7->obj.i = (long) (&obj);
22847 return(1 || funcname || hash || result7 || libp) ;
22848}
22849
22850
22851/* TMcEvent */
22852static int G__RootEventData_rootcint_492_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22853{
22854 TMcEvent* p = NULL;
22855 char* gvp = (char*) G__getgvp();
22856 int n = G__getaryconstruct();
22857 if (n) {
22858 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22859 p = new TMcEvent[n];
22860 } else {
22861 p = new((void*) gvp) TMcEvent[n];
22862 }
22863 } else {
22864 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
22865 p = new TMcEvent;
22866 } else {
22867 p = new((void*) gvp) TMcEvent;
22868 }
22869 }
22870 result7->obj.i = (long) p;
22871 result7->ref = (long) p;
22872 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
22873 return(1 || funcname || hash || result7 || libp) ;
22874}
22875
22876static int G__RootEventData_rootcint_492_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22877{
22878 ((TMcEvent*) G__getstructoffset())->initialize();
22879 G__setnull(result7);
22880 return(1 || funcname || hash || result7 || libp) ;
22881}
22882
22883static int G__RootEventData_rootcint_492_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22884{
22885 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMdcMcHitCol());
22886 return(1 || funcname || hash || result7 || libp) ;
22887}
22888
22889static int G__RootEventData_rootcint_492_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22890{
22891 ((TMcEvent*) G__getstructoffset())->addMdcMc((TMdcMc*) G__int(libp->para[0]));
22892 G__setnull(result7);
22893 return(1 || funcname || hash || result7 || libp) ;
22894}
22895
22896static int G__RootEventData_rootcint_492_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22897{
22898 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMdcMc((Int_t) G__int(libp->para[0])));
22899 return(1 || funcname || hash || result7 || libp) ;
22900}
22901
22902static int G__RootEventData_rootcint_492_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22903{
22904 ((TMcEvent*) G__getstructoffset())->clearMdcMcHitCol();
22905 G__setnull(result7);
22906 return(1 || funcname || hash || result7 || libp) ;
22907}
22908
22909static int G__RootEventData_rootcint_492_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22910{
22911 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getEmcMcHitCol());
22912 return(1 || funcname || hash || result7 || libp) ;
22913}
22914
22915static int G__RootEventData_rootcint_492_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22916{
22917 ((TMcEvent*) G__getstructoffset())->addEmcMc((TEmcMc*) G__int(libp->para[0]));
22918 G__setnull(result7);
22919 return(1 || funcname || hash || result7 || libp) ;
22920}
22921
22922static int G__RootEventData_rootcint_492_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22923{
22924 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getEmcMc((Int_t) G__int(libp->para[0])));
22925 return(1 || funcname || hash || result7 || libp) ;
22926}
22927
22928static int G__RootEventData_rootcint_492_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22929{
22930 ((TMcEvent*) G__getstructoffset())->clearEmcMcHitCol();
22931 G__setnull(result7);
22932 return(1 || funcname || hash || result7 || libp) ;
22933}
22934
22935static int G__RootEventData_rootcint_492_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22936{
22937 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getTofMcHitCol());
22938 return(1 || funcname || hash || result7 || libp) ;
22939}
22940
22941static int G__RootEventData_rootcint_492_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22942{
22943 ((TMcEvent*) G__getstructoffset())->addTofMc((TTofMc*) G__int(libp->para[0]));
22944 G__setnull(result7);
22945 return(1 || funcname || hash || result7 || libp) ;
22946}
22947
22948static int G__RootEventData_rootcint_492_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22949{
22950 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getTofMc((Int_t) G__int(libp->para[0])));
22951 return(1 || funcname || hash || result7 || libp) ;
22952}
22953
22954static int G__RootEventData_rootcint_492_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22955{
22956 ((TMcEvent*) G__getstructoffset())->clearTofMcHitCol();
22957 G__setnull(result7);
22958 return(1 || funcname || hash || result7 || libp) ;
22959}
22960
22961static int G__RootEventData_rootcint_492_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22962{
22963 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMucMcHitCol());
22964 return(1 || funcname || hash || result7 || libp) ;
22965}
22966
22967static int G__RootEventData_rootcint_492_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22968{
22969 ((TMcEvent*) G__getstructoffset())->addMucMc((TMucMc*) G__int(libp->para[0]));
22970 G__setnull(result7);
22971 return(1 || funcname || hash || result7 || libp) ;
22972}
22973
22974static int G__RootEventData_rootcint_492_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22975{
22976 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMucMc((Int_t) G__int(libp->para[0])));
22977 return(1 || funcname || hash || result7 || libp) ;
22978}
22979
22980static int G__RootEventData_rootcint_492_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22981{
22982 ((TMcEvent*) G__getstructoffset())->clearMucMcHitCol();
22983 G__setnull(result7);
22984 return(1 || funcname || hash || result7 || libp) ;
22985}
22986
22987static int G__RootEventData_rootcint_492_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22988{
22989 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMcParticleCol());
22990 return(1 || funcname || hash || result7 || libp) ;
22991}
22992
22993static int G__RootEventData_rootcint_492_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
22994{
22995 ((TMcEvent*) G__getstructoffset())->addMcParticle((TMcParticle*) G__int(libp->para[0]));
22996 G__setnull(result7);
22997 return(1 || funcname || hash || result7 || libp) ;
22998}
22999
23000static int G__RootEventData_rootcint_492_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23001{
23002 G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMcParticle((Int_t) G__int(libp->para[0])));
23003 return(1 || funcname || hash || result7 || libp) ;
23004}
23005
23006static int G__RootEventData_rootcint_492_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23007{
23008 ((TMcEvent*) G__getstructoffset())->clearMcParticleCol();
23009 G__setnull(result7);
23010 return(1 || funcname || hash || result7 || libp) ;
23011}
23012
23013static int G__RootEventData_rootcint_492_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23014{
23015 G__letint(result7, 85, (long) TMcEvent::Class());
23016 return(1 || funcname || hash || result7 || libp) ;
23017}
23018
23019static int G__RootEventData_rootcint_492_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23020{
23021 G__letint(result7, 67, (long) TMcEvent::Class_Name());
23022 return(1 || funcname || hash || result7 || libp) ;
23023}
23024
23025static int G__RootEventData_rootcint_492_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23026{
23027 G__letint(result7, 115, (long) TMcEvent::Class_Version());
23028 return(1 || funcname || hash || result7 || libp) ;
23029}
23030
23031static int G__RootEventData_rootcint_492_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23032{
23033 TMcEvent::Dictionary();
23034 G__setnull(result7);
23035 return(1 || funcname || hash || result7 || libp) ;
23036}
23037
23038static int G__RootEventData_rootcint_492_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23039{
23040 ((TMcEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23041 G__setnull(result7);
23042 return(1 || funcname || hash || result7 || libp) ;
23043}
23044
23045static int G__RootEventData_rootcint_492_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23046{
23047 G__letint(result7, 67, (long) TMcEvent::DeclFileName());
23048 return(1 || funcname || hash || result7 || libp) ;
23049}
23050
23051static int G__RootEventData_rootcint_492_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23052{
23053 G__letint(result7, 105, (long) TMcEvent::ImplFileLine());
23054 return(1 || funcname || hash || result7 || libp) ;
23055}
23056
23057static int G__RootEventData_rootcint_492_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23058{
23059 G__letint(result7, 67, (long) TMcEvent::ImplFileName());
23060 return(1 || funcname || hash || result7 || libp) ;
23061}
23062
23063static int G__RootEventData_rootcint_492_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23064{
23065 G__letint(result7, 105, (long) TMcEvent::DeclFileLine());
23066 return(1 || funcname || hash || result7 || libp) ;
23067}
23068
23069// automatic copy constructor
23070static int G__RootEventData_rootcint_492_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23071
23072{
23073 TMcEvent* p;
23074 void* tmp = (void*) G__int(libp->para[0]);
23075 p = new TMcEvent(*(TMcEvent*) tmp);
23076 result7->obj.i = (long) p;
23077 result7->ref = (long) p;
23078 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
23079 return(1 || funcname || hash || result7 || libp) ;
23080}
23081
23082// automatic destructor
23083typedef TMcEvent G__TTMcEvent;
23084static int G__RootEventData_rootcint_492_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23085{
23086 char* gvp = (char*) G__getgvp();
23087 long soff = G__getstructoffset();
23088 int n = G__getaryconstruct();
23089 //
23090 //has_a_delete: 1
23091 //has_own_delete1arg: 0
23092 //has_own_delete2arg: 0
23093 //
23094 if (!soff) {
23095 return(1);
23096 }
23097 if (n) {
23098 if (gvp == (char*)G__PVOID) {
23099 delete[] (TMcEvent*) soff;
23100 } else {
23101 G__setgvp((long) G__PVOID);
23102 for (int i = n - 1; i >= 0; --i) {
23103 ((TMcEvent*) (soff+(sizeof(TMcEvent)*i)))->~G__TTMcEvent();
23104 }
23105 G__setgvp((long)gvp);
23106 }
23107 } else {
23108 if (gvp == (char*)G__PVOID) {
23109 delete (TMcEvent*) soff;
23110 } else {
23111 G__setgvp((long) G__PVOID);
23112 ((TMcEvent*) (soff))->~G__TTMcEvent();
23113 G__setgvp((long)gvp);
23114 }
23115 }
23116 G__setnull(result7);
23117 return(1 || funcname || hash || result7 || libp) ;
23118}
23119
23120// automatic assignment operator
23121static int G__RootEventData_rootcint_492_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23122{
23123 TMcEvent* dest = (TMcEvent*) G__getstructoffset();
23124 *dest = *(TMcEvent*) libp->para[0].ref;
23125 const TMcEvent& obj = *dest;
23126 result7->ref = (long) (&obj);
23127 result7->obj.i = (long) (&obj);
23128 return(1 || funcname || hash || result7 || libp) ;
23129}
23130
23131
23132/* TEvtHeader */
23133static int G__RootEventData_rootcint_493_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23134{
23135 TEvtHeader* p = NULL;
23136 char* gvp = (char*) G__getgvp();
23137 int n = G__getaryconstruct();
23138 if (n) {
23139 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23140 p = new TEvtHeader[n];
23141 } else {
23142 p = new((void*) gvp) TEvtHeader[n];
23143 }
23144 } else {
23145 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23146 p = new TEvtHeader;
23147 } else {
23148 p = new((void*) gvp) TEvtHeader;
23149 }
23150 }
23151 result7->obj.i = (long) p;
23152 result7->ref = (long) p;
23153 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
23154 return(1 || funcname || hash || result7 || libp) ;
23155}
23156
23157static int G__RootEventData_rootcint_493_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23158{
23159 ((TEvtHeader*) G__getstructoffset())->initialize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
23160, (UInt_t) G__int(libp->para[2]));
23161 G__setnull(result7);
23162 return(1 || funcname || hash || result7 || libp) ;
23163}
23164
23165static int G__RootEventData_rootcint_493_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23166{
23167 G__letint(result7, 105, (long) ((TEvtHeader*) G__getstructoffset())->getEventId());
23168 return(1 || funcname || hash || result7 || libp) ;
23169}
23170
23171static int G__RootEventData_rootcint_493_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23172{
23173 G__letint(result7, 105, (long) ((TEvtHeader*) G__getstructoffset())->getRunId());
23174 return(1 || funcname || hash || result7 || libp) ;
23175}
23176
23177static int G__RootEventData_rootcint_493_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23178{
23179 G__letint(result7, 104, (long) ((const TEvtHeader*) G__getstructoffset())->time());
23180 return(1 || funcname || hash || result7 || libp) ;
23181}
23182
23183static int G__RootEventData_rootcint_493_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23184{
23185 ((TEvtHeader*) G__getstructoffset())->setTime((int) G__int(libp->para[0]));
23186 G__setnull(result7);
23187 return(1 || funcname || hash || result7 || libp) ;
23188}
23189
23190static int G__RootEventData_rootcint_493_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23191{
23192 G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getEventTag());
23193 return(1 || funcname || hash || result7 || libp) ;
23194}
23195
23196static int G__RootEventData_rootcint_493_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23197{
23198 ((TEvtHeader*) G__getstructoffset())->setFlag1((int) G__int(libp->para[0]));
23199 G__setnull(result7);
23200 return(1 || funcname || hash || result7 || libp) ;
23201}
23202
23203static int G__RootEventData_rootcint_493_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23204{
23205 ((TEvtHeader*) G__getstructoffset())->setFlag2((int) G__int(libp->para[0]));
23206 G__setnull(result7);
23207 return(1 || funcname || hash || result7 || libp) ;
23208}
23209
23210static int G__RootEventData_rootcint_493_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23211{
23212 G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getFlag1());
23213 return(1 || funcname || hash || result7 || libp) ;
23214}
23215
23216static int G__RootEventData_rootcint_493_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23217{
23218 G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getFlag2());
23219 return(1 || funcname || hash || result7 || libp) ;
23220}
23221
23222static int G__RootEventData_rootcint_493_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23223{
23224 G__letint(result7, 85, (long) TEvtHeader::Class());
23225 return(1 || funcname || hash || result7 || libp) ;
23226}
23227
23228static int G__RootEventData_rootcint_493_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23229{
23230 G__letint(result7, 67, (long) TEvtHeader::Class_Name());
23231 return(1 || funcname || hash || result7 || libp) ;
23232}
23233
23234static int G__RootEventData_rootcint_493_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23235{
23236 G__letint(result7, 115, (long) TEvtHeader::Class_Version());
23237 return(1 || funcname || hash || result7 || libp) ;
23238}
23239
23240static int G__RootEventData_rootcint_493_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23241{
23242 TEvtHeader::Dictionary();
23243 G__setnull(result7);
23244 return(1 || funcname || hash || result7 || libp) ;
23245}
23246
23247static int G__RootEventData_rootcint_493_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23248{
23249 ((TEvtHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23250 G__setnull(result7);
23251 return(1 || funcname || hash || result7 || libp) ;
23252}
23253
23254static int G__RootEventData_rootcint_493_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23255{
23256 G__letint(result7, 67, (long) TEvtHeader::DeclFileName());
23257 return(1 || funcname || hash || result7 || libp) ;
23258}
23259
23260static int G__RootEventData_rootcint_493_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23261{
23262 G__letint(result7, 105, (long) TEvtHeader::ImplFileLine());
23263 return(1 || funcname || hash || result7 || libp) ;
23264}
23265
23266static int G__RootEventData_rootcint_493_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23267{
23268 G__letint(result7, 67, (long) TEvtHeader::ImplFileName());
23269 return(1 || funcname || hash || result7 || libp) ;
23270}
23271
23272static int G__RootEventData_rootcint_493_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23273{
23274 G__letint(result7, 105, (long) TEvtHeader::DeclFileLine());
23275 return(1 || funcname || hash || result7 || libp) ;
23276}
23277
23278// automatic copy constructor
23279static int G__RootEventData_rootcint_493_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23280
23281{
23282 TEvtHeader* p;
23283 void* tmp = (void*) G__int(libp->para[0]);
23284 p = new TEvtHeader(*(TEvtHeader*) tmp);
23285 result7->obj.i = (long) p;
23286 result7->ref = (long) p;
23287 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
23288 return(1 || funcname || hash || result7 || libp) ;
23289}
23290
23291// automatic destructor
23292typedef TEvtHeader G__TTEvtHeader;
23293static int G__RootEventData_rootcint_493_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23294{
23295 char* gvp = (char*) G__getgvp();
23296 long soff = G__getstructoffset();
23297 int n = G__getaryconstruct();
23298 //
23299 //has_a_delete: 1
23300 //has_own_delete1arg: 0
23301 //has_own_delete2arg: 0
23302 //
23303 if (!soff) {
23304 return(1);
23305 }
23306 if (n) {
23307 if (gvp == (char*)G__PVOID) {
23308 delete[] (TEvtHeader*) soff;
23309 } else {
23310 G__setgvp((long) G__PVOID);
23311 for (int i = n - 1; i >= 0; --i) {
23312 ((TEvtHeader*) (soff+(sizeof(TEvtHeader)*i)))->~G__TTEvtHeader();
23313 }
23314 G__setgvp((long)gvp);
23315 }
23316 } else {
23317 if (gvp == (char*)G__PVOID) {
23318 delete (TEvtHeader*) soff;
23319 } else {
23320 G__setgvp((long) G__PVOID);
23321 ((TEvtHeader*) (soff))->~G__TTEvtHeader();
23322 G__setgvp((long)gvp);
23323 }
23324 }
23325 G__setnull(result7);
23326 return(1 || funcname || hash || result7 || libp) ;
23327}
23328
23329// automatic assignment operator
23330static int G__RootEventData_rootcint_493_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23331{
23332 TEvtHeader* dest = (TEvtHeader*) G__getstructoffset();
23333 *dest = *(TEvtHeader*) libp->para[0].ref;
23334 const TEvtHeader& obj = *dest;
23335 result7->ref = (long) (&obj);
23336 result7->obj.i = (long) (&obj);
23337 return(1 || funcname || hash || result7 || libp) ;
23338}
23339
23340
23341/* TEvtNavigator */
23342static int G__RootEventData_rootcint_503_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23343{
23344 TEvtNavigator* p = NULL;
23345 char* gvp = (char*) G__getgvp();
23346 int n = G__getaryconstruct();
23347 if (n) {
23348 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23349 p = new TEvtNavigator[n];
23350 } else {
23351 p = new((void*) gvp) TEvtNavigator[n];
23352 }
23353 } else {
23354 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23355 p = new TEvtNavigator;
23356 } else {
23357 p = new((void*) gvp) TEvtNavigator;
23358 }
23359 }
23360 result7->obj.i = (long) p;
23361 result7->ref = (long) p;
23362 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
23363 return(1 || funcname || hash || result7 || libp) ;
23364}
23365
23366static int G__RootEventData_rootcint_503_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23367{
23368 ((TEvtNavigator*) G__getstructoffset())->LoadMcMdcMcHits(*(multimap<int,int>*) libp->para[0].ref);
23369 G__setnull(result7);
23370 return(1 || funcname || hash || result7 || libp) ;
23371}
23372
23373static int G__RootEventData_rootcint_503_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23374{
23375 ((TEvtNavigator*) G__getstructoffset())->LoadMcMdcTracks(*(multimap<int,int>*) libp->para[0].ref);
23376 G__setnull(result7);
23377 return(1 || funcname || hash || result7 || libp) ;
23378}
23379
23380static int G__RootEventData_rootcint_503_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23381{
23382 ((TEvtNavigator*) G__getstructoffset())->LoadMcEmcMcHits(*(multimap<int,int>*) libp->para[0].ref);
23383 G__setnull(result7);
23384 return(1 || funcname || hash || result7 || libp) ;
23385}
23386
23387static int G__RootEventData_rootcint_503_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23388{
23389 ((TEvtNavigator*) G__getstructoffset())->LoadMcEmcRecShowers(*(multimap<int,int>*) libp->para[0].ref);
23390 G__setnull(result7);
23391 return(1 || funcname || hash || result7 || libp) ;
23392}
23393
23394static int G__RootEventData_rootcint_503_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23395{
23396 G__letint(result7, 85, (long) TEvtNavigator::Class());
23397 return(1 || funcname || hash || result7 || libp) ;
23398}
23399
23400static int G__RootEventData_rootcint_503_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23401{
23402 G__letint(result7, 67, (long) TEvtNavigator::Class_Name());
23403 return(1 || funcname || hash || result7 || libp) ;
23404}
23405
23406static int G__RootEventData_rootcint_503_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23407{
23408 G__letint(result7, 115, (long) TEvtNavigator::Class_Version());
23409 return(1 || funcname || hash || result7 || libp) ;
23410}
23411
23412static int G__RootEventData_rootcint_503_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23413{
23414 TEvtNavigator::Dictionary();
23415 G__setnull(result7);
23416 return(1 || funcname || hash || result7 || libp) ;
23417}
23418
23419static int G__RootEventData_rootcint_503_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23420{
23421 ((TEvtNavigator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23422 G__setnull(result7);
23423 return(1 || funcname || hash || result7 || libp) ;
23424}
23425
23426static int G__RootEventData_rootcint_503_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23427{
23428 G__letint(result7, 67, (long) TEvtNavigator::DeclFileName());
23429 return(1 || funcname || hash || result7 || libp) ;
23430}
23431
23432static int G__RootEventData_rootcint_503_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23433{
23434 G__letint(result7, 105, (long) TEvtNavigator::ImplFileLine());
23435 return(1 || funcname || hash || result7 || libp) ;
23436}
23437
23438static int G__RootEventData_rootcint_503_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23439{
23440 G__letint(result7, 67, (long) TEvtNavigator::ImplFileName());
23441 return(1 || funcname || hash || result7 || libp) ;
23442}
23443
23444static int G__RootEventData_rootcint_503_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23445{
23446 G__letint(result7, 105, (long) TEvtNavigator::DeclFileLine());
23447 return(1 || funcname || hash || result7 || libp) ;
23448}
23449
23450// automatic copy constructor
23451static int G__RootEventData_rootcint_503_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23452
23453{
23454 TEvtNavigator* p;
23455 void* tmp = (void*) G__int(libp->para[0]);
23456 p = new TEvtNavigator(*(TEvtNavigator*) tmp);
23457 result7->obj.i = (long) p;
23458 result7->ref = (long) p;
23459 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
23460 return(1 || funcname || hash || result7 || libp) ;
23461}
23462
23463// automatic destructor
23464typedef TEvtNavigator G__TTEvtNavigator;
23465static int G__RootEventData_rootcint_503_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23466{
23467 char* gvp = (char*) G__getgvp();
23468 long soff = G__getstructoffset();
23469 int n = G__getaryconstruct();
23470 //
23471 //has_a_delete: 1
23472 //has_own_delete1arg: 0
23473 //has_own_delete2arg: 0
23474 //
23475 if (!soff) {
23476 return(1);
23477 }
23478 if (n) {
23479 if (gvp == (char*)G__PVOID) {
23480 delete[] (TEvtNavigator*) soff;
23481 } else {
23482 G__setgvp((long) G__PVOID);
23483 for (int i = n - 1; i >= 0; --i) {
23484 ((TEvtNavigator*) (soff+(sizeof(TEvtNavigator)*i)))->~G__TTEvtNavigator();
23485 }
23486 G__setgvp((long)gvp);
23487 }
23488 } else {
23489 if (gvp == (char*)G__PVOID) {
23490 delete (TEvtNavigator*) soff;
23491 } else {
23492 G__setgvp((long) G__PVOID);
23493 ((TEvtNavigator*) (soff))->~G__TTEvtNavigator();
23494 G__setgvp((long)gvp);
23495 }
23496 }
23497 G__setnull(result7);
23498 return(1 || funcname || hash || result7 || libp) ;
23499}
23500
23501// automatic assignment operator
23502static int G__RootEventData_rootcint_503_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23503{
23504 TEvtNavigator* dest = (TEvtNavigator*) G__getstructoffset();
23505 *dest = *(TEvtNavigator*) libp->para[0].ref;
23506 const TEvtNavigator& obj = *dest;
23507 result7->ref = (long) (&obj);
23508 result7->obj.i = (long) (&obj);
23509 return(1 || funcname || hash || result7 || libp) ;
23510}
23511
23512
23513/* TTrigData */
23514static int G__RootEventData_rootcint_507_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23515{
23516 TTrigData* p = NULL;
23517 char* gvp = (char*) G__getgvp();
23518 int n = G__getaryconstruct();
23519 if (n) {
23520 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23521 p = new TTrigData[n];
23522 } else {
23523 p = new((void*) gvp) TTrigData[n];
23524 }
23525 } else {
23526 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23527 p = new TTrigData;
23528 } else {
23529 p = new((void*) gvp) TTrigData;
23530 }
23531 }
23532 result7->obj.i = (long) p;
23533 result7->ref = (long) p;
23534 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
23535 return(1 || funcname || hash || result7 || libp) ;
23536}
23537
23538static int G__RootEventData_rootcint_507_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23539{
23540 ((TTrigData*) G__getstructoffset())->setTrigCondition((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
23541 G__setnull(result7);
23542 return(1 || funcname || hash || result7 || libp) ;
23543}
23544
23545static int G__RootEventData_rootcint_507_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23546{
23547 ((TTrigData*) G__getstructoffset())->setTrigCondition((const int*) G__int(libp->para[0]));
23548 G__setnull(result7);
23549 return(1 || funcname || hash || result7 || libp) ;
23550}
23551
23552static int G__RootEventData_rootcint_507_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23553{
23554 ((TTrigData*) G__getstructoffset())->setTrigChannel((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
23555 G__setnull(result7);
23556 return(1 || funcname || hash || result7 || libp) ;
23557}
23558
23559static int G__RootEventData_rootcint_507_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23560{
23561 ((TTrigData*) G__getstructoffset())->setTrigChannel((const int*) G__int(libp->para[0]));
23562 G__setnull(result7);
23563 return(1 || funcname || hash || result7 || libp) ;
23564}
23565
23566static int G__RootEventData_rootcint_507_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23567{
23568 ((TTrigData*) G__getstructoffset())->setTimeWindow((int) G__int(libp->para[0]));
23569 G__setnull(result7);
23570 return(1 || funcname || hash || result7 || libp) ;
23571}
23572
23573static int G__RootEventData_rootcint_507_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23574{
23575 ((TTrigData*) G__getstructoffset())->setTimingType((int) G__int(libp->para[0]));
23576 G__setnull(result7);
23577 return(1 || funcname || hash || result7 || libp) ;
23578}
23579
23580static int G__RootEventData_rootcint_507_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23581{
23582 ((TTrigData*) G__getstructoffset())->setPreScale((bool) G__int(libp->para[0]));
23583 G__setnull(result7);
23584 return(1 || funcname || hash || result7 || libp) ;
23585}
23586
23587static int G__RootEventData_rootcint_507_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23588{
23589 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTrigCondition((int) G__int(libp->para[0])));
23590 return(1 || funcname || hash || result7 || libp) ;
23591}
23592
23593static int G__RootEventData_rootcint_507_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23594{
23595 G__letint(result7, 73, (long) ((const TTrigData*) G__getstructoffset())->getTrigCondition());
23596 return(1 || funcname || hash || result7 || libp) ;
23597}
23598
23599static int G__RootEventData_rootcint_507_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23600{
23601 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTrigChannel((int) G__int(libp->para[0])));
23602 return(1 || funcname || hash || result7 || libp) ;
23603}
23604
23605static int G__RootEventData_rootcint_507_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23606{
23607 G__letint(result7, 73, (long) ((const TTrigData*) G__getstructoffset())->getTrigChannel());
23608 return(1 || funcname || hash || result7 || libp) ;
23609}
23610
23611static int G__RootEventData_rootcint_507_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23612{
23613 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTimeWindow());
23614 return(1 || funcname || hash || result7 || libp) ;
23615}
23616
23617static int G__RootEventData_rootcint_507_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23618{
23619 G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTimingType());
23620 return(1 || funcname || hash || result7 || libp) ;
23621}
23622
23623static int G__RootEventData_rootcint_507_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23624{
23625 G__letint(result7, 103, (long) ((const TTrigData*) G__getstructoffset())->getPreScale());
23626 return(1 || funcname || hash || result7 || libp) ;
23627}
23628
23629static int G__RootEventData_rootcint_507_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23630{
23631 G__letint(result7, 85, (long) TTrigData::Class());
23632 return(1 || funcname || hash || result7 || libp) ;
23633}
23634
23635static int G__RootEventData_rootcint_507_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23636{
23637 G__letint(result7, 67, (long) TTrigData::Class_Name());
23638 return(1 || funcname || hash || result7 || libp) ;
23639}
23640
23641static int G__RootEventData_rootcint_507_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23642{
23643 G__letint(result7, 115, (long) TTrigData::Class_Version());
23644 return(1 || funcname || hash || result7 || libp) ;
23645}
23646
23647static int G__RootEventData_rootcint_507_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23648{
23649 TTrigData::Dictionary();
23650 G__setnull(result7);
23651 return(1 || funcname || hash || result7 || libp) ;
23652}
23653
23654static int G__RootEventData_rootcint_507_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23655{
23656 ((TTrigData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23657 G__setnull(result7);
23658 return(1 || funcname || hash || result7 || libp) ;
23659}
23660
23661static int G__RootEventData_rootcint_507_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23662{
23663 G__letint(result7, 67, (long) TTrigData::DeclFileName());
23664 return(1 || funcname || hash || result7 || libp) ;
23665}
23666
23667static int G__RootEventData_rootcint_507_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23668{
23669 G__letint(result7, 105, (long) TTrigData::ImplFileLine());
23670 return(1 || funcname || hash || result7 || libp) ;
23671}
23672
23673static int G__RootEventData_rootcint_507_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23674{
23675 G__letint(result7, 67, (long) TTrigData::ImplFileName());
23676 return(1 || funcname || hash || result7 || libp) ;
23677}
23678
23679static int G__RootEventData_rootcint_507_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23680{
23681 G__letint(result7, 105, (long) TTrigData::DeclFileLine());
23682 return(1 || funcname || hash || result7 || libp) ;
23683}
23684
23685// automatic copy constructor
23686static int G__RootEventData_rootcint_507_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23687
23688{
23689 TTrigData* p;
23690 void* tmp = (void*) G__int(libp->para[0]);
23691 p = new TTrigData(*(TTrigData*) tmp);
23692 result7->obj.i = (long) p;
23693 result7->ref = (long) p;
23694 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
23695 return(1 || funcname || hash || result7 || libp) ;
23696}
23697
23698// automatic destructor
23699typedef TTrigData G__TTTrigData;
23700static int G__RootEventData_rootcint_507_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23701{
23702 char* gvp = (char*) G__getgvp();
23703 long soff = G__getstructoffset();
23704 int n = G__getaryconstruct();
23705 //
23706 //has_a_delete: 1
23707 //has_own_delete1arg: 0
23708 //has_own_delete2arg: 0
23709 //
23710 if (!soff) {
23711 return(1);
23712 }
23713 if (n) {
23714 if (gvp == (char*)G__PVOID) {
23715 delete[] (TTrigData*) soff;
23716 } else {
23717 G__setgvp((long) G__PVOID);
23718 for (int i = n - 1; i >= 0; --i) {
23719 ((TTrigData*) (soff+(sizeof(TTrigData)*i)))->~G__TTTrigData();
23720 }
23721 G__setgvp((long)gvp);
23722 }
23723 } else {
23724 if (gvp == (char*)G__PVOID) {
23725 delete (TTrigData*) soff;
23726 } else {
23727 G__setgvp((long) G__PVOID);
23728 ((TTrigData*) (soff))->~G__TTTrigData();
23729 G__setgvp((long)gvp);
23730 }
23731 }
23732 G__setnull(result7);
23733 return(1 || funcname || hash || result7 || libp) ;
23734}
23735
23736// automatic assignment operator
23737static int G__RootEventData_rootcint_507_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23738{
23739 TTrigData* dest = (TTrigData*) G__getstructoffset();
23740 *dest = *(TTrigData*) libp->para[0].ref;
23741 const TTrigData& obj = *dest;
23742 result7->ref = (long) (&obj);
23743 result7->obj.i = (long) (&obj);
23744 return(1 || funcname || hash || result7 || libp) ;
23745}
23746
23747
23748/* TTrigEvent */
23749static int G__RootEventData_rootcint_508_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23750{
23751 TTrigEvent* p = NULL;
23752 char* gvp = (char*) G__getgvp();
23753 int n = G__getaryconstruct();
23754 if (n) {
23755 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23756 p = new TTrigEvent[n];
23757 } else {
23758 p = new((void*) gvp) TTrigEvent[n];
23759 }
23760 } else {
23761 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23762 p = new TTrigEvent;
23763 } else {
23764 p = new((void*) gvp) TTrigEvent;
23765 }
23766 }
23767 result7->obj.i = (long) p;
23768 result7->ref = (long) p;
23769 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
23770 return(1 || funcname || hash || result7 || libp) ;
23771}
23772
23773static int G__RootEventData_rootcint_508_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23774{
23775 ((TTrigEvent*) G__getstructoffset())->initialize();
23776 G__setnull(result7);
23777 return(1 || funcname || hash || result7 || libp) ;
23778}
23779
23780static int G__RootEventData_rootcint_508_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23781{
23782 ((TTrigEvent*) G__getstructoffset())->addTrigData((TTrigData*) G__int(libp->para[0]));
23783 G__setnull(result7);
23784 return(1 || funcname || hash || result7 || libp) ;
23785}
23786
23787static int G__RootEventData_rootcint_508_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23788{
23789 G__letint(result7, 85, (long) ((const TTrigEvent*) G__getstructoffset())->getTrigData());
23790 return(1 || funcname || hash || result7 || libp) ;
23791}
23792
23793static int G__RootEventData_rootcint_508_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23794{
23795 ((TTrigEvent*) G__getstructoffset())->clearTrigData();
23796 G__setnull(result7);
23797 return(1 || funcname || hash || result7 || libp) ;
23798}
23799
23800static int G__RootEventData_rootcint_508_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23801{
23802 G__letint(result7, 85, (long) TTrigEvent::Class());
23803 return(1 || funcname || hash || result7 || libp) ;
23804}
23805
23806static int G__RootEventData_rootcint_508_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23807{
23808 G__letint(result7, 67, (long) TTrigEvent::Class_Name());
23809 return(1 || funcname || hash || result7 || libp) ;
23810}
23811
23812static int G__RootEventData_rootcint_508_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23813{
23814 G__letint(result7, 115, (long) TTrigEvent::Class_Version());
23815 return(1 || funcname || hash || result7 || libp) ;
23816}
23817
23818static int G__RootEventData_rootcint_508_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23819{
23820 TTrigEvent::Dictionary();
23821 G__setnull(result7);
23822 return(1 || funcname || hash || result7 || libp) ;
23823}
23824
23825static int G__RootEventData_rootcint_508_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23826{
23827 ((TTrigEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23828 G__setnull(result7);
23829 return(1 || funcname || hash || result7 || libp) ;
23830}
23831
23832static int G__RootEventData_rootcint_508_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23833{
23834 G__letint(result7, 67, (long) TTrigEvent::DeclFileName());
23835 return(1 || funcname || hash || result7 || libp) ;
23836}
23837
23838static int G__RootEventData_rootcint_508_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23839{
23840 G__letint(result7, 105, (long) TTrigEvent::ImplFileLine());
23841 return(1 || funcname || hash || result7 || libp) ;
23842}
23843
23844static int G__RootEventData_rootcint_508_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23845{
23846 G__letint(result7, 67, (long) TTrigEvent::ImplFileName());
23847 return(1 || funcname || hash || result7 || libp) ;
23848}
23849
23850static int G__RootEventData_rootcint_508_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23851{
23852 G__letint(result7, 105, (long) TTrigEvent::DeclFileLine());
23853 return(1 || funcname || hash || result7 || libp) ;
23854}
23855
23856// automatic copy constructor
23857static int G__RootEventData_rootcint_508_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23858
23859{
23860 TTrigEvent* p;
23861 void* tmp = (void*) G__int(libp->para[0]);
23862 p = new TTrigEvent(*(TTrigEvent*) tmp);
23863 result7->obj.i = (long) p;
23864 result7->ref = (long) p;
23865 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
23866 return(1 || funcname || hash || result7 || libp) ;
23867}
23868
23869// automatic destructor
23870typedef TTrigEvent G__TTTrigEvent;
23871static int G__RootEventData_rootcint_508_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23872{
23873 char* gvp = (char*) G__getgvp();
23874 long soff = G__getstructoffset();
23875 int n = G__getaryconstruct();
23876 //
23877 //has_a_delete: 1
23878 //has_own_delete1arg: 0
23879 //has_own_delete2arg: 0
23880 //
23881 if (!soff) {
23882 return(1);
23883 }
23884 if (n) {
23885 if (gvp == (char*)G__PVOID) {
23886 delete[] (TTrigEvent*) soff;
23887 } else {
23888 G__setgvp((long) G__PVOID);
23889 for (int i = n - 1; i >= 0; --i) {
23890 ((TTrigEvent*) (soff+(sizeof(TTrigEvent)*i)))->~G__TTTrigEvent();
23891 }
23892 G__setgvp((long)gvp);
23893 }
23894 } else {
23895 if (gvp == (char*)G__PVOID) {
23896 delete (TTrigEvent*) soff;
23897 } else {
23898 G__setgvp((long) G__PVOID);
23899 ((TTrigEvent*) (soff))->~G__TTTrigEvent();
23900 G__setgvp((long)gvp);
23901 }
23902 }
23903 G__setnull(result7);
23904 return(1 || funcname || hash || result7 || libp) ;
23905}
23906
23907// automatic assignment operator
23908static int G__RootEventData_rootcint_508_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23909{
23910 TTrigEvent* dest = (TTrigEvent*) G__getstructoffset();
23911 *dest = *(TTrigEvent*) libp->para[0].ref;
23912 const TTrigEvent& obj = *dest;
23913 result7->ref = (long) (&obj);
23914 result7->obj.i = (long) (&obj);
23915 return(1 || funcname || hash || result7 || libp) ;
23916}
23917
23918
23919/* THltRaw */
23920static int G__RootEventData_rootcint_509_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23921{
23922 THltRaw* p = NULL;
23923 char* gvp = (char*) G__getgvp();
23924 int n = G__getaryconstruct();
23925 if (n) {
23926 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23927 p = new THltRaw[n];
23928 } else {
23929 p = new((void*) gvp) THltRaw[n];
23930 }
23931 } else {
23932 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
23933 p = new THltRaw;
23934 } else {
23935 p = new((void*) gvp) THltRaw;
23936 }
23937 }
23938 result7->obj.i = (long) p;
23939 result7->ref = (long) p;
23940 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
23941 return(1 || funcname || hash || result7 || libp) ;
23942}
23943
23944static int G__RootEventData_rootcint_509_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23945{
23946 G__letint(result7, 85, (long) THltRaw::Class());
23947 return(1 || funcname || hash || result7 || libp) ;
23948}
23949
23950static int G__RootEventData_rootcint_509_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23951{
23952 G__letint(result7, 67, (long) THltRaw::Class_Name());
23953 return(1 || funcname || hash || result7 || libp) ;
23954}
23955
23956static int G__RootEventData_rootcint_509_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23957{
23958 G__letint(result7, 115, (long) THltRaw::Class_Version());
23959 return(1 || funcname || hash || result7 || libp) ;
23960}
23961
23962static int G__RootEventData_rootcint_509_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23963{
23964 THltRaw::Dictionary();
23965 G__setnull(result7);
23966 return(1 || funcname || hash || result7 || libp) ;
23967}
23968
23969static int G__RootEventData_rootcint_509_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23970{
23971 ((THltRaw*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
23972 G__setnull(result7);
23973 return(1 || funcname || hash || result7 || libp) ;
23974}
23975
23976static int G__RootEventData_rootcint_509_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23977{
23978 G__letint(result7, 67, (long) THltRaw::DeclFileName());
23979 return(1 || funcname || hash || result7 || libp) ;
23980}
23981
23982static int G__RootEventData_rootcint_509_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23983{
23984 G__letint(result7, 105, (long) THltRaw::ImplFileLine());
23985 return(1 || funcname || hash || result7 || libp) ;
23986}
23987
23988static int G__RootEventData_rootcint_509_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23989{
23990 G__letint(result7, 67, (long) THltRaw::ImplFileName());
23991 return(1 || funcname || hash || result7 || libp) ;
23992}
23993
23994static int G__RootEventData_rootcint_509_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
23995{
23996 G__letint(result7, 105, (long) THltRaw::DeclFileLine());
23997 return(1 || funcname || hash || result7 || libp) ;
23998}
23999
24000// automatic copy constructor
24001static int G__RootEventData_rootcint_509_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24002
24003{
24004 THltRaw* p;
24005 void* tmp = (void*) G__int(libp->para[0]);
24006 p = new THltRaw(*(THltRaw*) tmp);
24007 result7->obj.i = (long) p;
24008 result7->ref = (long) p;
24009 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
24010 return(1 || funcname || hash || result7 || libp) ;
24011}
24012
24013// automatic destructor
24014typedef THltRaw G__TTHltRaw;
24015static int G__RootEventData_rootcint_509_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24016{
24017 char* gvp = (char*) G__getgvp();
24018 long soff = G__getstructoffset();
24019 int n = G__getaryconstruct();
24020 //
24021 //has_a_delete: 1
24022 //has_own_delete1arg: 0
24023 //has_own_delete2arg: 0
24024 //
24025 if (!soff) {
24026 return(1);
24027 }
24028 if (n) {
24029 if (gvp == (char*)G__PVOID) {
24030 delete[] (THltRaw*) soff;
24031 } else {
24032 G__setgvp((long) G__PVOID);
24033 for (int i = n - 1; i >= 0; --i) {
24034 ((THltRaw*) (soff+(sizeof(THltRaw)*i)))->~G__TTHltRaw();
24035 }
24036 G__setgvp((long)gvp);
24037 }
24038 } else {
24039 if (gvp == (char*)G__PVOID) {
24040 delete (THltRaw*) soff;
24041 } else {
24042 G__setgvp((long) G__PVOID);
24043 ((THltRaw*) (soff))->~G__TTHltRaw();
24044 G__setgvp((long)gvp);
24045 }
24046 }
24047 G__setnull(result7);
24048 return(1 || funcname || hash || result7 || libp) ;
24049}
24050
24051// automatic assignment operator
24052static int G__RootEventData_rootcint_509_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24053{
24054 THltRaw* dest = (THltRaw*) G__getstructoffset();
24055 *dest = *(THltRaw*) libp->para[0].ref;
24056 const THltRaw& obj = *dest;
24057 result7->ref = (long) (&obj);
24058 result7->obj.i = (long) (&obj);
24059 return(1 || funcname || hash || result7 || libp) ;
24060}
24061
24062
24063/* THltInf */
24064static int G__RootEventData_rootcint_510_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24065{
24066 THltInf* p = NULL;
24067 char* gvp = (char*) G__getgvp();
24068 int n = G__getaryconstruct();
24069 if (n) {
24070 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24071 p = new THltInf[n];
24072 } else {
24073 p = new((void*) gvp) THltInf[n];
24074 }
24075 } else {
24076 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24077 p = new THltInf;
24078 } else {
24079 p = new((void*) gvp) THltInf;
24080 }
24081 }
24082 result7->obj.i = (long) p;
24083 result7->ref = (long) p;
24084 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
24085 return(1 || funcname || hash || result7 || libp) ;
24086}
24087
24088static int G__RootEventData_rootcint_510_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24089{
24090 ((THltInf*) G__getstructoffset())->setEventType((const Int_t) G__int(libp->para[0]));
24091 G__setnull(result7);
24092 return(1 || funcname || hash || result7 || libp) ;
24093}
24094
24095static int G__RootEventData_rootcint_510_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24096{
24097 ((THltInf*) G__getstructoffset())->setAlgProcess((const Int_t) G__int(libp->para[0]));
24098 G__setnull(result7);
24099 return(1 || funcname || hash || result7 || libp) ;
24100}
24101
24102static int G__RootEventData_rootcint_510_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24103{
24104 ((THltInf*) G__getstructoffset())->setCriteriaTable((const Int_t) G__int(libp->para[0]));
24105 G__setnull(result7);
24106 return(1 || funcname || hash || result7 || libp) ;
24107}
24108
24109static int G__RootEventData_rootcint_510_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24110{
24111 ((THltInf*) G__getstructoffset())->setVersion((const Int_t) G__int(libp->para[0]));
24112 G__setnull(result7);
24113 return(1 || funcname || hash || result7 || libp) ;
24114}
24115
24116static int G__RootEventData_rootcint_510_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24117{
24118 ((THltInf*) G__getstructoffset())->setTotalEnergy((const Double_t) G__double(libp->para[0]));
24119 G__setnull(result7);
24120 return(1 || funcname || hash || result7 || libp) ;
24121}
24122
24123static int G__RootEventData_rootcint_510_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24124{
24125 ((THltInf*) G__getstructoffset())->setNumber((const Int_t) G__int(libp->para[0]));
24126 G__setnull(result7);
24127 return(1 || funcname || hash || result7 || libp) ;
24128}
24129
24130static int G__RootEventData_rootcint_510_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24131{
24132 ((THltInf*) G__getstructoffset())->setNCON((const Int_t) G__int(libp->para[0]));
24133 G__setnull(result7);
24134 return(1 || funcname || hash || result7 || libp) ;
24135}
24136
24137static int G__RootEventData_rootcint_510_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24138{
24139 ((THltInf*) G__getstructoffset())->setMdcData(*(vector<Int_t>*) libp->para[0].ref);
24140 G__setnull(result7);
24141 return(1 || funcname || hash || result7 || libp) ;
24142}
24143
24144static int G__RootEventData_rootcint_510_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24145{
24146 ((THltInf*) G__getstructoffset())->setTofData(*(vector<Int_t>*) libp->para[0].ref);
24147 G__setnull(result7);
24148 return(1 || funcname || hash || result7 || libp) ;
24149}
24150
24151static int G__RootEventData_rootcint_510_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24152{
24153 ((THltInf*) G__getstructoffset())->setEmcData(*(vector<Int_t>*) libp->para[0].ref);
24154 G__setnull(result7);
24155 return(1 || funcname || hash || result7 || libp) ;
24156}
24157
24158static int G__RootEventData_rootcint_510_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24159{
24160 ((THltInf*) G__getstructoffset())->setMucData(*(vector<Int_t>*) libp->para[0].ref);
24161 G__setnull(result7);
24162 return(1 || funcname || hash || result7 || libp) ;
24163}
24164
24165static int G__RootEventData_rootcint_510_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24166{
24167 ((THltInf*) G__getstructoffset())->setConData(*(vector<Int_t>*) libp->para[0].ref);
24168 G__setnull(result7);
24169 return(1 || funcname || hash || result7 || libp) ;
24170}
24171
24172static int G__RootEventData_rootcint_510_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24173{
24174 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getEventType());
24175 return(1 || funcname || hash || result7 || libp) ;
24176}
24177
24178static int G__RootEventData_rootcint_510_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24179{
24180 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getAlgProcess());
24181 return(1 || funcname || hash || result7 || libp) ;
24182}
24183
24184static int G__RootEventData_rootcint_510_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24185{
24186 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getCriteriaTable());
24187 return(1 || funcname || hash || result7 || libp) ;
24188}
24189
24190static int G__RootEventData_rootcint_510_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24191{
24192 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getVersion());
24193 return(1 || funcname || hash || result7 || libp) ;
24194}
24195
24196static int G__RootEventData_rootcint_510_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24197{
24198 G__letdouble(result7, 100, (double) ((const THltInf*) G__getstructoffset())->getTotalEnergy());
24199 return(1 || funcname || hash || result7 || libp) ;
24200}
24201
24202static int G__RootEventData_rootcint_510_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24203{
24204 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getNumber());
24205 return(1 || funcname || hash || result7 || libp) ;
24206}
24207
24208static int G__RootEventData_rootcint_510_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24209{
24210 G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getNCON());
24211 return(1 || funcname || hash || result7 || libp) ;
24212}
24213
24214static int G__RootEventData_rootcint_510_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24215{
24216 {
24217 const vector<Int_t>* pobj;
24218 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getMdcData();
24219 pobj = new vector<Int_t>(xobj);
24220 result7->obj.i = (long) ((void*) pobj);
24221 result7->ref = result7->obj.i;
24222 G__store_tempobject(*result7);
24223 }
24224 return(1 || funcname || hash || result7 || libp) ;
24225}
24226
24227static int G__RootEventData_rootcint_510_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24228{
24229 {
24230 const vector<Int_t>* pobj;
24231 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getTofData();
24232 pobj = new vector<Int_t>(xobj);
24233 result7->obj.i = (long) ((void*) pobj);
24234 result7->ref = result7->obj.i;
24235 G__store_tempobject(*result7);
24236 }
24237 return(1 || funcname || hash || result7 || libp) ;
24238}
24239
24240static int G__RootEventData_rootcint_510_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24241{
24242 {
24243 const vector<Int_t>* pobj;
24244 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getEmcData();
24245 pobj = new vector<Int_t>(xobj);
24246 result7->obj.i = (long) ((void*) pobj);
24247 result7->ref = result7->obj.i;
24248 G__store_tempobject(*result7);
24249 }
24250 return(1 || funcname || hash || result7 || libp) ;
24251}
24252
24253static int G__RootEventData_rootcint_510_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24254{
24255 {
24256 const vector<Int_t>* pobj;
24257 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getMucData();
24258 pobj = new vector<Int_t>(xobj);
24259 result7->obj.i = (long) ((void*) pobj);
24260 result7->ref = result7->obj.i;
24261 G__store_tempobject(*result7);
24262 }
24263 return(1 || funcname || hash || result7 || libp) ;
24264}
24265
24266static int G__RootEventData_rootcint_510_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24267{
24268 {
24269 const vector<Int_t>* pobj;
24270 const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getConData();
24271 pobj = new vector<Int_t>(xobj);
24272 result7->obj.i = (long) ((void*) pobj);
24273 result7->ref = result7->obj.i;
24274 G__store_tempobject(*result7);
24275 }
24276 return(1 || funcname || hash || result7 || libp) ;
24277}
24278
24279static int G__RootEventData_rootcint_510_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24280{
24281 G__letint(result7, 85, (long) THltInf::Class());
24282 return(1 || funcname || hash || result7 || libp) ;
24283}
24284
24285static int G__RootEventData_rootcint_510_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24286{
24287 G__letint(result7, 67, (long) THltInf::Class_Name());
24288 return(1 || funcname || hash || result7 || libp) ;
24289}
24290
24291static int G__RootEventData_rootcint_510_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24292{
24293 G__letint(result7, 115, (long) THltInf::Class_Version());
24294 return(1 || funcname || hash || result7 || libp) ;
24295}
24296
24297static int G__RootEventData_rootcint_510_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24298{
24299 THltInf::Dictionary();
24300 G__setnull(result7);
24301 return(1 || funcname || hash || result7 || libp) ;
24302}
24303
24304static int G__RootEventData_rootcint_510_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24305{
24306 ((THltInf*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24307 G__setnull(result7);
24308 return(1 || funcname || hash || result7 || libp) ;
24309}
24310
24311static int G__RootEventData_rootcint_510_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24312{
24313 G__letint(result7, 67, (long) THltInf::DeclFileName());
24314 return(1 || funcname || hash || result7 || libp) ;
24315}
24316
24317static int G__RootEventData_rootcint_510_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24318{
24319 G__letint(result7, 105, (long) THltInf::ImplFileLine());
24320 return(1 || funcname || hash || result7 || libp) ;
24321}
24322
24323static int G__RootEventData_rootcint_510_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24324{
24325 G__letint(result7, 67, (long) THltInf::ImplFileName());
24326 return(1 || funcname || hash || result7 || libp) ;
24327}
24328
24329static int G__RootEventData_rootcint_510_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24330{
24331 G__letint(result7, 105, (long) THltInf::DeclFileLine());
24332 return(1 || funcname || hash || result7 || libp) ;
24333}
24334
24335// automatic copy constructor
24336static int G__RootEventData_rootcint_510_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24337
24338{
24339 THltInf* p;
24340 void* tmp = (void*) G__int(libp->para[0]);
24341 p = new THltInf(*(THltInf*) tmp);
24342 result7->obj.i = (long) p;
24343 result7->ref = (long) p;
24344 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
24345 return(1 || funcname || hash || result7 || libp) ;
24346}
24347
24348// automatic destructor
24349typedef THltInf G__TTHltInf;
24350static int G__RootEventData_rootcint_510_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24351{
24352 char* gvp = (char*) G__getgvp();
24353 long soff = G__getstructoffset();
24354 int n = G__getaryconstruct();
24355 //
24356 //has_a_delete: 1
24357 //has_own_delete1arg: 0
24358 //has_own_delete2arg: 0
24359 //
24360 if (!soff) {
24361 return(1);
24362 }
24363 if (n) {
24364 if (gvp == (char*)G__PVOID) {
24365 delete[] (THltInf*) soff;
24366 } else {
24367 G__setgvp((long) G__PVOID);
24368 for (int i = n - 1; i >= 0; --i) {
24369 ((THltInf*) (soff+(sizeof(THltInf)*i)))->~G__TTHltInf();
24370 }
24371 G__setgvp((long)gvp);
24372 }
24373 } else {
24374 if (gvp == (char*)G__PVOID) {
24375 delete (THltInf*) soff;
24376 } else {
24377 G__setgvp((long) G__PVOID);
24378 ((THltInf*) (soff))->~G__TTHltInf();
24379 G__setgvp((long)gvp);
24380 }
24381 }
24382 G__setnull(result7);
24383 return(1 || funcname || hash || result7 || libp) ;
24384}
24385
24386// automatic assignment operator
24387static int G__RootEventData_rootcint_510_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24388{
24389 THltInf* dest = (THltInf*) G__getstructoffset();
24390 *dest = *(THltInf*) libp->para[0].ref;
24391 const THltInf& obj = *dest;
24392 result7->ref = (long) (&obj);
24393 result7->obj.i = (long) (&obj);
24394 return(1 || funcname || hash || result7 || libp) ;
24395}
24396
24397
24398/* TDstHltInf */
24399static int G__RootEventData_rootcint_511_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24400{
24401 TDstHltInf* p = NULL;
24402 char* gvp = (char*) G__getgvp();
24403 int n = G__getaryconstruct();
24404 if (n) {
24405 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24406 p = new TDstHltInf[n];
24407 } else {
24408 p = new((void*) gvp) TDstHltInf[n];
24409 }
24410 } else {
24411 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24412 p = new TDstHltInf;
24413 } else {
24414 p = new((void*) gvp) TDstHltInf;
24415 }
24416 }
24417 result7->obj.i = (long) p;
24418 result7->ref = (long) p;
24419 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
24420 return(1 || funcname || hash || result7 || libp) ;
24421}
24422
24423static int G__RootEventData_rootcint_511_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24424{
24425 ((TDstHltInf*) G__getstructoffset())->setEventType((const Int_t) G__int(libp->para[0]));
24426 G__setnull(result7);
24427 return(1 || funcname || hash || result7 || libp) ;
24428}
24429
24430static int G__RootEventData_rootcint_511_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24431{
24432 ((TDstHltInf*) G__getstructoffset())->setAlgProcess((const Int_t) G__int(libp->para[0]));
24433 G__setnull(result7);
24434 return(1 || funcname || hash || result7 || libp) ;
24435}
24436
24437static int G__RootEventData_rootcint_511_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24438{
24439 ((TDstHltInf*) G__getstructoffset())->setCriteriaTable((const Int_t) G__int(libp->para[0]));
24440 G__setnull(result7);
24441 return(1 || funcname || hash || result7 || libp) ;
24442}
24443
24444static int G__RootEventData_rootcint_511_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24445{
24446 ((TDstHltInf*) G__getstructoffset())->setVersion((const Int_t) G__int(libp->para[0]));
24447 G__setnull(result7);
24448 return(1 || funcname || hash || result7 || libp) ;
24449}
24450
24451static int G__RootEventData_rootcint_511_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24452{
24453 ((TDstHltInf*) G__getstructoffset())->setTotalEnergy((const Double_t) G__double(libp->para[0]));
24454 G__setnull(result7);
24455 return(1 || funcname || hash || result7 || libp) ;
24456}
24457
24458static int G__RootEventData_rootcint_511_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24459{
24460 ((TDstHltInf*) G__getstructoffset())->setNumber((const Int_t) G__int(libp->para[0]));
24461 G__setnull(result7);
24462 return(1 || funcname || hash || result7 || libp) ;
24463}
24464
24465static int G__RootEventData_rootcint_511_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24466{
24467 ((TDstHltInf*) G__getstructoffset())->setNCON((const Int_t) G__int(libp->para[0]));
24468 G__setnull(result7);
24469 return(1 || funcname || hash || result7 || libp) ;
24470}
24471
24472static int G__RootEventData_rootcint_511_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24473{
24474 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getEventType());
24475 return(1 || funcname || hash || result7 || libp) ;
24476}
24477
24478static int G__RootEventData_rootcint_511_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24479{
24480 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getAlgProcess());
24481 return(1 || funcname || hash || result7 || libp) ;
24482}
24483
24484static int G__RootEventData_rootcint_511_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24485{
24486 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getCriteriaTable());
24487 return(1 || funcname || hash || result7 || libp) ;
24488}
24489
24490static int G__RootEventData_rootcint_511_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24491{
24492 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getVersion());
24493 return(1 || funcname || hash || result7 || libp) ;
24494}
24495
24496static int G__RootEventData_rootcint_511_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24497{
24498 G__letdouble(result7, 100, (double) ((const TDstHltInf*) G__getstructoffset())->getTotalEnergy());
24499 return(1 || funcname || hash || result7 || libp) ;
24500}
24501
24502static int G__RootEventData_rootcint_511_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24503{
24504 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getNumber());
24505 return(1 || funcname || hash || result7 || libp) ;
24506}
24507
24508static int G__RootEventData_rootcint_511_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24509{
24510 G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getNCON());
24511 return(1 || funcname || hash || result7 || libp) ;
24512}
24513
24514static int G__RootEventData_rootcint_511_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24515{
24516 G__letint(result7, 85, (long) TDstHltInf::Class());
24517 return(1 || funcname || hash || result7 || libp) ;
24518}
24519
24520static int G__RootEventData_rootcint_511_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24521{
24522 G__letint(result7, 67, (long) TDstHltInf::Class_Name());
24523 return(1 || funcname || hash || result7 || libp) ;
24524}
24525
24526static int G__RootEventData_rootcint_511_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24527{
24528 G__letint(result7, 115, (long) TDstHltInf::Class_Version());
24529 return(1 || funcname || hash || result7 || libp) ;
24530}
24531
24532static int G__RootEventData_rootcint_511_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24533{
24534 TDstHltInf::Dictionary();
24535 G__setnull(result7);
24536 return(1 || funcname || hash || result7 || libp) ;
24537}
24538
24539static int G__RootEventData_rootcint_511_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24540{
24541 ((TDstHltInf*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24542 G__setnull(result7);
24543 return(1 || funcname || hash || result7 || libp) ;
24544}
24545
24546static int G__RootEventData_rootcint_511_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24547{
24548 G__letint(result7, 67, (long) TDstHltInf::DeclFileName());
24549 return(1 || funcname || hash || result7 || libp) ;
24550}
24551
24552static int G__RootEventData_rootcint_511_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24553{
24554 G__letint(result7, 105, (long) TDstHltInf::ImplFileLine());
24555 return(1 || funcname || hash || result7 || libp) ;
24556}
24557
24558static int G__RootEventData_rootcint_511_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24559{
24560 G__letint(result7, 67, (long) TDstHltInf::ImplFileName());
24561 return(1 || funcname || hash || result7 || libp) ;
24562}
24563
24564static int G__RootEventData_rootcint_511_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24565{
24566 G__letint(result7, 105, (long) TDstHltInf::DeclFileLine());
24567 return(1 || funcname || hash || result7 || libp) ;
24568}
24569
24570// automatic copy constructor
24571static int G__RootEventData_rootcint_511_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24572
24573{
24574 TDstHltInf* p;
24575 void* tmp = (void*) G__int(libp->para[0]);
24576 p = new TDstHltInf(*(TDstHltInf*) tmp);
24577 result7->obj.i = (long) p;
24578 result7->ref = (long) p;
24579 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
24580 return(1 || funcname || hash || result7 || libp) ;
24581}
24582
24583// automatic destructor
24584typedef TDstHltInf G__TTDstHltInf;
24585static int G__RootEventData_rootcint_511_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24586{
24587 char* gvp = (char*) G__getgvp();
24588 long soff = G__getstructoffset();
24589 int n = G__getaryconstruct();
24590 //
24591 //has_a_delete: 1
24592 //has_own_delete1arg: 0
24593 //has_own_delete2arg: 0
24594 //
24595 if (!soff) {
24596 return(1);
24597 }
24598 if (n) {
24599 if (gvp == (char*)G__PVOID) {
24600 delete[] (TDstHltInf*) soff;
24601 } else {
24602 G__setgvp((long) G__PVOID);
24603 for (int i = n - 1; i >= 0; --i) {
24604 ((TDstHltInf*) (soff+(sizeof(TDstHltInf)*i)))->~G__TTDstHltInf();
24605 }
24606 G__setgvp((long)gvp);
24607 }
24608 } else {
24609 if (gvp == (char*)G__PVOID) {
24610 delete (TDstHltInf*) soff;
24611 } else {
24612 G__setgvp((long) G__PVOID);
24613 ((TDstHltInf*) (soff))->~G__TTDstHltInf();
24614 G__setgvp((long)gvp);
24615 }
24616 }
24617 G__setnull(result7);
24618 return(1 || funcname || hash || result7 || libp) ;
24619}
24620
24621// automatic assignment operator
24622static int G__RootEventData_rootcint_511_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24623{
24624 TDstHltInf* dest = (TDstHltInf*) G__getstructoffset();
24625 *dest = *(TDstHltInf*) libp->para[0].ref;
24626 const TDstHltInf& obj = *dest;
24627 result7->ref = (long) (&obj);
24628 result7->obj.i = (long) (&obj);
24629 return(1 || funcname || hash || result7 || libp) ;
24630}
24631
24632
24633/* THltEvent */
24634static int G__RootEventData_rootcint_512_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24635{
24636 THltEvent* p = NULL;
24637 char* gvp = (char*) G__getgvp();
24638 int n = G__getaryconstruct();
24639 if (n) {
24640 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24641 p = new THltEvent[n];
24642 } else {
24643 p = new((void*) gvp) THltEvent[n];
24644 }
24645 } else {
24646 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24647 p = new THltEvent;
24648 } else {
24649 p = new((void*) gvp) THltEvent;
24650 }
24651 }
24652 result7->obj.i = (long) p;
24653 result7->ref = (long) p;
24654 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
24655 return(1 || funcname || hash || result7 || libp) ;
24656}
24657
24658static int G__RootEventData_rootcint_512_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24659{
24660 ((THltEvent*) G__getstructoffset())->initialize();
24661 G__setnull(result7);
24662 return(1 || funcname || hash || result7 || libp) ;
24663}
24664
24665static int G__RootEventData_rootcint_512_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24666{
24667 ((THltEvent*) G__getstructoffset())->addHltRaw((THltRaw*) G__int(libp->para[0]));
24668 G__setnull(result7);
24669 return(1 || funcname || hash || result7 || libp) ;
24670}
24671
24672static int G__RootEventData_rootcint_512_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24673{
24674 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltRaw((int) G__int(libp->para[0])));
24675 return(1 || funcname || hash || result7 || libp) ;
24676}
24677
24678static int G__RootEventData_rootcint_512_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24679{
24680 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltRawCol());
24681 return(1 || funcname || hash || result7 || libp) ;
24682}
24683
24684static int G__RootEventData_rootcint_512_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24685{
24686 ((THltEvent*) G__getstructoffset())->clearHltRawCol();
24687 G__setnull(result7);
24688 return(1 || funcname || hash || result7 || libp) ;
24689}
24690
24691static int G__RootEventData_rootcint_512_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24692{
24693 ((THltEvent*) G__getstructoffset())->addHltInf((THltInf*) G__int(libp->para[0]));
24694 G__setnull(result7);
24695 return(1 || funcname || hash || result7 || libp) ;
24696}
24697
24698static int G__RootEventData_rootcint_512_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24699{
24700 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltInf());
24701 return(1 || funcname || hash || result7 || libp) ;
24702}
24703
24704static int G__RootEventData_rootcint_512_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24705{
24706 ((THltEvent*) G__getstructoffset())->clearHltInf();
24707 G__setnull(result7);
24708 return(1 || funcname || hash || result7 || libp) ;
24709}
24710
24711static int G__RootEventData_rootcint_512_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24712{
24713 ((THltEvent*) G__getstructoffset())->addDstHltInf((TDstHltInf*) G__int(libp->para[0]));
24714 G__setnull(result7);
24715 return(1 || funcname || hash || result7 || libp) ;
24716}
24717
24718static int G__RootEventData_rootcint_512_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24719{
24720 G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getDstHltInf());
24721 return(1 || funcname || hash || result7 || libp) ;
24722}
24723
24724static int G__RootEventData_rootcint_512_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24725{
24726 ((THltEvent*) G__getstructoffset())->clearDstHltInf();
24727 G__setnull(result7);
24728 return(1 || funcname || hash || result7 || libp) ;
24729}
24730
24731static int G__RootEventData_rootcint_512_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24732{
24733 G__letint(result7, 85, (long) THltEvent::Class());
24734 return(1 || funcname || hash || result7 || libp) ;
24735}
24736
24737static int G__RootEventData_rootcint_512_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24738{
24739 G__letint(result7, 67, (long) THltEvent::Class_Name());
24740 return(1 || funcname || hash || result7 || libp) ;
24741}
24742
24743static int G__RootEventData_rootcint_512_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24744{
24745 G__letint(result7, 115, (long) THltEvent::Class_Version());
24746 return(1 || funcname || hash || result7 || libp) ;
24747}
24748
24749static int G__RootEventData_rootcint_512_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24750{
24751 THltEvent::Dictionary();
24752 G__setnull(result7);
24753 return(1 || funcname || hash || result7 || libp) ;
24754}
24755
24756static int G__RootEventData_rootcint_512_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24757{
24758 ((THltEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
24759 G__setnull(result7);
24760 return(1 || funcname || hash || result7 || libp) ;
24761}
24762
24763static int G__RootEventData_rootcint_512_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24764{
24765 G__letint(result7, 67, (long) THltEvent::DeclFileName());
24766 return(1 || funcname || hash || result7 || libp) ;
24767}
24768
24769static int G__RootEventData_rootcint_512_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24770{
24771 G__letint(result7, 105, (long) THltEvent::ImplFileLine());
24772 return(1 || funcname || hash || result7 || libp) ;
24773}
24774
24775static int G__RootEventData_rootcint_512_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24776{
24777 G__letint(result7, 67, (long) THltEvent::ImplFileName());
24778 return(1 || funcname || hash || result7 || libp) ;
24779}
24780
24781static int G__RootEventData_rootcint_512_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24782{
24783 G__letint(result7, 105, (long) THltEvent::DeclFileLine());
24784 return(1 || funcname || hash || result7 || libp) ;
24785}
24786
24787// automatic copy constructor
24788static int G__RootEventData_rootcint_512_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24789
24790{
24791 THltEvent* p;
24792 void* tmp = (void*) G__int(libp->para[0]);
24793 p = new THltEvent(*(THltEvent*) tmp);
24794 result7->obj.i = (long) p;
24795 result7->ref = (long) p;
24796 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
24797 return(1 || funcname || hash || result7 || libp) ;
24798}
24799
24800// automatic destructor
24801typedef THltEvent G__TTHltEvent;
24802static int G__RootEventData_rootcint_512_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24803{
24804 char* gvp = (char*) G__getgvp();
24805 long soff = G__getstructoffset();
24806 int n = G__getaryconstruct();
24807 //
24808 //has_a_delete: 1
24809 //has_own_delete1arg: 0
24810 //has_own_delete2arg: 0
24811 //
24812 if (!soff) {
24813 return(1);
24814 }
24815 if (n) {
24816 if (gvp == (char*)G__PVOID) {
24817 delete[] (THltEvent*) soff;
24818 } else {
24819 G__setgvp((long) G__PVOID);
24820 for (int i = n - 1; i >= 0; --i) {
24821 ((THltEvent*) (soff+(sizeof(THltEvent)*i)))->~G__TTHltEvent();
24822 }
24823 G__setgvp((long)gvp);
24824 }
24825 } else {
24826 if (gvp == (char*)G__PVOID) {
24827 delete (THltEvent*) soff;
24828 } else {
24829 G__setgvp((long) G__PVOID);
24830 ((THltEvent*) (soff))->~G__TTHltEvent();
24831 G__setgvp((long)gvp);
24832 }
24833 }
24834 G__setnull(result7);
24835 return(1 || funcname || hash || result7 || libp) ;
24836}
24837
24838// automatic assignment operator
24839static int G__RootEventData_rootcint_512_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24840{
24841 THltEvent* dest = (THltEvent*) G__getstructoffset();
24842 *dest = *(THltEvent*) libp->para[0].ref;
24843 const THltEvent& obj = *dest;
24844 result7->ref = (long) (&obj);
24845 result7->obj.i = (long) (&obj);
24846 return(1 || funcname || hash || result7 || libp) ;
24847}
24848
24849
24850/* TDisTrack */
24851static int G__RootEventData_rootcint_513_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24852{
24853 TDisTrack* p = NULL;
24854 char* gvp = (char*) G__getgvp();
24855 int n = G__getaryconstruct();
24856 if (n) {
24857 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24858 p = new TDisTrack[n];
24859 } else {
24860 p = new((void*) gvp) TDisTrack[n];
24861 }
24862 } else {
24863 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
24864 p = new TDisTrack;
24865 } else {
24866 p = new((void*) gvp) TDisTrack;
24867 }
24868 }
24869 result7->obj.i = (long) p;
24870 result7->ref = (long) p;
24871 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
24872 return(1 || funcname || hash || result7 || libp) ;
24873}
24874
24875static int G__RootEventData_rootcint_513_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24876{
24877 ((TDisTrack*) G__getstructoffset())->initialize();
24878 G__setnull(result7);
24879 return(1 || funcname || hash || result7 || libp) ;
24880}
24881
24882static int G__RootEventData_rootcint_513_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24883{
24884 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcTrackCol());
24885 return(1 || funcname || hash || result7 || libp) ;
24886}
24887
24888static int G__RootEventData_rootcint_513_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24889{
24890 ((TDisTrack*) G__getstructoffset())->addRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
24891 G__setnull(result7);
24892 return(1 || funcname || hash || result7 || libp) ;
24893}
24894
24895static int G__RootEventData_rootcint_513_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24896{
24897 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcTrack((Int_t) G__int(libp->para[0])));
24898 return(1 || funcname || hash || result7 || libp) ;
24899}
24900
24901static int G__RootEventData_rootcint_513_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24902{
24903 ((TDisTrack*) G__getstructoffset())->clearRecMdcTrackCol();
24904 G__setnull(result7);
24905 return(1 || funcname || hash || result7 || libp) ;
24906}
24907
24908static int G__RootEventData_rootcint_513_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24909{
24910 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcHitCol());
24911 return(1 || funcname || hash || result7 || libp) ;
24912}
24913
24914static int G__RootEventData_rootcint_513_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24915{
24916 ((TDisTrack*) G__getstructoffset())->addRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
24917 G__setnull(result7);
24918 return(1 || funcname || hash || result7 || libp) ;
24919}
24920
24921static int G__RootEventData_rootcint_513_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24922{
24923 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcHit((Int_t) G__int(libp->para[0])));
24924 return(1 || funcname || hash || result7 || libp) ;
24925}
24926
24927static int G__RootEventData_rootcint_513_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24928{
24929 ((TDisTrack*) G__getstructoffset())->clearRecMdcHitCol();
24930 G__setnull(result7);
24931 return(1 || funcname || hash || result7 || libp) ;
24932}
24933
24934static int G__RootEventData_rootcint_513_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24935{
24936 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getTofTrackCol());
24937 return(1 || funcname || hash || result7 || libp) ;
24938}
24939
24940static int G__RootEventData_rootcint_513_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24941{
24942 ((TDisTrack*) G__getstructoffset())->addTofTrack((TRecTofTrack*) G__int(libp->para[0]));
24943 G__setnull(result7);
24944 return(1 || funcname || hash || result7 || libp) ;
24945}
24946
24947static int G__RootEventData_rootcint_513_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24948{
24949 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
24950 return(1 || funcname || hash || result7 || libp) ;
24951}
24952
24953static int G__RootEventData_rootcint_513_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24954{
24955 ((TDisTrack*) G__getstructoffset())->clearTofTrackCol();
24956 G__setnull(result7);
24957 return(1 || funcname || hash || result7 || libp) ;
24958}
24959
24960static int G__RootEventData_rootcint_513_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24961{
24962 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getMucTrackCol());
24963 return(1 || funcname || hash || result7 || libp) ;
24964}
24965
24966static int G__RootEventData_rootcint_513_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24967{
24968 ((TDisTrack*) G__getstructoffset())->addMucTrack((TRecMucTrack*) G__int(libp->para[0]));
24969 G__setnull(result7);
24970 return(1 || funcname || hash || result7 || libp) ;
24971}
24972
24973static int G__RootEventData_rootcint_513_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24974{
24975 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
24976 return(1 || funcname || hash || result7 || libp) ;
24977}
24978
24979static int G__RootEventData_rootcint_513_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24980{
24981 ((TDisTrack*) G__getstructoffset())->clearMucTrackCol();
24982 G__setnull(result7);
24983 return(1 || funcname || hash || result7 || libp) ;
24984}
24985
24986static int G__RootEventData_rootcint_513_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24987{
24988 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMdcTrackNum());
24989 return(1 || funcname || hash || result7 || libp) ;
24990}
24991
24992static int G__RootEventData_rootcint_513_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24993{
24994 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getTofTrackNum());
24995 return(1 || funcname || hash || result7 || libp) ;
24996}
24997
24998static int G__RootEventData_rootcint_513_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
24999{
25000 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getEmcShowerNum());
25001 return(1 || funcname || hash || result7 || libp) ;
25002}
25003
25004static int G__RootEventData_rootcint_513_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25005{
25006 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMucTrackNum());
25007 return(1 || funcname || hash || result7 || libp) ;
25008}
25009
25010static int G__RootEventData_rootcint_513_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25011{
25012 G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMdcHitNum());
25013 return(1 || funcname || hash || result7 || libp) ;
25014}
25015
25016static int G__RootEventData_rootcint_513_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25017{
25018 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getEmcShowerCol());
25019 return(1 || funcname || hash || result7 || libp) ;
25020}
25021
25022static int G__RootEventData_rootcint_513_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25023{
25024 ((TDisTrack*) G__getstructoffset())->addEmcShower((TRecEmcShower*) G__int(libp->para[0]));
25025 G__setnull(result7);
25026 return(1 || funcname || hash || result7 || libp) ;
25027}
25028
25029static int G__RootEventData_rootcint_513_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25030{
25031 G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getEmcShower((Int_t) G__int(libp->para[0])));
25032 return(1 || funcname || hash || result7 || libp) ;
25033}
25034
25035static int G__RootEventData_rootcint_513_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25036{
25037 ((TDisTrack*) G__getstructoffset())->clearEmcShowerCol();
25038 G__setnull(result7);
25039 return(1 || funcname || hash || result7 || libp) ;
25040}
25041
25042static int G__RootEventData_rootcint_513_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25043{
25044 G__letint(result7, 85, (long) TDisTrack::Class());
25045 return(1 || funcname || hash || result7 || libp) ;
25046}
25047
25048static int G__RootEventData_rootcint_513_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25049{
25050 G__letint(result7, 67, (long) TDisTrack::Class_Name());
25051 return(1 || funcname || hash || result7 || libp) ;
25052}
25053
25054static int G__RootEventData_rootcint_513_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25055{
25056 G__letint(result7, 115, (long) TDisTrack::Class_Version());
25057 return(1 || funcname || hash || result7 || libp) ;
25058}
25059
25060static int G__RootEventData_rootcint_513_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25061{
25062 TDisTrack::Dictionary();
25063 G__setnull(result7);
25064 return(1 || funcname || hash || result7 || libp) ;
25065}
25066
25067static int G__RootEventData_rootcint_513_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25068{
25069 ((TDisTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25070 G__setnull(result7);
25071 return(1 || funcname || hash || result7 || libp) ;
25072}
25073
25074static int G__RootEventData_rootcint_513_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25075{
25076 G__letint(result7, 67, (long) TDisTrack::DeclFileName());
25077 return(1 || funcname || hash || result7 || libp) ;
25078}
25079
25080static int G__RootEventData_rootcint_513_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25081{
25082 G__letint(result7, 105, (long) TDisTrack::ImplFileLine());
25083 return(1 || funcname || hash || result7 || libp) ;
25084}
25085
25086static int G__RootEventData_rootcint_513_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25087{
25088 G__letint(result7, 67, (long) TDisTrack::ImplFileName());
25089 return(1 || funcname || hash || result7 || libp) ;
25090}
25091
25092static int G__RootEventData_rootcint_513_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25093{
25094 G__letint(result7, 105, (long) TDisTrack::DeclFileLine());
25095 return(1 || funcname || hash || result7 || libp) ;
25096}
25097
25098// automatic copy constructor
25099static int G__RootEventData_rootcint_513_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25100
25101{
25102 TDisTrack* p;
25103 void* tmp = (void*) G__int(libp->para[0]);
25104 p = new TDisTrack(*(TDisTrack*) tmp);
25105 result7->obj.i = (long) p;
25106 result7->ref = (long) p;
25107 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
25108 return(1 || funcname || hash || result7 || libp) ;
25109}
25110
25111// automatic destructor
25112typedef TDisTrack G__TTDisTrack;
25113static int G__RootEventData_rootcint_513_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25114{
25115 char* gvp = (char*) G__getgvp();
25116 long soff = G__getstructoffset();
25117 int n = G__getaryconstruct();
25118 //
25119 //has_a_delete: 1
25120 //has_own_delete1arg: 0
25121 //has_own_delete2arg: 0
25122 //
25123 if (!soff) {
25124 return(1);
25125 }
25126 if (n) {
25127 if (gvp == (char*)G__PVOID) {
25128 delete[] (TDisTrack*) soff;
25129 } else {
25130 G__setgvp((long) G__PVOID);
25131 for (int i = n - 1; i >= 0; --i) {
25132 ((TDisTrack*) (soff+(sizeof(TDisTrack)*i)))->~G__TTDisTrack();
25133 }
25134 G__setgvp((long)gvp);
25135 }
25136 } else {
25137 if (gvp == (char*)G__PVOID) {
25138 delete (TDisTrack*) soff;
25139 } else {
25140 G__setgvp((long) G__PVOID);
25141 ((TDisTrack*) (soff))->~G__TTDisTrack();
25142 G__setgvp((long)gvp);
25143 }
25144 }
25145 G__setnull(result7);
25146 return(1 || funcname || hash || result7 || libp) ;
25147}
25148
25149// automatic assignment operator
25150static int G__RootEventData_rootcint_513_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25151{
25152 TDisTrack* dest = (TDisTrack*) G__getstructoffset();
25153 *dest = *(TDisTrack*) libp->para[0].ref;
25154 const TDisTrack& obj = *dest;
25155 result7->ref = (long) (&obj);
25156 result7->obj.i = (long) (&obj);
25157 return(1 || funcname || hash || result7 || libp) ;
25158}
25159
25160
25161/* TEvtRecEvent */
25162static int G__RootEventData_rootcint_514_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25163{
25164 TEvtRecEvent* p = NULL;
25165 char* gvp = (char*) G__getgvp();
25166 int n = G__getaryconstruct();
25167 if (n) {
25168 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25169 p = new TEvtRecEvent[n];
25170 } else {
25171 p = new((void*) gvp) TEvtRecEvent[n];
25172 }
25173 } else {
25174 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25175 p = new TEvtRecEvent;
25176 } else {
25177 p = new((void*) gvp) TEvtRecEvent;
25178 }
25179 }
25180 result7->obj.i = (long) p;
25181 result7->ref = (long) p;
25182 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
25183 return(1 || funcname || hash || result7 || libp) ;
25184}
25185
25186static int G__RootEventData_rootcint_514_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25187{
25188 ((TEvtRecEvent*) G__getstructoffset())->initialize();
25189 G__setnull(result7);
25190 return(1 || funcname || hash || result7 || libp) ;
25191}
25192
25193static int G__RootEventData_rootcint_514_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25194{
25195 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalTracks());
25196 return(1 || funcname || hash || result7 || libp) ;
25197}
25198
25199static int G__RootEventData_rootcint_514_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25200{
25201 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalCharged());
25202 return(1 || funcname || hash || result7 || libp) ;
25203}
25204
25205static int G__RootEventData_rootcint_514_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25206{
25207 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalNeutral());
25208 return(1 || funcname || hash || result7 || libp) ;
25209}
25210
25211static int G__RootEventData_rootcint_514_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25212{
25213 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfVee());
25214 return(1 || funcname || hash || result7 || libp) ;
25215}
25216
25217static int G__RootEventData_rootcint_514_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25218{
25219 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfPi0());
25220 return(1 || funcname || hash || result7 || libp) ;
25221}
25222
25223static int G__RootEventData_rootcint_514_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25224{
25225 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfEtaToGG());
25226 return(1 || funcname || hash || result7 || libp) ;
25227}
25228
25229static int G__RootEventData_rootcint_514_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25230{
25231 G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfDTag());
25232 return(1 || funcname || hash || result7 || libp) ;
25233}
25234
25235static int G__RootEventData_rootcint_514_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25236{
25237 ((TEvtRecEvent*) G__getstructoffset())->setTotalTracks((const int) G__int(libp->para[0]));
25238 G__setnull(result7);
25239 return(1 || funcname || hash || result7 || libp) ;
25240}
25241
25242static int G__RootEventData_rootcint_514_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25243{
25244 ((TEvtRecEvent*) G__getstructoffset())->setTotalCharged((const int) G__int(libp->para[0]));
25245 G__setnull(result7);
25246 return(1 || funcname || hash || result7 || libp) ;
25247}
25248
25249static int G__RootEventData_rootcint_514_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25250{
25251 ((TEvtRecEvent*) G__getstructoffset())->setTotalNeutral((const int) G__int(libp->para[0]));
25252 G__setnull(result7);
25253 return(1 || funcname || hash || result7 || libp) ;
25254}
25255
25256static int G__RootEventData_rootcint_514_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25257{
25258 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfVee((const int) G__int(libp->para[0]));
25259 G__setnull(result7);
25260 return(1 || funcname || hash || result7 || libp) ;
25261}
25262
25263static int G__RootEventData_rootcint_514_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25264{
25265 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfPi0((const int) G__int(libp->para[0]));
25266 G__setnull(result7);
25267 return(1 || funcname || hash || result7 || libp) ;
25268}
25269
25270static int G__RootEventData_rootcint_514_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25271{
25272 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfEtaToGG((const int) G__int(libp->para[0]));
25273 G__setnull(result7);
25274 return(1 || funcname || hash || result7 || libp) ;
25275}
25276
25277static int G__RootEventData_rootcint_514_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25278{
25279 ((TEvtRecEvent*) G__getstructoffset())->setNumberOfDTag((const int) G__int(libp->para[0]));
25280 G__setnull(result7);
25281 return(1 || funcname || hash || result7 || libp) ;
25282}
25283
25284static int G__RootEventData_rootcint_514_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25285{
25286 G__letint(result7, 85, (long) TEvtRecEvent::Class());
25287 return(1 || funcname || hash || result7 || libp) ;
25288}
25289
25290static int G__RootEventData_rootcint_514_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25291{
25292 G__letint(result7, 67, (long) TEvtRecEvent::Class_Name());
25293 return(1 || funcname || hash || result7 || libp) ;
25294}
25295
25296static int G__RootEventData_rootcint_514_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25297{
25298 G__letint(result7, 115, (long) TEvtRecEvent::Class_Version());
25299 return(1 || funcname || hash || result7 || libp) ;
25300}
25301
25302static int G__RootEventData_rootcint_514_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25303{
25304 TEvtRecEvent::Dictionary();
25305 G__setnull(result7);
25306 return(1 || funcname || hash || result7 || libp) ;
25307}
25308
25309static int G__RootEventData_rootcint_514_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25310{
25311 ((TEvtRecEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25312 G__setnull(result7);
25313 return(1 || funcname || hash || result7 || libp) ;
25314}
25315
25316static int G__RootEventData_rootcint_514_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25317{
25318 G__letint(result7, 67, (long) TEvtRecEvent::DeclFileName());
25319 return(1 || funcname || hash || result7 || libp) ;
25320}
25321
25322static int G__RootEventData_rootcint_514_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25323{
25324 G__letint(result7, 105, (long) TEvtRecEvent::ImplFileLine());
25325 return(1 || funcname || hash || result7 || libp) ;
25326}
25327
25328static int G__RootEventData_rootcint_514_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25329{
25330 G__letint(result7, 67, (long) TEvtRecEvent::ImplFileName());
25331 return(1 || funcname || hash || result7 || libp) ;
25332}
25333
25334static int G__RootEventData_rootcint_514_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25335{
25336 G__letint(result7, 105, (long) TEvtRecEvent::DeclFileLine());
25337 return(1 || funcname || hash || result7 || libp) ;
25338}
25339
25340// automatic copy constructor
25341static int G__RootEventData_rootcint_514_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25342
25343{
25344 TEvtRecEvent* p;
25345 void* tmp = (void*) G__int(libp->para[0]);
25346 p = new TEvtRecEvent(*(TEvtRecEvent*) tmp);
25347 result7->obj.i = (long) p;
25348 result7->ref = (long) p;
25349 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
25350 return(1 || funcname || hash || result7 || libp) ;
25351}
25352
25353// automatic destructor
25354typedef TEvtRecEvent G__TTEvtRecEvent;
25355static int G__RootEventData_rootcint_514_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25356{
25357 char* gvp = (char*) G__getgvp();
25358 long soff = G__getstructoffset();
25359 int n = G__getaryconstruct();
25360 //
25361 //has_a_delete: 1
25362 //has_own_delete1arg: 0
25363 //has_own_delete2arg: 0
25364 //
25365 if (!soff) {
25366 return(1);
25367 }
25368 if (n) {
25369 if (gvp == (char*)G__PVOID) {
25370 delete[] (TEvtRecEvent*) soff;
25371 } else {
25372 G__setgvp((long) G__PVOID);
25373 for (int i = n - 1; i >= 0; --i) {
25374 ((TEvtRecEvent*) (soff+(sizeof(TEvtRecEvent)*i)))->~G__TTEvtRecEvent();
25375 }
25376 G__setgvp((long)gvp);
25377 }
25378 } else {
25379 if (gvp == (char*)G__PVOID) {
25380 delete (TEvtRecEvent*) soff;
25381 } else {
25382 G__setgvp((long) G__PVOID);
25383 ((TEvtRecEvent*) (soff))->~G__TTEvtRecEvent();
25384 G__setgvp((long)gvp);
25385 }
25386 }
25387 G__setnull(result7);
25388 return(1 || funcname || hash || result7 || libp) ;
25389}
25390
25391// automatic assignment operator
25392static int G__RootEventData_rootcint_514_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25393{
25394 TEvtRecEvent* dest = (TEvtRecEvent*) G__getstructoffset();
25395 *dest = *(TEvtRecEvent*) libp->para[0].ref;
25396 const TEvtRecEvent& obj = *dest;
25397 result7->ref = (long) (&obj);
25398 result7->obj.i = (long) (&obj);
25399 return(1 || funcname || hash || result7 || libp) ;
25400}
25401
25402
25403/* TEvtRecTrack */
25404static int G__RootEventData_rootcint_515_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25405{
25406 TEvtRecTrack* p = NULL;
25407 char* gvp = (char*) G__getgvp();
25408 int n = G__getaryconstruct();
25409 if (n) {
25410 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25411 p = new TEvtRecTrack[n];
25412 } else {
25413 p = new((void*) gvp) TEvtRecTrack[n];
25414 }
25415 } else {
25416 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25417 p = new TEvtRecTrack;
25418 } else {
25419 p = new((void*) gvp) TEvtRecTrack;
25420 }
25421 }
25422 result7->obj.i = (long) p;
25423 result7->ref = (long) p;
25424 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
25425 return(1 || funcname || hash || result7 || libp) ;
25426}
25427
25428static int G__RootEventData_rootcint_515_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25429{
25430 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->trackId());
25431 return(1 || funcname || hash || result7 || libp) ;
25432}
25433
25434static int G__RootEventData_rootcint_515_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25435{
25436 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->partId());
25437 return(1 || funcname || hash || result7 || libp) ;
25438}
25439
25440static int G__RootEventData_rootcint_515_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25441{
25442 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->quality());
25443 return(1 || funcname || hash || result7 || libp) ;
25444}
25445
25446static int G__RootEventData_rootcint_515_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25447{
25448 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcTrackId());
25449 return(1 || funcname || hash || result7 || libp) ;
25450}
25451
25452static int G__RootEventData_rootcint_515_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25453{
25454 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcKalTrackId());
25455 return(1 || funcname || hash || result7 || libp) ;
25456}
25457
25458static int G__RootEventData_rootcint_515_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25459{
25460 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcDedxId());
25461 return(1 || funcname || hash || result7 || libp) ;
25462}
25463
25464static int G__RootEventData_rootcint_515_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25465{
25466 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->extTrackId());
25467 return(1 || funcname || hash || result7 || libp) ;
25468}
25469
25470static int G__RootEventData_rootcint_515_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25471{
25472 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->emcShowerId());
25473 return(1 || funcname || hash || result7 || libp) ;
25474}
25475
25476static int G__RootEventData_rootcint_515_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25477{
25478 G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mucTrackId());
25479 return(1 || funcname || hash || result7 || libp) ;
25480}
25481
25482static int G__RootEventData_rootcint_515_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25483{
25484 {
25485 const vector<Int_t>& obj = ((const TEvtRecTrack*) G__getstructoffset())->tofTrackIds();
25486 result7->ref = (long) (&obj);
25487 result7->obj.i = (long) (&obj);
25488 }
25489 return(1 || funcname || hash || result7 || libp) ;
25490}
25491
25492static int G__RootEventData_rootcint_515_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25493{
25494 ((TEvtRecTrack*) G__getstructoffset())->setTrackId((const int) G__int(libp->para[0]));
25495 G__setnull(result7);
25496 return(1 || funcname || hash || result7 || libp) ;
25497}
25498
25499static int G__RootEventData_rootcint_515_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25500{
25501 ((TEvtRecTrack*) G__getstructoffset())->setPartId((const int) G__int(libp->para[0]));
25502 G__setnull(result7);
25503 return(1 || funcname || hash || result7 || libp) ;
25504}
25505
25506static int G__RootEventData_rootcint_515_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25507{
25508 ((TEvtRecTrack*) G__getstructoffset())->setQuality((const int) G__int(libp->para[0]));
25509 G__setnull(result7);
25510 return(1 || funcname || hash || result7 || libp) ;
25511}
25512
25513static int G__RootEventData_rootcint_515_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25514{
25515 ((TEvtRecTrack*) G__getstructoffset())->setMdcTrackId((const int) G__int(libp->para[0]));
25516 G__setnull(result7);
25517 return(1 || funcname || hash || result7 || libp) ;
25518}
25519
25520static int G__RootEventData_rootcint_515_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25521{
25522 ((TEvtRecTrack*) G__getstructoffset())->setMdcKalTrackId((const int) G__int(libp->para[0]));
25523 G__setnull(result7);
25524 return(1 || funcname || hash || result7 || libp) ;
25525}
25526
25527static int G__RootEventData_rootcint_515_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25528{
25529 ((TEvtRecTrack*) G__getstructoffset())->setMdcDedxId((const int) G__int(libp->para[0]));
25530 G__setnull(result7);
25531 return(1 || funcname || hash || result7 || libp) ;
25532}
25533
25534static int G__RootEventData_rootcint_515_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25535{
25536 ((TEvtRecTrack*) G__getstructoffset())->setExtTrackId((const int) G__int(libp->para[0]));
25537 G__setnull(result7);
25538 return(1 || funcname || hash || result7 || libp) ;
25539}
25540
25541static int G__RootEventData_rootcint_515_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25542{
25543 ((TEvtRecTrack*) G__getstructoffset())->setEmcShowerId((const int) G__int(libp->para[0]));
25544 G__setnull(result7);
25545 return(1 || funcname || hash || result7 || libp) ;
25546}
25547
25548static int G__RootEventData_rootcint_515_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25549{
25550 ((TEvtRecTrack*) G__getstructoffset())->setMucTrackId((const int) G__int(libp->para[0]));
25551 G__setnull(result7);
25552 return(1 || funcname || hash || result7 || libp) ;
25553}
25554
25555static int G__RootEventData_rootcint_515_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25556{
25557 ((TEvtRecTrack*) G__getstructoffset())->setTofTrackIds(*(vector<Int_t>*) libp->para[0].ref);
25558 G__setnull(result7);
25559 return(1 || funcname || hash || result7 || libp) ;
25560}
25561
25562static int G__RootEventData_rootcint_515_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25563{
25564 ((TEvtRecTrack*) G__getstructoffset())->addTofTrackId((const int) G__int(libp->para[0]));
25565 G__setnull(result7);
25566 return(1 || funcname || hash || result7 || libp) ;
25567}
25568
25569static int G__RootEventData_rootcint_515_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25570{
25571 G__letint(result7, 85, (long) TEvtRecTrack::Class());
25572 return(1 || funcname || hash || result7 || libp) ;
25573}
25574
25575static int G__RootEventData_rootcint_515_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25576{
25577 G__letint(result7, 67, (long) TEvtRecTrack::Class_Name());
25578 return(1 || funcname || hash || result7 || libp) ;
25579}
25580
25581static int G__RootEventData_rootcint_515_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25582{
25583 G__letint(result7, 115, (long) TEvtRecTrack::Class_Version());
25584 return(1 || funcname || hash || result7 || libp) ;
25585}
25586
25587static int G__RootEventData_rootcint_515_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25588{
25589 TEvtRecTrack::Dictionary();
25590 G__setnull(result7);
25591 return(1 || funcname || hash || result7 || libp) ;
25592}
25593
25594static int G__RootEventData_rootcint_515_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25595{
25596 ((TEvtRecTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25597 G__setnull(result7);
25598 return(1 || funcname || hash || result7 || libp) ;
25599}
25600
25601static int G__RootEventData_rootcint_515_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25602{
25603 G__letint(result7, 67, (long) TEvtRecTrack::DeclFileName());
25604 return(1 || funcname || hash || result7 || libp) ;
25605}
25606
25607static int G__RootEventData_rootcint_515_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25608{
25609 G__letint(result7, 105, (long) TEvtRecTrack::ImplFileLine());
25610 return(1 || funcname || hash || result7 || libp) ;
25611}
25612
25613static int G__RootEventData_rootcint_515_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25614{
25615 G__letint(result7, 67, (long) TEvtRecTrack::ImplFileName());
25616 return(1 || funcname || hash || result7 || libp) ;
25617}
25618
25619static int G__RootEventData_rootcint_515_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25620{
25621 G__letint(result7, 105, (long) TEvtRecTrack::DeclFileLine());
25622 return(1 || funcname || hash || result7 || libp) ;
25623}
25624
25625// automatic copy constructor
25626static int G__RootEventData_rootcint_515_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25627
25628{
25629 TEvtRecTrack* p;
25630 void* tmp = (void*) G__int(libp->para[0]);
25631 p = new TEvtRecTrack(*(TEvtRecTrack*) tmp);
25632 result7->obj.i = (long) p;
25633 result7->ref = (long) p;
25634 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
25635 return(1 || funcname || hash || result7 || libp) ;
25636}
25637
25638// automatic destructor
25639typedef TEvtRecTrack G__TTEvtRecTrack;
25640static int G__RootEventData_rootcint_515_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25641{
25642 char* gvp = (char*) G__getgvp();
25643 long soff = G__getstructoffset();
25644 int n = G__getaryconstruct();
25645 //
25646 //has_a_delete: 1
25647 //has_own_delete1arg: 0
25648 //has_own_delete2arg: 0
25649 //
25650 if (!soff) {
25651 return(1);
25652 }
25653 if (n) {
25654 if (gvp == (char*)G__PVOID) {
25655 delete[] (TEvtRecTrack*) soff;
25656 } else {
25657 G__setgvp((long) G__PVOID);
25658 for (int i = n - 1; i >= 0; --i) {
25659 ((TEvtRecTrack*) (soff+(sizeof(TEvtRecTrack)*i)))->~G__TTEvtRecTrack();
25660 }
25661 G__setgvp((long)gvp);
25662 }
25663 } else {
25664 if (gvp == (char*)G__PVOID) {
25665 delete (TEvtRecTrack*) soff;
25666 } else {
25667 G__setgvp((long) G__PVOID);
25668 ((TEvtRecTrack*) (soff))->~G__TTEvtRecTrack();
25669 G__setgvp((long)gvp);
25670 }
25671 }
25672 G__setnull(result7);
25673 return(1 || funcname || hash || result7 || libp) ;
25674}
25675
25676// automatic assignment operator
25677static int G__RootEventData_rootcint_515_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25678{
25679 TEvtRecTrack* dest = (TEvtRecTrack*) G__getstructoffset();
25680 *dest = *(TEvtRecTrack*) libp->para[0].ref;
25681 const TEvtRecTrack& obj = *dest;
25682 result7->ref = (long) (&obj);
25683 result7->obj.i = (long) (&obj);
25684 return(1 || funcname || hash || result7 || libp) ;
25685}
25686
25687
25688/* TEvtRecPrimaryVertex */
25689static int G__RootEventData_rootcint_516_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25690{
25691 TEvtRecPrimaryVertex* p = NULL;
25692 char* gvp = (char*) G__getgvp();
25693 int n = G__getaryconstruct();
25694 if (n) {
25695 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25696 p = new TEvtRecPrimaryVertex[n];
25697 } else {
25698 p = new((void*) gvp) TEvtRecPrimaryVertex[n];
25699 }
25700 } else {
25701 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25702 p = new TEvtRecPrimaryVertex;
25703 } else {
25704 p = new((void*) gvp) TEvtRecPrimaryVertex;
25705 }
25706 }
25707 result7->obj.i = (long) p;
25708 result7->ref = (long) p;
25709 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
25710 return(1 || funcname || hash || result7 || libp) ;
25711}
25712
25713static int G__RootEventData_rootcint_516_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25714{
25715 G__letint(result7, 103, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->isValid());
25716 return(1 || funcname || hash || result7 || libp) ;
25717}
25718
25719static int G__RootEventData_rootcint_516_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25720{
25721 G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->nTracks());
25722 return(1 || funcname || hash || result7 || libp) ;
25723}
25724
25725static int G__RootEventData_rootcint_516_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25726{
25727 {
25728 const vector<Int_t>& obj = ((const TEvtRecPrimaryVertex*) G__getstructoffset())->trackIdList();
25729 result7->ref = (long) (&obj);
25730 result7->obj.i = (long) (&obj);
25731 }
25732 return(1 || funcname || hash || result7 || libp) ;
25733}
25734
25735static int G__RootEventData_rootcint_516_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25736{
25737 G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->chi2());
25738 return(1 || funcname || hash || result7 || libp) ;
25739}
25740
25741static int G__RootEventData_rootcint_516_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25742{
25743 G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->ndof());
25744 return(1 || funcname || hash || result7 || libp) ;
25745}
25746
25747static int G__RootEventData_rootcint_516_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25748{
25749 G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->fitMethod());
25750 return(1 || funcname || hash || result7 || libp) ;
25751}
25752
25753static int G__RootEventData_rootcint_516_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25754{
25755 G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->vertex((Int_t) G__int(libp->para[0])));
25756 return(1 || funcname || hash || result7 || libp) ;
25757}
25758
25759static int G__RootEventData_rootcint_516_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25760{
25761 G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->errorVertex((Int_t) G__int(libp->para[0])));
25762 return(1 || funcname || hash || result7 || libp) ;
25763}
25764
25765static int G__RootEventData_rootcint_516_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25766{
25767 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setIsValid((Bool_t) G__int(libp->para[0]));
25768 G__setnull(result7);
25769 return(1 || funcname || hash || result7 || libp) ;
25770}
25771
25772static int G__RootEventData_rootcint_516_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25773{
25774 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setNTracks((Int_t) G__int(libp->para[0]));
25775 G__setnull(result7);
25776 return(1 || funcname || hash || result7 || libp) ;
25777}
25778
25779static int G__RootEventData_rootcint_516_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25780{
25781 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setTrackIdList(*(vector<Int_t>*) libp->para[0].ref);
25782 G__setnull(result7);
25783 return(1 || funcname || hash || result7 || libp) ;
25784}
25785
25786static int G__RootEventData_rootcint_516_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25787{
25788 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
25789 G__setnull(result7);
25790 return(1 || funcname || hash || result7 || libp) ;
25791}
25792
25793static int G__RootEventData_rootcint_516_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25794{
25795 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setNdof((Int_t) G__int(libp->para[0]));
25796 G__setnull(result7);
25797 return(1 || funcname || hash || result7 || libp) ;
25798}
25799
25800static int G__RootEventData_rootcint_516_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25801{
25802 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setFitMethod((Int_t) G__int(libp->para[0]));
25803 G__setnull(result7);
25804 return(1 || funcname || hash || result7 || libp) ;
25805}
25806
25807static int G__RootEventData_rootcint_516_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25808{
25809 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setVertex((Double_t*) G__int(libp->para[0]));
25810 G__setnull(result7);
25811 return(1 || funcname || hash || result7 || libp) ;
25812}
25813
25814static int G__RootEventData_rootcint_516_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25815{
25816 ((TEvtRecPrimaryVertex*) G__getstructoffset())->setErrorVertex((Double_t*) G__int(libp->para[0]));
25817 G__setnull(result7);
25818 return(1 || funcname || hash || result7 || libp) ;
25819}
25820
25821static int G__RootEventData_rootcint_516_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25822{
25823 G__letint(result7, 85, (long) TEvtRecPrimaryVertex::Class());
25824 return(1 || funcname || hash || result7 || libp) ;
25825}
25826
25827static int G__RootEventData_rootcint_516_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25828{
25829 G__letint(result7, 67, (long) TEvtRecPrimaryVertex::Class_Name());
25830 return(1 || funcname || hash || result7 || libp) ;
25831}
25832
25833static int G__RootEventData_rootcint_516_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25834{
25835 G__letint(result7, 115, (long) TEvtRecPrimaryVertex::Class_Version());
25836 return(1 || funcname || hash || result7 || libp) ;
25837}
25838
25839static int G__RootEventData_rootcint_516_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25840{
25841 TEvtRecPrimaryVertex::Dictionary();
25842 G__setnull(result7);
25843 return(1 || funcname || hash || result7 || libp) ;
25844}
25845
25846static int G__RootEventData_rootcint_516_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25847{
25848 ((TEvtRecPrimaryVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
25849 G__setnull(result7);
25850 return(1 || funcname || hash || result7 || libp) ;
25851}
25852
25853static int G__RootEventData_rootcint_516_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25854{
25855 G__letint(result7, 67, (long) TEvtRecPrimaryVertex::DeclFileName());
25856 return(1 || funcname || hash || result7 || libp) ;
25857}
25858
25859static int G__RootEventData_rootcint_516_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25860{
25861 G__letint(result7, 105, (long) TEvtRecPrimaryVertex::ImplFileLine());
25862 return(1 || funcname || hash || result7 || libp) ;
25863}
25864
25865static int G__RootEventData_rootcint_516_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25866{
25867 G__letint(result7, 67, (long) TEvtRecPrimaryVertex::ImplFileName());
25868 return(1 || funcname || hash || result7 || libp) ;
25869}
25870
25871static int G__RootEventData_rootcint_516_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25872{
25873 G__letint(result7, 105, (long) TEvtRecPrimaryVertex::DeclFileLine());
25874 return(1 || funcname || hash || result7 || libp) ;
25875}
25876
25877// automatic copy constructor
25878static int G__RootEventData_rootcint_516_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25879
25880{
25881 TEvtRecPrimaryVertex* p;
25882 void* tmp = (void*) G__int(libp->para[0]);
25883 p = new TEvtRecPrimaryVertex(*(TEvtRecPrimaryVertex*) tmp);
25884 result7->obj.i = (long) p;
25885 result7->ref = (long) p;
25886 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
25887 return(1 || funcname || hash || result7 || libp) ;
25888}
25889
25890// automatic destructor
25891typedef TEvtRecPrimaryVertex G__TTEvtRecPrimaryVertex;
25892static int G__RootEventData_rootcint_516_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25893{
25894 char* gvp = (char*) G__getgvp();
25895 long soff = G__getstructoffset();
25896 int n = G__getaryconstruct();
25897 //
25898 //has_a_delete: 1
25899 //has_own_delete1arg: 0
25900 //has_own_delete2arg: 0
25901 //
25902 if (!soff) {
25903 return(1);
25904 }
25905 if (n) {
25906 if (gvp == (char*)G__PVOID) {
25907 delete[] (TEvtRecPrimaryVertex*) soff;
25908 } else {
25909 G__setgvp((long) G__PVOID);
25910 for (int i = n - 1; i >= 0; --i) {
25911 ((TEvtRecPrimaryVertex*) (soff+(sizeof(TEvtRecPrimaryVertex)*i)))->~G__TTEvtRecPrimaryVertex();
25912 }
25913 G__setgvp((long)gvp);
25914 }
25915 } else {
25916 if (gvp == (char*)G__PVOID) {
25917 delete (TEvtRecPrimaryVertex*) soff;
25918 } else {
25919 G__setgvp((long) G__PVOID);
25920 ((TEvtRecPrimaryVertex*) (soff))->~G__TTEvtRecPrimaryVertex();
25921 G__setgvp((long)gvp);
25922 }
25923 }
25924 G__setnull(result7);
25925 return(1 || funcname || hash || result7 || libp) ;
25926}
25927
25928// automatic assignment operator
25929static int G__RootEventData_rootcint_516_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25930{
25931 TEvtRecPrimaryVertex* dest = (TEvtRecPrimaryVertex*) G__getstructoffset();
25932 *dest = *(TEvtRecPrimaryVertex*) libp->para[0].ref;
25933 const TEvtRecPrimaryVertex& obj = *dest;
25934 result7->ref = (long) (&obj);
25935 result7->obj.i = (long) (&obj);
25936 return(1 || funcname || hash || result7 || libp) ;
25937}
25938
25939
25940/* TEvtRecVeeVertex */
25941static int G__RootEventData_rootcint_517_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25942{
25943 TEvtRecVeeVertex* p = NULL;
25944 char* gvp = (char*) G__getgvp();
25945 int n = G__getaryconstruct();
25946 if (n) {
25947 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25948 p = new TEvtRecVeeVertex[n];
25949 } else {
25950 p = new((void*) gvp) TEvtRecVeeVertex[n];
25951 }
25952 } else {
25953 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
25954 p = new TEvtRecVeeVertex;
25955 } else {
25956 p = new((void*) gvp) TEvtRecVeeVertex;
25957 }
25958 }
25959 result7->obj.i = (long) p;
25960 result7->ref = (long) p;
25961 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
25962 return(1 || funcname || hash || result7 || libp) ;
25963}
25964
25965static int G__RootEventData_rootcint_517_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25966{
25967 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->vertexId());
25968 return(1 || funcname || hash || result7 || libp) ;
25969}
25970
25971static int G__RootEventData_rootcint_517_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25972{
25973 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->vertexType());
25974 return(1 || funcname || hash || result7 || libp) ;
25975}
25976
25977static int G__RootEventData_rootcint_517_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25978{
25979 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->chi2());
25980 return(1 || funcname || hash || result7 || libp) ;
25981}
25982
25983static int G__RootEventData_rootcint_517_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25984{
25985 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->ndof());
25986 return(1 || funcname || hash || result7 || libp) ;
25987}
25988
25989static int G__RootEventData_rootcint_517_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25990{
25991 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->mass());
25992 return(1 || funcname || hash || result7 || libp) ;
25993}
25994
25995static int G__RootEventData_rootcint_517_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
25996{
25997 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->w((Int_t) G__int(libp->para[0])));
25998 return(1 || funcname || hash || result7 || libp) ;
25999}
26000
26001static int G__RootEventData_rootcint_517_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26002{
26003 G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->Ew((Int_t) G__int(libp->para[0])));
26004 return(1 || funcname || hash || result7 || libp) ;
26005}
26006
26007static int G__RootEventData_rootcint_517_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26008{
26009 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->pair((Int_t) G__int(libp->para[0])));
26010 return(1 || funcname || hash || result7 || libp) ;
26011}
26012
26013static int G__RootEventData_rootcint_517_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26014{
26015 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->nCharge());
26016 return(1 || funcname || hash || result7 || libp) ;
26017}
26018
26019static int G__RootEventData_rootcint_517_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26020{
26021 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->nTracks());
26022 return(1 || funcname || hash || result7 || libp) ;
26023}
26024
26025static int G__RootEventData_rootcint_517_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26026{
26027 G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->daughter((Int_t) G__int(libp->para[0])));
26028 return(1 || funcname || hash || result7 || libp) ;
26029}
26030
26031static int G__RootEventData_rootcint_517_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26032{
26033 ((TEvtRecVeeVertex*) G__getstructoffset())->setVertexId((Int_t) G__int(libp->para[0]));
26034 G__setnull(result7);
26035 return(1 || funcname || hash || result7 || libp) ;
26036}
26037
26038static int G__RootEventData_rootcint_517_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26039{
26040 ((TEvtRecVeeVertex*) G__getstructoffset())->setVertexType((Int_t) G__int(libp->para[0]));
26041 G__setnull(result7);
26042 return(1 || funcname || hash || result7 || libp) ;
26043}
26044
26045static int G__RootEventData_rootcint_517_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26046{
26047 ((TEvtRecVeeVertex*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
26048 G__setnull(result7);
26049 return(1 || funcname || hash || result7 || libp) ;
26050}
26051
26052static int G__RootEventData_rootcint_517_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26053{
26054 ((TEvtRecVeeVertex*) G__getstructoffset())->setNdof((Int_t) G__int(libp->para[0]));
26055 G__setnull(result7);
26056 return(1 || funcname || hash || result7 || libp) ;
26057}
26058
26059static int G__RootEventData_rootcint_517_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26060{
26061 ((TEvtRecVeeVertex*) G__getstructoffset())->setMass((Double_t) G__double(libp->para[0]));
26062 G__setnull(result7);
26063 return(1 || funcname || hash || result7 || libp) ;
26064}
26065
26066static int G__RootEventData_rootcint_517_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26067{
26068 ((TEvtRecVeeVertex*) G__getstructoffset())->setW((Double_t*) G__int(libp->para[0]));
26069 G__setnull(result7);
26070 return(1 || funcname || hash || result7 || libp) ;
26071}
26072
26073static int G__RootEventData_rootcint_517_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26074{
26075 ((TEvtRecVeeVertex*) G__getstructoffset())->setEw((Double_t*) G__int(libp->para[0]));
26076 G__setnull(result7);
26077 return(1 || funcname || hash || result7 || libp) ;
26078}
26079
26080static int G__RootEventData_rootcint_517_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26081{
26082 ((TEvtRecVeeVertex*) G__getstructoffset())->setPair((Int_t*) G__int(libp->para[0]));
26083 G__setnull(result7);
26084 return(1 || funcname || hash || result7 || libp) ;
26085}
26086
26087static int G__RootEventData_rootcint_517_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26088{
26089 ((TEvtRecVeeVertex*) G__getstructoffset())->setNCharge((Int_t) G__int(libp->para[0]));
26090 G__setnull(result7);
26091 return(1 || funcname || hash || result7 || libp) ;
26092}
26093
26094static int G__RootEventData_rootcint_517_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26095{
26096 ((TEvtRecVeeVertex*) G__getstructoffset())->setNTracks((Int_t) G__int(libp->para[0]));
26097 G__setnull(result7);
26098 return(1 || funcname || hash || result7 || libp) ;
26099}
26100
26101static int G__RootEventData_rootcint_517_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26102{
26103 ((TEvtRecVeeVertex*) G__getstructoffset())->setDaughter((Int_t*) G__int(libp->para[0]));
26104 G__setnull(result7);
26105 return(1 || funcname || hash || result7 || libp) ;
26106}
26107
26108static int G__RootEventData_rootcint_517_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26109{
26110 G__letint(result7, 85, (long) TEvtRecVeeVertex::Class());
26111 return(1 || funcname || hash || result7 || libp) ;
26112}
26113
26114static int G__RootEventData_rootcint_517_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26115{
26116 G__letint(result7, 67, (long) TEvtRecVeeVertex::Class_Name());
26117 return(1 || funcname || hash || result7 || libp) ;
26118}
26119
26120static int G__RootEventData_rootcint_517_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26121{
26122 G__letint(result7, 115, (long) TEvtRecVeeVertex::Class_Version());
26123 return(1 || funcname || hash || result7 || libp) ;
26124}
26125
26126static int G__RootEventData_rootcint_517_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26127{
26128 TEvtRecVeeVertex::Dictionary();
26129 G__setnull(result7);
26130 return(1 || funcname || hash || result7 || libp) ;
26131}
26132
26133static int G__RootEventData_rootcint_517_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26134{
26135 ((TEvtRecVeeVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
26136 G__setnull(result7);
26137 return(1 || funcname || hash || result7 || libp) ;
26138}
26139
26140static int G__RootEventData_rootcint_517_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26141{
26142 G__letint(result7, 67, (long) TEvtRecVeeVertex::DeclFileName());
26143 return(1 || funcname || hash || result7 || libp) ;
26144}
26145
26146static int G__RootEventData_rootcint_517_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26147{
26148 G__letint(result7, 105, (long) TEvtRecVeeVertex::ImplFileLine());
26149 return(1 || funcname || hash || result7 || libp) ;
26150}
26151
26152static int G__RootEventData_rootcint_517_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26153{
26154 G__letint(result7, 67, (long) TEvtRecVeeVertex::ImplFileName());
26155 return(1 || funcname || hash || result7 || libp) ;
26156}
26157
26158static int G__RootEventData_rootcint_517_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26159{
26160 G__letint(result7, 105, (long) TEvtRecVeeVertex::DeclFileLine());
26161 return(1 || funcname || hash || result7 || libp) ;
26162}
26163
26164// automatic copy constructor
26165static int G__RootEventData_rootcint_517_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26166
26167{
26168 TEvtRecVeeVertex* p;
26169 void* tmp = (void*) G__int(libp->para[0]);
26170 p = new TEvtRecVeeVertex(*(TEvtRecVeeVertex*) tmp);
26171 result7->obj.i = (long) p;
26172 result7->ref = (long) p;
26173 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
26174 return(1 || funcname || hash || result7 || libp) ;
26175}
26176
26177// automatic destructor
26178typedef TEvtRecVeeVertex G__TTEvtRecVeeVertex;
26179static int G__RootEventData_rootcint_517_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26180{
26181 char* gvp = (char*) G__getgvp();
26182 long soff = G__getstructoffset();
26183 int n = G__getaryconstruct();
26184 //
26185 //has_a_delete: 1
26186 //has_own_delete1arg: 0
26187 //has_own_delete2arg: 0
26188 //
26189 if (!soff) {
26190 return(1);
26191 }
26192 if (n) {
26193 if (gvp == (char*)G__PVOID) {
26194 delete[] (TEvtRecVeeVertex*) soff;
26195 } else {
26196 G__setgvp((long) G__PVOID);
26197 for (int i = n - 1; i >= 0; --i) {
26198 ((TEvtRecVeeVertex*) (soff+(sizeof(TEvtRecVeeVertex)*i)))->~G__TTEvtRecVeeVertex();
26199 }
26200 G__setgvp((long)gvp);
26201 }
26202 } else {
26203 if (gvp == (char*)G__PVOID) {
26204 delete (TEvtRecVeeVertex*) soff;
26205 } else {
26206 G__setgvp((long) G__PVOID);
26207 ((TEvtRecVeeVertex*) (soff))->~G__TTEvtRecVeeVertex();
26208 G__setgvp((long)gvp);
26209 }
26210 }
26211 G__setnull(result7);
26212 return(1 || funcname || hash || result7 || libp) ;
26213}
26214
26215// automatic assignment operator
26216static int G__RootEventData_rootcint_517_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26217{
26218 TEvtRecVeeVertex* dest = (TEvtRecVeeVertex*) G__getstructoffset();
26219 *dest = *(TEvtRecVeeVertex*) libp->para[0].ref;
26220 const TEvtRecVeeVertex& obj = *dest;
26221 result7->ref = (long) (&obj);
26222 result7->obj.i = (long) (&obj);
26223 return(1 || funcname || hash || result7 || libp) ;
26224}
26225
26226
26227/* TEvtRecPi0 */
26228static int G__RootEventData_rootcint_518_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26229{
26230 TEvtRecPi0* p = NULL;
26231 char* gvp = (char*) G__getgvp();
26232 int n = G__getaryconstruct();
26233 if (n) {
26234 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26235 p = new TEvtRecPi0[n];
26236 } else {
26237 p = new((void*) gvp) TEvtRecPi0[n];
26238 }
26239 } else {
26240 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26241 p = new TEvtRecPi0;
26242 } else {
26243 p = new((void*) gvp) TEvtRecPi0;
26244 }
26245 }
26246 result7->obj.i = (long) p;
26247 result7->ref = (long) p;
26248 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
26249 return(1 || funcname || hash || result7 || libp) ;
26250}
26251
26252static int G__RootEventData_rootcint_518_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26253{
26254 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->unconMass());
26255 return(1 || funcname || hash || result7 || libp) ;
26256}
26257
26258static int G__RootEventData_rootcint_518_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26259{
26260 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->chisq());
26261 return(1 || funcname || hash || result7 || libp) ;
26262}
26263
26264static int G__RootEventData_rootcint_518_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26265{
26266 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPxfit());
26267 return(1 || funcname || hash || result7 || libp) ;
26268}
26269
26270static int G__RootEventData_rootcint_518_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26271{
26272 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPyfit());
26273 return(1 || funcname || hash || result7 || libp) ;
26274}
26275
26276static int G__RootEventData_rootcint_518_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26277{
26278 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPzfit());
26279 return(1 || funcname || hash || result7 || libp) ;
26280}
26281
26282static int G__RootEventData_rootcint_518_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26283{
26284 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPefit());
26285 return(1 || funcname || hash || result7 || libp) ;
26286}
26287
26288static int G__RootEventData_rootcint_518_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26289{
26290 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPxfit());
26291 return(1 || funcname || hash || result7 || libp) ;
26292}
26293
26294static int G__RootEventData_rootcint_518_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26295{
26296 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPyfit());
26297 return(1 || funcname || hash || result7 || libp) ;
26298}
26299
26300static int G__RootEventData_rootcint_518_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26301{
26302 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPzfit());
26303 return(1 || funcname || hash || result7 || libp) ;
26304}
26305
26306static int G__RootEventData_rootcint_518_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26307{
26308 G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPefit());
26309 return(1 || funcname || hash || result7 || libp) ;
26310}
26311
26312static int G__RootEventData_rootcint_518_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26313{
26314 G__letint(result7, 105, (long) ((const TEvtRecPi0*) G__getstructoffset())->hiEnGamma());
26315 return(1 || funcname || hash || result7 || libp) ;
26316}
26317
26318static int G__RootEventData_rootcint_518_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26319{
26320 G__letint(result7, 105, (long) ((const TEvtRecPi0*) G__getstructoffset())->loEnGamma());
26321 return(1 || funcname || hash || result7 || libp) ;
26322}
26323
26324static int G__RootEventData_rootcint_518_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26325{
26326 ((TEvtRecPi0*) G__getstructoffset())->setUnconMass((Double_t) G__double(libp->para[0]));
26327 G__setnull(result7);
26328 return(1 || funcname || hash || result7 || libp) ;
26329}
26330
26331static int G__RootEventData_rootcint_518_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26332{
26333 ((TEvtRecPi0*) G__getstructoffset())->setChisq((Double_t) G__double(libp->para[0]));
26334 G__setnull(result7);
26335 return(1 || funcname || hash || result7 || libp) ;
26336}
26337
26338static int G__RootEventData_rootcint_518_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26339{
26340 ((TEvtRecPi0*) G__getstructoffset())->setHiPxfit((Double_t) G__double(libp->para[0]));
26341 G__setnull(result7);
26342 return(1 || funcname || hash || result7 || libp) ;
26343}
26344
26345static int G__RootEventData_rootcint_518_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26346{
26347 ((TEvtRecPi0*) G__getstructoffset())->setHiPyfit((Double_t) G__double(libp->para[0]));
26348 G__setnull(result7);
26349 return(1 || funcname || hash || result7 || libp) ;
26350}
26351
26352static int G__RootEventData_rootcint_518_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26353{
26354 ((TEvtRecPi0*) G__getstructoffset())->setHiPzfit((Double_t) G__double(libp->para[0]));
26355 G__setnull(result7);
26356 return(1 || funcname || hash || result7 || libp) ;
26357}
26358
26359static int G__RootEventData_rootcint_518_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26360{
26361 ((TEvtRecPi0*) G__getstructoffset())->setHiPefit((Double_t) G__double(libp->para[0]));
26362 G__setnull(result7);
26363 return(1 || funcname || hash || result7 || libp) ;
26364}
26365
26366static int G__RootEventData_rootcint_518_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26367{
26368 ((TEvtRecPi0*) G__getstructoffset())->setLoPxfit((Double_t) G__double(libp->para[0]));
26369 G__setnull(result7);
26370 return(1 || funcname || hash || result7 || libp) ;
26371}
26372
26373static int G__RootEventData_rootcint_518_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26374{
26375 ((TEvtRecPi0*) G__getstructoffset())->setLoPyfit((Double_t) G__double(libp->para[0]));
26376 G__setnull(result7);
26377 return(1 || funcname || hash || result7 || libp) ;
26378}
26379
26380static int G__RootEventData_rootcint_518_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26381{
26382 ((TEvtRecPi0*) G__getstructoffset())->setLoPzfit((Double_t) G__double(libp->para[0]));
26383 G__setnull(result7);
26384 return(1 || funcname || hash || result7 || libp) ;
26385}
26386
26387static int G__RootEventData_rootcint_518_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26388{
26389 ((TEvtRecPi0*) G__getstructoffset())->setLoPefit((Double_t) G__double(libp->para[0]));
26390 G__setnull(result7);
26391 return(1 || funcname || hash || result7 || libp) ;
26392}
26393
26394static int G__RootEventData_rootcint_518_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26395{
26396 ((TEvtRecPi0*) G__getstructoffset())->setHiEnGamma((Int_t) G__int(libp->para[0]));
26397 G__setnull(result7);
26398 return(1 || funcname || hash || result7 || libp) ;
26399}
26400
26401static int G__RootEventData_rootcint_518_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26402{
26403 ((TEvtRecPi0*) G__getstructoffset())->setLoEnGamma((Int_t) G__int(libp->para[0]));
26404 G__setnull(result7);
26405 return(1 || funcname || hash || result7 || libp) ;
26406}
26407
26408static int G__RootEventData_rootcint_518_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26409{
26410 G__letint(result7, 85, (long) TEvtRecPi0::Class());
26411 return(1 || funcname || hash || result7 || libp) ;
26412}
26413
26414static int G__RootEventData_rootcint_518_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26415{
26416 G__letint(result7, 67, (long) TEvtRecPi0::Class_Name());
26417 return(1 || funcname || hash || result7 || libp) ;
26418}
26419
26420static int G__RootEventData_rootcint_518_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26421{
26422 G__letint(result7, 115, (long) TEvtRecPi0::Class_Version());
26423 return(1 || funcname || hash || result7 || libp) ;
26424}
26425
26426static int G__RootEventData_rootcint_518_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26427{
26428 TEvtRecPi0::Dictionary();
26429 G__setnull(result7);
26430 return(1 || funcname || hash || result7 || libp) ;
26431}
26432
26433static int G__RootEventData_rootcint_518_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26434{
26435 ((TEvtRecPi0*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
26436 G__setnull(result7);
26437 return(1 || funcname || hash || result7 || libp) ;
26438}
26439
26440static int G__RootEventData_rootcint_518_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26441{
26442 G__letint(result7, 67, (long) TEvtRecPi0::DeclFileName());
26443 return(1 || funcname || hash || result7 || libp) ;
26444}
26445
26446static int G__RootEventData_rootcint_518_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26447{
26448 G__letint(result7, 105, (long) TEvtRecPi0::ImplFileLine());
26449 return(1 || funcname || hash || result7 || libp) ;
26450}
26451
26452static int G__RootEventData_rootcint_518_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26453{
26454 G__letint(result7, 67, (long) TEvtRecPi0::ImplFileName());
26455 return(1 || funcname || hash || result7 || libp) ;
26456}
26457
26458static int G__RootEventData_rootcint_518_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26459{
26460 G__letint(result7, 105, (long) TEvtRecPi0::DeclFileLine());
26461 return(1 || funcname || hash || result7 || libp) ;
26462}
26463
26464// automatic copy constructor
26465static int G__RootEventData_rootcint_518_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26466
26467{
26468 TEvtRecPi0* p;
26469 void* tmp = (void*) G__int(libp->para[0]);
26470 p = new TEvtRecPi0(*(TEvtRecPi0*) tmp);
26471 result7->obj.i = (long) p;
26472 result7->ref = (long) p;
26473 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
26474 return(1 || funcname || hash || result7 || libp) ;
26475}
26476
26477// automatic destructor
26478typedef TEvtRecPi0 G__TTEvtRecPi0;
26479static int G__RootEventData_rootcint_518_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26480{
26481 char* gvp = (char*) G__getgvp();
26482 long soff = G__getstructoffset();
26483 int n = G__getaryconstruct();
26484 //
26485 //has_a_delete: 1
26486 //has_own_delete1arg: 0
26487 //has_own_delete2arg: 0
26488 //
26489 if (!soff) {
26490 return(1);
26491 }
26492 if (n) {
26493 if (gvp == (char*)G__PVOID) {
26494 delete[] (TEvtRecPi0*) soff;
26495 } else {
26496 G__setgvp((long) G__PVOID);
26497 for (int i = n - 1; i >= 0; --i) {
26498 ((TEvtRecPi0*) (soff+(sizeof(TEvtRecPi0)*i)))->~G__TTEvtRecPi0();
26499 }
26500 G__setgvp((long)gvp);
26501 }
26502 } else {
26503 if (gvp == (char*)G__PVOID) {
26504 delete (TEvtRecPi0*) soff;
26505 } else {
26506 G__setgvp((long) G__PVOID);
26507 ((TEvtRecPi0*) (soff))->~G__TTEvtRecPi0();
26508 G__setgvp((long)gvp);
26509 }
26510 }
26511 G__setnull(result7);
26512 return(1 || funcname || hash || result7 || libp) ;
26513}
26514
26515// automatic assignment operator
26516static int G__RootEventData_rootcint_518_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26517{
26518 TEvtRecPi0* dest = (TEvtRecPi0*) G__getstructoffset();
26519 *dest = *(TEvtRecPi0*) libp->para[0].ref;
26520 const TEvtRecPi0& obj = *dest;
26521 result7->ref = (long) (&obj);
26522 result7->obj.i = (long) (&obj);
26523 return(1 || funcname || hash || result7 || libp) ;
26524}
26525
26526
26527/* TEvtRecEtaToGG */
26528static int G__RootEventData_rootcint_519_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26529{
26530 TEvtRecEtaToGG* p = NULL;
26531 char* gvp = (char*) G__getgvp();
26532 int n = G__getaryconstruct();
26533 if (n) {
26534 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26535 p = new TEvtRecEtaToGG[n];
26536 } else {
26537 p = new((void*) gvp) TEvtRecEtaToGG[n];
26538 }
26539 } else {
26540 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26541 p = new TEvtRecEtaToGG;
26542 } else {
26543 p = new((void*) gvp) TEvtRecEtaToGG;
26544 }
26545 }
26546 result7->obj.i = (long) p;
26547 result7->ref = (long) p;
26548 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
26549 return(1 || funcname || hash || result7 || libp) ;
26550}
26551
26552static int G__RootEventData_rootcint_519_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26553{
26554 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->unconMass());
26555 return(1 || funcname || hash || result7 || libp) ;
26556}
26557
26558static int G__RootEventData_rootcint_519_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26559{
26560 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->chisq());
26561 return(1 || funcname || hash || result7 || libp) ;
26562}
26563
26564static int G__RootEventData_rootcint_519_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26565{
26566 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPxfit());
26567 return(1 || funcname || hash || result7 || libp) ;
26568}
26569
26570static int G__RootEventData_rootcint_519_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26571{
26572 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPyfit());
26573 return(1 || funcname || hash || result7 || libp) ;
26574}
26575
26576static int G__RootEventData_rootcint_519_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26577{
26578 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPzfit());
26579 return(1 || funcname || hash || result7 || libp) ;
26580}
26581
26582static int G__RootEventData_rootcint_519_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26583{
26584 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPefit());
26585 return(1 || funcname || hash || result7 || libp) ;
26586}
26587
26588static int G__RootEventData_rootcint_519_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26589{
26590 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPxfit());
26591 return(1 || funcname || hash || result7 || libp) ;
26592}
26593
26594static int G__RootEventData_rootcint_519_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26595{
26596 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPyfit());
26597 return(1 || funcname || hash || result7 || libp) ;
26598}
26599
26600static int G__RootEventData_rootcint_519_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26601{
26602 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPzfit());
26603 return(1 || funcname || hash || result7 || libp) ;
26604}
26605
26606static int G__RootEventData_rootcint_519_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26607{
26608 G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPefit());
26609 return(1 || funcname || hash || result7 || libp) ;
26610}
26611
26612static int G__RootEventData_rootcint_519_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26613{
26614 G__letint(result7, 105, (long) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiEnGamma());
26615 return(1 || funcname || hash || result7 || libp) ;
26616}
26617
26618static int G__RootEventData_rootcint_519_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26619{
26620 G__letint(result7, 105, (long) ((const TEvtRecEtaToGG*) G__getstructoffset())->loEnGamma());
26621 return(1 || funcname || hash || result7 || libp) ;
26622}
26623
26624static int G__RootEventData_rootcint_519_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26625{
26626 ((TEvtRecEtaToGG*) G__getstructoffset())->setUnconMass((Double_t) G__double(libp->para[0]));
26627 G__setnull(result7);
26628 return(1 || funcname || hash || result7 || libp) ;
26629}
26630
26631static int G__RootEventData_rootcint_519_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26632{
26633 ((TEvtRecEtaToGG*) G__getstructoffset())->setChisq((Double_t) G__double(libp->para[0]));
26634 G__setnull(result7);
26635 return(1 || funcname || hash || result7 || libp) ;
26636}
26637
26638static int G__RootEventData_rootcint_519_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26639{
26640 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPxfit((Double_t) G__double(libp->para[0]));
26641 G__setnull(result7);
26642 return(1 || funcname || hash || result7 || libp) ;
26643}
26644
26645static int G__RootEventData_rootcint_519_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26646{
26647 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPyfit((Double_t) G__double(libp->para[0]));
26648 G__setnull(result7);
26649 return(1 || funcname || hash || result7 || libp) ;
26650}
26651
26652static int G__RootEventData_rootcint_519_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26653{
26654 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPzfit((Double_t) G__double(libp->para[0]));
26655 G__setnull(result7);
26656 return(1 || funcname || hash || result7 || libp) ;
26657}
26658
26659static int G__RootEventData_rootcint_519_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26660{
26661 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPefit((Double_t) G__double(libp->para[0]));
26662 G__setnull(result7);
26663 return(1 || funcname || hash || result7 || libp) ;
26664}
26665
26666static int G__RootEventData_rootcint_519_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26667{
26668 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPxfit((Double_t) G__double(libp->para[0]));
26669 G__setnull(result7);
26670 return(1 || funcname || hash || result7 || libp) ;
26671}
26672
26673static int G__RootEventData_rootcint_519_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26674{
26675 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPyfit((Double_t) G__double(libp->para[0]));
26676 G__setnull(result7);
26677 return(1 || funcname || hash || result7 || libp) ;
26678}
26679
26680static int G__RootEventData_rootcint_519_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26681{
26682 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPzfit((Double_t) G__double(libp->para[0]));
26683 G__setnull(result7);
26684 return(1 || funcname || hash || result7 || libp) ;
26685}
26686
26687static int G__RootEventData_rootcint_519_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26688{
26689 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPefit((Double_t) G__double(libp->para[0]));
26690 G__setnull(result7);
26691 return(1 || funcname || hash || result7 || libp) ;
26692}
26693
26694static int G__RootEventData_rootcint_519_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26695{
26696 ((TEvtRecEtaToGG*) G__getstructoffset())->setHiEnGamma((Int_t) G__int(libp->para[0]));
26697 G__setnull(result7);
26698 return(1 || funcname || hash || result7 || libp) ;
26699}
26700
26701static int G__RootEventData_rootcint_519_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26702{
26703 ((TEvtRecEtaToGG*) G__getstructoffset())->setLoEnGamma((Int_t) G__int(libp->para[0]));
26704 G__setnull(result7);
26705 return(1 || funcname || hash || result7 || libp) ;
26706}
26707
26708static int G__RootEventData_rootcint_519_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26709{
26710 G__letint(result7, 85, (long) TEvtRecEtaToGG::Class());
26711 return(1 || funcname || hash || result7 || libp) ;
26712}
26713
26714static int G__RootEventData_rootcint_519_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26715{
26716 G__letint(result7, 67, (long) TEvtRecEtaToGG::Class_Name());
26717 return(1 || funcname || hash || result7 || libp) ;
26718}
26719
26720static int G__RootEventData_rootcint_519_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26721{
26722 G__letint(result7, 115, (long) TEvtRecEtaToGG::Class_Version());
26723 return(1 || funcname || hash || result7 || libp) ;
26724}
26725
26726static int G__RootEventData_rootcint_519_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26727{
26728 TEvtRecEtaToGG::Dictionary();
26729 G__setnull(result7);
26730 return(1 || funcname || hash || result7 || libp) ;
26731}
26732
26733static int G__RootEventData_rootcint_519_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26734{
26735 ((TEvtRecEtaToGG*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
26736 G__setnull(result7);
26737 return(1 || funcname || hash || result7 || libp) ;
26738}
26739
26740static int G__RootEventData_rootcint_519_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26741{
26742 G__letint(result7, 67, (long) TEvtRecEtaToGG::DeclFileName());
26743 return(1 || funcname || hash || result7 || libp) ;
26744}
26745
26746static int G__RootEventData_rootcint_519_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26747{
26748 G__letint(result7, 105, (long) TEvtRecEtaToGG::ImplFileLine());
26749 return(1 || funcname || hash || result7 || libp) ;
26750}
26751
26752static int G__RootEventData_rootcint_519_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26753{
26754 G__letint(result7, 67, (long) TEvtRecEtaToGG::ImplFileName());
26755 return(1 || funcname || hash || result7 || libp) ;
26756}
26757
26758static int G__RootEventData_rootcint_519_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26759{
26760 G__letint(result7, 105, (long) TEvtRecEtaToGG::DeclFileLine());
26761 return(1 || funcname || hash || result7 || libp) ;
26762}
26763
26764// automatic copy constructor
26765static int G__RootEventData_rootcint_519_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26766
26767{
26768 TEvtRecEtaToGG* p;
26769 void* tmp = (void*) G__int(libp->para[0]);
26770 p = new TEvtRecEtaToGG(*(TEvtRecEtaToGG*) tmp);
26771 result7->obj.i = (long) p;
26772 result7->ref = (long) p;
26773 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
26774 return(1 || funcname || hash || result7 || libp) ;
26775}
26776
26777// automatic destructor
26778typedef TEvtRecEtaToGG G__TTEvtRecEtaToGG;
26779static int G__RootEventData_rootcint_519_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26780{
26781 char* gvp = (char*) G__getgvp();
26782 long soff = G__getstructoffset();
26783 int n = G__getaryconstruct();
26784 //
26785 //has_a_delete: 1
26786 //has_own_delete1arg: 0
26787 //has_own_delete2arg: 0
26788 //
26789 if (!soff) {
26790 return(1);
26791 }
26792 if (n) {
26793 if (gvp == (char*)G__PVOID) {
26794 delete[] (TEvtRecEtaToGG*) soff;
26795 } else {
26796 G__setgvp((long) G__PVOID);
26797 for (int i = n - 1; i >= 0; --i) {
26798 ((TEvtRecEtaToGG*) (soff+(sizeof(TEvtRecEtaToGG)*i)))->~G__TTEvtRecEtaToGG();
26799 }
26800 G__setgvp((long)gvp);
26801 }
26802 } else {
26803 if (gvp == (char*)G__PVOID) {
26804 delete (TEvtRecEtaToGG*) soff;
26805 } else {
26806 G__setgvp((long) G__PVOID);
26807 ((TEvtRecEtaToGG*) (soff))->~G__TTEvtRecEtaToGG();
26808 G__setgvp((long)gvp);
26809 }
26810 }
26811 G__setnull(result7);
26812 return(1 || funcname || hash || result7 || libp) ;
26813}
26814
26815// automatic assignment operator
26816static int G__RootEventData_rootcint_519_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26817{
26818 TEvtRecEtaToGG* dest = (TEvtRecEtaToGG*) G__getstructoffset();
26819 *dest = *(TEvtRecEtaToGG*) libp->para[0].ref;
26820 const TEvtRecEtaToGG& obj = *dest;
26821 result7->ref = (long) (&obj);
26822 result7->obj.i = (long) (&obj);
26823 return(1 || funcname || hash || result7 || libp) ;
26824}
26825
26826
26827/* TEvtRecDTag */
26828static int G__RootEventData_rootcint_520_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26829{
26830 TEvtRecDTag* p = NULL;
26831 char* gvp = (char*) G__getgvp();
26832 int n = G__getaryconstruct();
26833 if (n) {
26834 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26835 p = new TEvtRecDTag[n];
26836 } else {
26837 p = new((void*) gvp) TEvtRecDTag[n];
26838 }
26839 } else {
26840 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
26841 p = new TEvtRecDTag;
26842 } else {
26843 p = new((void*) gvp) TEvtRecDTag;
26844 }
26845 }
26846 result7->obj.i = (long) p;
26847 result7->ref = (long) p;
26848 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
26849 return(1 || funcname || hash || result7 || libp) ;
26850}
26851
26852static int G__RootEventData_rootcint_520_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26853{
26854 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->decayMode());
26855 return(1 || funcname || hash || result7 || libp) ;
26856}
26857
26858static int G__RootEventData_rootcint_520_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26859{
26860 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->type());
26861 return(1 || funcname || hash || result7 || libp) ;
26862}
26863
26864static int G__RootEventData_rootcint_520_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26865{
26866 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->beamE());
26867 return(1 || funcname || hash || result7 || libp) ;
26868}
26869
26870static int G__RootEventData_rootcint_520_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26871{
26872 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->mass());
26873 return(1 || funcname || hash || result7 || libp) ;
26874}
26875
26876static int G__RootEventData_rootcint_520_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26877{
26878 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->mBC());
26879 return(1 || funcname || hash || result7 || libp) ;
26880}
26881
26882static int G__RootEventData_rootcint_520_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26883{
26884 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->deltaE());
26885 return(1 || funcname || hash || result7 || libp) ;
26886}
26887
26888static int G__RootEventData_rootcint_520_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26889{
26890 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->charge());
26891 return(1 || funcname || hash || result7 || libp) ;
26892}
26893
26894static int G__RootEventData_rootcint_520_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26895{
26896 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->charm());
26897 return(1 || funcname || hash || result7 || libp) ;
26898}
26899
26900static int G__RootEventData_rootcint_520_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26901{
26902 G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->numOfChildren());
26903 return(1 || funcname || hash || result7 || libp) ;
26904}
26905
26906static int G__RootEventData_rootcint_520_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26907{
26908 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->px());
26909 return(1 || funcname || hash || result7 || libp) ;
26910}
26911
26912static int G__RootEventData_rootcint_520_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26913{
26914 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->py());
26915 return(1 || funcname || hash || result7 || libp) ;
26916}
26917
26918static int G__RootEventData_rootcint_520_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26919{
26920 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->pz());
26921 return(1 || funcname || hash || result7 || libp) ;
26922}
26923
26924static int G__RootEventData_rootcint_520_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26925{
26926 G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->pe());
26927 return(1 || funcname || hash || result7 || libp) ;
26928}
26929
26930static int G__RootEventData_rootcint_520_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26931{
26932 {
26933 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->tracks();
26934 result7->ref = (long) (&obj);
26935 result7->obj.i = (long) (&obj);
26936 }
26937 return(1 || funcname || hash || result7 || libp) ;
26938}
26939
26940static int G__RootEventData_rootcint_520_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26941{
26942 {
26943 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->showers();
26944 result7->ref = (long) (&obj);
26945 result7->obj.i = (long) (&obj);
26946 }
26947 return(1 || funcname || hash || result7 || libp) ;
26948}
26949
26950static int G__RootEventData_rootcint_520_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26951{
26952 {
26953 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->otherTracks();
26954 result7->ref = (long) (&obj);
26955 result7->obj.i = (long) (&obj);
26956 }
26957 return(1 || funcname || hash || result7 || libp) ;
26958}
26959
26960static int G__RootEventData_rootcint_520_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26961{
26962 {
26963 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->otherShowers();
26964 result7->ref = (long) (&obj);
26965 result7->obj.i = (long) (&obj);
26966 }
26967 return(1 || funcname || hash || result7 || libp) ;
26968}
26969
26970static int G__RootEventData_rootcint_520_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26971{
26972 {
26973 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->pionId();
26974 result7->ref = (long) (&obj);
26975 result7->obj.i = (long) (&obj);
26976 }
26977 return(1 || funcname || hash || result7 || libp) ;
26978}
26979
26980static int G__RootEventData_rootcint_520_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26981{
26982 {
26983 const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->kaonId();
26984 result7->ref = (long) (&obj);
26985 result7->obj.i = (long) (&obj);
26986 }
26987 return(1 || funcname || hash || result7 || libp) ;
26988}
26989
26990static int G__RootEventData_rootcint_520_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26991{
26992 ((TEvtRecDTag*) G__getstructoffset())->setdecayMode((Int_t) G__int(libp->para[0]));
26993 G__setnull(result7);
26994 return(1 || funcname || hash || result7 || libp) ;
26995}
26996
26997static int G__RootEventData_rootcint_520_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
26998{
26999 ((TEvtRecDTag*) G__getstructoffset())->settype((Int_t) G__int(libp->para[0]));
27000 G__setnull(result7);
27001 return(1 || funcname || hash || result7 || libp) ;
27002}
27003
27004static int G__RootEventData_rootcint_520_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27005{
27006 ((TEvtRecDTag*) G__getstructoffset())->setbeamE((Double_t) G__double(libp->para[0]));
27007 G__setnull(result7);
27008 return(1 || funcname || hash || result7 || libp) ;
27009}
27010
27011static int G__RootEventData_rootcint_520_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27012{
27013 ((TEvtRecDTag*) G__getstructoffset())->setmass((Double_t) G__double(libp->para[0]));
27014 G__setnull(result7);
27015 return(1 || funcname || hash || result7 || libp) ;
27016}
27017
27018static int G__RootEventData_rootcint_520_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27019{
27020 ((TEvtRecDTag*) G__getstructoffset())->setmBC((Double_t) G__double(libp->para[0]));
27021 G__setnull(result7);
27022 return(1 || funcname || hash || result7 || libp) ;
27023}
27024
27025static int G__RootEventData_rootcint_520_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27026{
27027 ((TEvtRecDTag*) G__getstructoffset())->setdeltaE((Double_t) G__double(libp->para[0]));
27028 G__setnull(result7);
27029 return(1 || funcname || hash || result7 || libp) ;
27030}
27031
27032static int G__RootEventData_rootcint_520_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27033{
27034 ((TEvtRecDTag*) G__getstructoffset())->setcharge((Int_t) G__int(libp->para[0]));
27035 G__setnull(result7);
27036 return(1 || funcname || hash || result7 || libp) ;
27037}
27038
27039static int G__RootEventData_rootcint_520_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27040{
27041 ((TEvtRecDTag*) G__getstructoffset())->setcharm((Int_t) G__int(libp->para[0]));
27042 G__setnull(result7);
27043 return(1 || funcname || hash || result7 || libp) ;
27044}
27045
27046static int G__RootEventData_rootcint_520_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27047{
27048 ((TEvtRecDTag*) G__getstructoffset())->setnumOfChildren((Int_t) G__int(libp->para[0]));
27049 G__setnull(result7);
27050 return(1 || funcname || hash || result7 || libp) ;
27051}
27052
27053static int G__RootEventData_rootcint_520_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27054{
27055 ((TEvtRecDTag*) G__getstructoffset())->setpx((Double_t) G__double(libp->para[0]));
27056 G__setnull(result7);
27057 return(1 || funcname || hash || result7 || libp) ;
27058}
27059
27060static int G__RootEventData_rootcint_520_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27061{
27062 ((TEvtRecDTag*) G__getstructoffset())->setpy((Double_t) G__double(libp->para[0]));
27063 G__setnull(result7);
27064 return(1 || funcname || hash || result7 || libp) ;
27065}
27066
27067static int G__RootEventData_rootcint_520_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27068{
27069 ((TEvtRecDTag*) G__getstructoffset())->setpz((Double_t) G__double(libp->para[0]));
27070 G__setnull(result7);
27071 return(1 || funcname || hash || result7 || libp) ;
27072}
27073
27074static int G__RootEventData_rootcint_520_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27075{
27076 ((TEvtRecDTag*) G__getstructoffset())->setpe((Double_t) G__double(libp->para[0]));
27077 G__setnull(result7);
27078 return(1 || funcname || hash || result7 || libp) ;
27079}
27080
27081static int G__RootEventData_rootcint_520_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27082{
27083 ((TEvtRecDTag*) G__getstructoffset())->setTracks(*(vector<Int_t>*) libp->para[0].ref);
27084 G__setnull(result7);
27085 return(1 || funcname || hash || result7 || libp) ;
27086}
27087
27088static int G__RootEventData_rootcint_520_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27089{
27090 ((TEvtRecDTag*) G__getstructoffset())->setShowers(*(vector<Int_t>*) libp->para[0].ref);
27091 G__setnull(result7);
27092 return(1 || funcname || hash || result7 || libp) ;
27093}
27094
27095static int G__RootEventData_rootcint_520_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27096{
27097 ((TEvtRecDTag*) G__getstructoffset())->setOtherTracks(*(vector<Int_t>*) libp->para[0].ref);
27098 G__setnull(result7);
27099 return(1 || funcname || hash || result7 || libp) ;
27100}
27101
27102static int G__RootEventData_rootcint_520_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27103{
27104 ((TEvtRecDTag*) G__getstructoffset())->setOtherShowers(*(vector<Int_t>*) libp->para[0].ref);
27105 G__setnull(result7);
27106 return(1 || funcname || hash || result7 || libp) ;
27107}
27108
27109static int G__RootEventData_rootcint_520_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27110{
27111 ((TEvtRecDTag*) G__getstructoffset())->setPionId(*(vector<Int_t>*) libp->para[0].ref);
27112 G__setnull(result7);
27113 return(1 || funcname || hash || result7 || libp) ;
27114}
27115
27116static int G__RootEventData_rootcint_520_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27117{
27118 ((TEvtRecDTag*) G__getstructoffset())->setKaonId(*(vector<Int_t>*) libp->para[0].ref);
27119 G__setnull(result7);
27120 return(1 || funcname || hash || result7 || libp) ;
27121}
27122
27123static int G__RootEventData_rootcint_520_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27124{
27125 ((TEvtRecDTag*) G__getstructoffset())->addTrack((Int_t) G__int(libp->para[0]));
27126 G__setnull(result7);
27127 return(1 || funcname || hash || result7 || libp) ;
27128}
27129
27130static int G__RootEventData_rootcint_520_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27131{
27132 ((TEvtRecDTag*) G__getstructoffset())->addShower((Int_t) G__int(libp->para[0]));
27133 G__setnull(result7);
27134 return(1 || funcname || hash || result7 || libp) ;
27135}
27136
27137static int G__RootEventData_rootcint_520_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27138{
27139 ((TEvtRecDTag*) G__getstructoffset())->addOtherTrack((Int_t) G__int(libp->para[0]));
27140 G__setnull(result7);
27141 return(1 || funcname || hash || result7 || libp) ;
27142}
27143
27144static int G__RootEventData_rootcint_520_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27145{
27146 ((TEvtRecDTag*) G__getstructoffset())->addOtherShower((Int_t) G__int(libp->para[0]));
27147 G__setnull(result7);
27148 return(1 || funcname || hash || result7 || libp) ;
27149}
27150
27151static int G__RootEventData_rootcint_520_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27152{
27153 ((TEvtRecDTag*) G__getstructoffset())->addPionId((Int_t) G__int(libp->para[0]));
27154 G__setnull(result7);
27155 return(1 || funcname || hash || result7 || libp) ;
27156}
27157
27158static int G__RootEventData_rootcint_520_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27159{
27160 ((TEvtRecDTag*) G__getstructoffset())->addKaonId((Int_t) G__int(libp->para[0]));
27161 G__setnull(result7);
27162 return(1 || funcname || hash || result7 || libp) ;
27163}
27164
27165static int G__RootEventData_rootcint_520_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27166{
27167 G__letint(result7, 85, (long) TEvtRecDTag::Class());
27168 return(1 || funcname || hash || result7 || libp) ;
27169}
27170
27171static int G__RootEventData_rootcint_520_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27172{
27173 G__letint(result7, 67, (long) TEvtRecDTag::Class_Name());
27174 return(1 || funcname || hash || result7 || libp) ;
27175}
27176
27177static int G__RootEventData_rootcint_520_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27178{
27179 G__letint(result7, 115, (long) TEvtRecDTag::Class_Version());
27180 return(1 || funcname || hash || result7 || libp) ;
27181}
27182
27183static int G__RootEventData_rootcint_520_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27184{
27185 TEvtRecDTag::Dictionary();
27186 G__setnull(result7);
27187 return(1 || funcname || hash || result7 || libp) ;
27188}
27189
27190static int G__RootEventData_rootcint_520_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27191{
27192 ((TEvtRecDTag*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
27193 G__setnull(result7);
27194 return(1 || funcname || hash || result7 || libp) ;
27195}
27196
27197static int G__RootEventData_rootcint_520_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27198{
27199 G__letint(result7, 67, (long) TEvtRecDTag::DeclFileName());
27200 return(1 || funcname || hash || result7 || libp) ;
27201}
27202
27203static int G__RootEventData_rootcint_520_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27204{
27205 G__letint(result7, 105, (long) TEvtRecDTag::ImplFileLine());
27206 return(1 || funcname || hash || result7 || libp) ;
27207}
27208
27209static int G__RootEventData_rootcint_520_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27210{
27211 G__letint(result7, 67, (long) TEvtRecDTag::ImplFileName());
27212 return(1 || funcname || hash || result7 || libp) ;
27213}
27214
27215static int G__RootEventData_rootcint_520_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27216{
27217 G__letint(result7, 105, (long) TEvtRecDTag::DeclFileLine());
27218 return(1 || funcname || hash || result7 || libp) ;
27219}
27220
27221// automatic copy constructor
27222static int G__RootEventData_rootcint_520_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27223
27224{
27225 TEvtRecDTag* p;
27226 void* tmp = (void*) G__int(libp->para[0]);
27227 p = new TEvtRecDTag(*(TEvtRecDTag*) tmp);
27228 result7->obj.i = (long) p;
27229 result7->ref = (long) p;
27230 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
27231 return(1 || funcname || hash || result7 || libp) ;
27232}
27233
27234// automatic destructor
27235typedef TEvtRecDTag G__TTEvtRecDTag;
27236static int G__RootEventData_rootcint_520_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27237{
27238 char* gvp = (char*) G__getgvp();
27239 long soff = G__getstructoffset();
27240 int n = G__getaryconstruct();
27241 //
27242 //has_a_delete: 1
27243 //has_own_delete1arg: 0
27244 //has_own_delete2arg: 0
27245 //
27246 if (!soff) {
27247 return(1);
27248 }
27249 if (n) {
27250 if (gvp == (char*)G__PVOID) {
27251 delete[] (TEvtRecDTag*) soff;
27252 } else {
27253 G__setgvp((long) G__PVOID);
27254 for (int i = n - 1; i >= 0; --i) {
27255 ((TEvtRecDTag*) (soff+(sizeof(TEvtRecDTag)*i)))->~G__TTEvtRecDTag();
27256 }
27257 G__setgvp((long)gvp);
27258 }
27259 } else {
27260 if (gvp == (char*)G__PVOID) {
27261 delete (TEvtRecDTag*) soff;
27262 } else {
27263 G__setgvp((long) G__PVOID);
27264 ((TEvtRecDTag*) (soff))->~G__TTEvtRecDTag();
27265 G__setgvp((long)gvp);
27266 }
27267 }
27268 G__setnull(result7);
27269 return(1 || funcname || hash || result7 || libp) ;
27270}
27271
27272// automatic assignment operator
27273static int G__RootEventData_rootcint_520_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27274{
27275 TEvtRecDTag* dest = (TEvtRecDTag*) G__getstructoffset();
27276 *dest = *(TEvtRecDTag*) libp->para[0].ref;
27277 const TEvtRecDTag& obj = *dest;
27278 result7->ref = (long) (&obj);
27279 result7->obj.i = (long) (&obj);
27280 return(1 || funcname || hash || result7 || libp) ;
27281}
27282
27283
27284/* TEvtRecObject */
27285static int G__RootEventData_rootcint_521_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27286{
27287 TEvtRecObject* p = NULL;
27288 char* gvp = (char*) G__getgvp();
27289 int n = G__getaryconstruct();
27290 if (n) {
27291 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27292 p = new TEvtRecObject[n];
27293 } else {
27294 p = new((void*) gvp) TEvtRecObject[n];
27295 }
27296 } else {
27297 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27298 p = new TEvtRecObject;
27299 } else {
27300 p = new((void*) gvp) TEvtRecObject;
27301 }
27302 }
27303 result7->obj.i = (long) p;
27304 result7->ref = (long) p;
27305 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
27306 return(1 || funcname || hash || result7 || libp) ;
27307}
27308
27309static int G__RootEventData_rootcint_521_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27310{
27311 ((TEvtRecObject*) G__getstructoffset())->initialize();
27312 G__setnull(result7);
27313 return(1 || funcname || hash || result7 || libp) ;
27314}
27315
27316static int G__RootEventData_rootcint_521_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27317{
27318 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEvent());
27319 return(1 || funcname || hash || result7 || libp) ;
27320}
27321
27322static int G__RootEventData_rootcint_521_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27323{
27324 ((TEvtRecObject*) G__getstructoffset())->setEvtRecEvent((TEvtRecEvent*) G__int(libp->para[0]));
27325 G__setnull(result7);
27326 return(1 || funcname || hash || result7 || libp) ;
27327}
27328
27329static int G__RootEventData_rootcint_521_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27330{
27331 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecTrackCol());
27332 return(1 || funcname || hash || result7 || libp) ;
27333}
27334
27335static int G__RootEventData_rootcint_521_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27336{
27337 ((TEvtRecObject*) G__getstructoffset())->addEvtRecTrack((TEvtRecTrack*) G__int(libp->para[0]));
27338 G__setnull(result7);
27339 return(1 || funcname || hash || result7 || libp) ;
27340}
27341
27342static int G__RootEventData_rootcint_521_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27343{
27344 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecTrack((Int_t) G__int(libp->para[0])));
27345 return(1 || funcname || hash || result7 || libp) ;
27346}
27347
27348static int G__RootEventData_rootcint_521_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27349{
27350 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecTrackCol();
27351 G__setnull(result7);
27352 return(1 || funcname || hash || result7 || libp) ;
27353}
27354
27355static int G__RootEventData_rootcint_521_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27356{
27357 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPrimaryVertex());
27358 return(1 || funcname || hash || result7 || libp) ;
27359}
27360
27361static int G__RootEventData_rootcint_521_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27362{
27363 ((TEvtRecObject*) G__getstructoffset())->setEvtRecPrimaryVertex((TEvtRecPrimaryVertex*) G__int(libp->para[0]));
27364 G__setnull(result7);
27365 return(1 || funcname || hash || result7 || libp) ;
27366}
27367
27368static int G__RootEventData_rootcint_521_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27369{
27370 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecVeeVertexCol());
27371 return(1 || funcname || hash || result7 || libp) ;
27372}
27373
27374static int G__RootEventData_rootcint_521_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27375{
27376 ((TEvtRecObject*) G__getstructoffset())->addEvtRecVeeVertex((TEvtRecVeeVertex*) G__int(libp->para[0]));
27377 G__setnull(result7);
27378 return(1 || funcname || hash || result7 || libp) ;
27379}
27380
27381static int G__RootEventData_rootcint_521_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27382{
27383 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecVeeVertex((Int_t) G__int(libp->para[0])));
27384 return(1 || funcname || hash || result7 || libp) ;
27385}
27386
27387static int G__RootEventData_rootcint_521_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27388{
27389 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecVeeVertexCol();
27390 G__setnull(result7);
27391 return(1 || funcname || hash || result7 || libp) ;
27392}
27393
27394static int G__RootEventData_rootcint_521_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27395{
27396 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPi0Col());
27397 return(1 || funcname || hash || result7 || libp) ;
27398}
27399
27400static int G__RootEventData_rootcint_521_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27401{
27402 ((TEvtRecObject*) G__getstructoffset())->addEvtRecPi0((TEvtRecPi0*) G__int(libp->para[0]));
27403 G__setnull(result7);
27404 return(1 || funcname || hash || result7 || libp) ;
27405}
27406
27407static int G__RootEventData_rootcint_521_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27408{
27409 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPi0((Int_t) G__int(libp->para[0])));
27410 return(1 || funcname || hash || result7 || libp) ;
27411}
27412
27413static int G__RootEventData_rootcint_521_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27414{
27415 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecPi0Col();
27416 G__setnull(result7);
27417 return(1 || funcname || hash || result7 || libp) ;
27418}
27419
27420static int G__RootEventData_rootcint_521_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27421{
27422 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEtaToGGCol());
27423 return(1 || funcname || hash || result7 || libp) ;
27424}
27425
27426static int G__RootEventData_rootcint_521_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27427{
27428 ((TEvtRecObject*) G__getstructoffset())->addEvtRecEtaToGG((TEvtRecEtaToGG*) G__int(libp->para[0]));
27429 G__setnull(result7);
27430 return(1 || funcname || hash || result7 || libp) ;
27431}
27432
27433static int G__RootEventData_rootcint_521_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27434{
27435 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEtaToGG((Int_t) G__int(libp->para[0])));
27436 return(1 || funcname || hash || result7 || libp) ;
27437}
27438
27439static int G__RootEventData_rootcint_521_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27440{
27441 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecEtaToGGCol();
27442 G__setnull(result7);
27443 return(1 || funcname || hash || result7 || libp) ;
27444}
27445
27446static int G__RootEventData_rootcint_521_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27447{
27448 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecDTagCol());
27449 return(1 || funcname || hash || result7 || libp) ;
27450}
27451
27452static int G__RootEventData_rootcint_521_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27453{
27454 ((TEvtRecObject*) G__getstructoffset())->addEvtRecDTag((TEvtRecDTag*) G__int(libp->para[0]));
27455 G__setnull(result7);
27456 return(1 || funcname || hash || result7 || libp) ;
27457}
27458
27459static int G__RootEventData_rootcint_521_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27460{
27461 G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecDTag((Int_t) G__int(libp->para[0])));
27462 return(1 || funcname || hash || result7 || libp) ;
27463}
27464
27465static int G__RootEventData_rootcint_521_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27466{
27467 ((TEvtRecObject*) G__getstructoffset())->clearEvtRecDTagCol();
27468 G__setnull(result7);
27469 return(1 || funcname || hash || result7 || libp) ;
27470}
27471
27472static int G__RootEventData_rootcint_521_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27473{
27474 G__letint(result7, 85, (long) TEvtRecObject::Class());
27475 return(1 || funcname || hash || result7 || libp) ;
27476}
27477
27478static int G__RootEventData_rootcint_521_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27479{
27480 G__letint(result7, 67, (long) TEvtRecObject::Class_Name());
27481 return(1 || funcname || hash || result7 || libp) ;
27482}
27483
27484static int G__RootEventData_rootcint_521_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27485{
27486 G__letint(result7, 115, (long) TEvtRecObject::Class_Version());
27487 return(1 || funcname || hash || result7 || libp) ;
27488}
27489
27490static int G__RootEventData_rootcint_521_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27491{
27492 TEvtRecObject::Dictionary();
27493 G__setnull(result7);
27494 return(1 || funcname || hash || result7 || libp) ;
27495}
27496
27497static int G__RootEventData_rootcint_521_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27498{
27499 ((TEvtRecObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
27500 G__setnull(result7);
27501 return(1 || funcname || hash || result7 || libp) ;
27502}
27503
27504static int G__RootEventData_rootcint_521_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27505{
27506 G__letint(result7, 67, (long) TEvtRecObject::DeclFileName());
27507 return(1 || funcname || hash || result7 || libp) ;
27508}
27509
27510static int G__RootEventData_rootcint_521_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27511{
27512 G__letint(result7, 105, (long) TEvtRecObject::ImplFileLine());
27513 return(1 || funcname || hash || result7 || libp) ;
27514}
27515
27516static int G__RootEventData_rootcint_521_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27517{
27518 G__letint(result7, 67, (long) TEvtRecObject::ImplFileName());
27519 return(1 || funcname || hash || result7 || libp) ;
27520}
27521
27522static int G__RootEventData_rootcint_521_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27523{
27524 G__letint(result7, 105, (long) TEvtRecObject::DeclFileLine());
27525 return(1 || funcname || hash || result7 || libp) ;
27526}
27527
27528// automatic copy constructor
27529static int G__RootEventData_rootcint_521_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27530
27531{
27532 TEvtRecObject* p;
27533 void* tmp = (void*) G__int(libp->para[0]);
27534 p = new TEvtRecObject(*(TEvtRecObject*) tmp);
27535 result7->obj.i = (long) p;
27536 result7->ref = (long) p;
27537 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
27538 return(1 || funcname || hash || result7 || libp) ;
27539}
27540
27541// automatic destructor
27542typedef TEvtRecObject G__TTEvtRecObject;
27543static int G__RootEventData_rootcint_521_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27544{
27545 char* gvp = (char*) G__getgvp();
27546 long soff = G__getstructoffset();
27547 int n = G__getaryconstruct();
27548 //
27549 //has_a_delete: 1
27550 //has_own_delete1arg: 0
27551 //has_own_delete2arg: 0
27552 //
27553 if (!soff) {
27554 return(1);
27555 }
27556 if (n) {
27557 if (gvp == (char*)G__PVOID) {
27558 delete[] (TEvtRecObject*) soff;
27559 } else {
27560 G__setgvp((long) G__PVOID);
27561 for (int i = n - 1; i >= 0; --i) {
27562 ((TEvtRecObject*) (soff+(sizeof(TEvtRecObject)*i)))->~G__TTEvtRecObject();
27563 }
27564 G__setgvp((long)gvp);
27565 }
27566 } else {
27567 if (gvp == (char*)G__PVOID) {
27568 delete (TEvtRecObject*) soff;
27569 } else {
27570 G__setgvp((long) G__PVOID);
27571 ((TEvtRecObject*) (soff))->~G__TTEvtRecObject();
27572 G__setgvp((long)gvp);
27573 }
27574 }
27575 G__setnull(result7);
27576 return(1 || funcname || hash || result7 || libp) ;
27577}
27578
27579// automatic assignment operator
27580static int G__RootEventData_rootcint_521_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27581{
27582 TEvtRecObject* dest = (TEvtRecObject*) G__getstructoffset();
27583 *dest = *(TEvtRecObject*) libp->para[0].ref;
27584 const TEvtRecObject& obj = *dest;
27585 result7->ref = (long) (&obj);
27586 result7->obj.i = (long) (&obj);
27587 return(1 || funcname || hash || result7 || libp) ;
27588}
27589
27590
27591/* TMcHitTof */
27592static int G__RootEventData_rootcint_559_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27593{
27594 TMcHitTof* p = NULL;
27595 char* gvp = (char*) G__getgvp();
27596 int n = G__getaryconstruct();
27597 if (n) {
27598 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27599 p = new TMcHitTof[n];
27600 } else {
27601 p = new((void*) gvp) TMcHitTof[n];
27602 }
27603 } else {
27604 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27605 p = new TMcHitTof;
27606 } else {
27607 p = new((void*) gvp) TMcHitTof;
27608 }
27609 }
27610 result7->obj.i = (long) p;
27611 result7->ref = (long) p;
27612 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
27613 return(1 || funcname || hash || result7 || libp) ;
27614}
27615
27616static int G__RootEventData_rootcint_559_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27617{
27618 ((TMcHitTof*) G__getstructoffset())->SetTrackIndex((Int_t) G__int(libp->para[0]));
27619 G__setnull(result7);
27620 return(1 || funcname || hash || result7 || libp) ;
27621}
27622
27623static int G__RootEventData_rootcint_559_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27624{
27625 ((TMcHitTof*) G__getstructoffset())->SetG4Index((Int_t) G__int(libp->para[0]));
27626 G__setnull(result7);
27627 return(1 || funcname || hash || result7 || libp) ;
27628}
27629
27630static int G__RootEventData_rootcint_559_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27631{
27632 ((TMcHitTof*) G__getstructoffset())->SetPartId((Int_t) G__int(libp->para[0]));
27633 G__setnull(result7);
27634 return(1 || funcname || hash || result7 || libp) ;
27635}
27636
27637static int G__RootEventData_rootcint_559_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27638{
27639 ((TMcHitTof*) G__getstructoffset())->SetScinNb((Int_t) G__int(libp->para[0]));
27640 G__setnull(result7);
27641 return(1 || funcname || hash || result7 || libp) ;
27642}
27643
27644static int G__RootEventData_rootcint_559_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27645{
27646 ((TMcHitTof*) G__getstructoffset())->SetEdep((Double_t) G__double(libp->para[0]));
27647 G__setnull(result7);
27648 return(1 || funcname || hash || result7 || libp) ;
27649}
27650
27651static int G__RootEventData_rootcint_559_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27652{
27653 ((TMcHitTof*) G__getstructoffset())->SetStepL((Double_t) G__double(libp->para[0]));
27654 G__setnull(result7);
27655 return(1 || funcname || hash || result7 || libp) ;
27656}
27657
27658static int G__RootEventData_rootcint_559_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27659{
27660 ((TMcHitTof*) G__getstructoffset())->SetTrackL((Double_t) G__double(libp->para[0]));
27661 G__setnull(result7);
27662 return(1 || funcname || hash || result7 || libp) ;
27663}
27664
27665static int G__RootEventData_rootcint_559_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27666{
27667 ((TMcHitTof*) G__getstructoffset())->SetPos(*((TVector3*) G__int(libp->para[0])));
27668 G__setnull(result7);
27669 return(1 || funcname || hash || result7 || libp) ;
27670}
27671
27672static int G__RootEventData_rootcint_559_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27673{
27674 ((TMcHitTof*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
27675 G__setnull(result7);
27676 return(1 || funcname || hash || result7 || libp) ;
27677}
27678
27679static int G__RootEventData_rootcint_559_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27680{
27681 ((TMcHitTof*) G__getstructoffset())->SetDeltaT((Double_t) G__double(libp->para[0]));
27682 G__setnull(result7);
27683 return(1 || funcname || hash || result7 || libp) ;
27684}
27685
27686static int G__RootEventData_rootcint_559_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27687{
27688 ((TMcHitTof*) G__getstructoffset())->SetPDirection(*((TVector3*) G__int(libp->para[0])));
27689 G__setnull(result7);
27690 return(1 || funcname || hash || result7 || libp) ;
27691}
27692
27693static int G__RootEventData_rootcint_559_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27694{
27695 ((TMcHitTof*) G__getstructoffset())->SetMomentum(*((TVector3*) G__int(libp->para[0])));
27696 G__setnull(result7);
27697 return(1 || funcname || hash || result7 || libp) ;
27698}
27699
27700static int G__RootEventData_rootcint_559_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27701{
27702 ((TMcHitTof*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
27703 G__setnull(result7);
27704 return(1 || funcname || hash || result7 || libp) ;
27705}
27706
27707static int G__RootEventData_rootcint_559_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27708{
27709 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetTrackIndex());
27710 return(1 || funcname || hash || result7 || libp) ;
27711}
27712
27713static int G__RootEventData_rootcint_559_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27714{
27715 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetG4Index());
27716 return(1 || funcname || hash || result7 || libp) ;
27717}
27718
27719static int G__RootEventData_rootcint_559_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27720{
27721 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetPartId());
27722 return(1 || funcname || hash || result7 || libp) ;
27723}
27724
27725static int G__RootEventData_rootcint_559_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27726{
27727 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetScinNb());
27728 return(1 || funcname || hash || result7 || libp) ;
27729}
27730
27731static int G__RootEventData_rootcint_559_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27732{
27733 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetEdep());
27734 return(1 || funcname || hash || result7 || libp) ;
27735}
27736
27737static int G__RootEventData_rootcint_559_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27738{
27739 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetStepL());
27740 return(1 || funcname || hash || result7 || libp) ;
27741}
27742
27743static int G__RootEventData_rootcint_559_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27744{
27745 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetTrackL());
27746 return(1 || funcname || hash || result7 || libp) ;
27747}
27748
27749static int G__RootEventData_rootcint_559_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27750{
27751 {
27752 const TVector3* pobj;
27753 const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetPos();
27754 pobj = new TVector3(xobj);
27755 result7->obj.i = (long) ((void*) pobj);
27756 result7->ref = result7->obj.i;
27757 G__store_tempobject(*result7);
27758 }
27759 return(1 || funcname || hash || result7 || libp) ;
27760}
27761
27762static int G__RootEventData_rootcint_559_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27763{
27764 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetTime());
27765 return(1 || funcname || hash || result7 || libp) ;
27766}
27767
27768static int G__RootEventData_rootcint_559_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27769{
27770 G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetDeltaT());
27771 return(1 || funcname || hash || result7 || libp) ;
27772}
27773
27774static int G__RootEventData_rootcint_559_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27775{
27776 {
27777 const TVector3* pobj;
27778 const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetPDirection();
27779 pobj = new TVector3(xobj);
27780 result7->obj.i = (long) ((void*) pobj);
27781 result7->ref = result7->obj.i;
27782 G__store_tempobject(*result7);
27783 }
27784 return(1 || funcname || hash || result7 || libp) ;
27785}
27786
27787static int G__RootEventData_rootcint_559_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27788{
27789 {
27790 const TVector3* pobj;
27791 const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetMomentum();
27792 pobj = new TVector3(xobj);
27793 result7->obj.i = (long) ((void*) pobj);
27794 result7->ref = result7->obj.i;
27795 G__store_tempobject(*result7);
27796 }
27797 return(1 || funcname || hash || result7 || libp) ;
27798}
27799
27800static int G__RootEventData_rootcint_559_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27801{
27802 G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetCharge());
27803 return(1 || funcname || hash || result7 || libp) ;
27804}
27805
27806static int G__RootEventData_rootcint_559_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27807{
27808 G__letint(result7, 85, (long) TMcHitTof::Class());
27809 return(1 || funcname || hash || result7 || libp) ;
27810}
27811
27812static int G__RootEventData_rootcint_559_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27813{
27814 G__letint(result7, 67, (long) TMcHitTof::Class_Name());
27815 return(1 || funcname || hash || result7 || libp) ;
27816}
27817
27818static int G__RootEventData_rootcint_559_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27819{
27820 G__letint(result7, 115, (long) TMcHitTof::Class_Version());
27821 return(1 || funcname || hash || result7 || libp) ;
27822}
27823
27824static int G__RootEventData_rootcint_559_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27825{
27826 TMcHitTof::Dictionary();
27827 G__setnull(result7);
27828 return(1 || funcname || hash || result7 || libp) ;
27829}
27830
27831static int G__RootEventData_rootcint_559_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27832{
27833 ((TMcHitTof*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
27834 G__setnull(result7);
27835 return(1 || funcname || hash || result7 || libp) ;
27836}
27837
27838static int G__RootEventData_rootcint_559_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27839{
27840 G__letint(result7, 67, (long) TMcHitTof::DeclFileName());
27841 return(1 || funcname || hash || result7 || libp) ;
27842}
27843
27844static int G__RootEventData_rootcint_559_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27845{
27846 G__letint(result7, 105, (long) TMcHitTof::ImplFileLine());
27847 return(1 || funcname || hash || result7 || libp) ;
27848}
27849
27850static int G__RootEventData_rootcint_559_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27851{
27852 G__letint(result7, 67, (long) TMcHitTof::ImplFileName());
27853 return(1 || funcname || hash || result7 || libp) ;
27854}
27855
27856static int G__RootEventData_rootcint_559_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27857{
27858 G__letint(result7, 105, (long) TMcHitTof::DeclFileLine());
27859 return(1 || funcname || hash || result7 || libp) ;
27860}
27861
27862// automatic copy constructor
27863static int G__RootEventData_rootcint_559_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27864
27865{
27866 TMcHitTof* p;
27867 void* tmp = (void*) G__int(libp->para[0]);
27868 p = new TMcHitTof(*(TMcHitTof*) tmp);
27869 result7->obj.i = (long) p;
27870 result7->ref = (long) p;
27871 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
27872 return(1 || funcname || hash || result7 || libp) ;
27873}
27874
27875// automatic destructor
27876typedef TMcHitTof G__TTMcHitTof;
27877static int G__RootEventData_rootcint_559_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27878{
27879 char* gvp = (char*) G__getgvp();
27880 long soff = G__getstructoffset();
27881 int n = G__getaryconstruct();
27882 //
27883 //has_a_delete: 1
27884 //has_own_delete1arg: 0
27885 //has_own_delete2arg: 0
27886 //
27887 if (!soff) {
27888 return(1);
27889 }
27890 if (n) {
27891 if (gvp == (char*)G__PVOID) {
27892 delete[] (TMcHitTof*) soff;
27893 } else {
27894 G__setgvp((long) G__PVOID);
27895 for (int i = n - 1; i >= 0; --i) {
27896 ((TMcHitTof*) (soff+(sizeof(TMcHitTof)*i)))->~G__TTMcHitTof();
27897 }
27898 G__setgvp((long)gvp);
27899 }
27900 } else {
27901 if (gvp == (char*)G__PVOID) {
27902 delete (TMcHitTof*) soff;
27903 } else {
27904 G__setgvp((long) G__PVOID);
27905 ((TMcHitTof*) (soff))->~G__TTMcHitTof();
27906 G__setgvp((long)gvp);
27907 }
27908 }
27909 G__setnull(result7);
27910 return(1 || funcname || hash || result7 || libp) ;
27911}
27912
27913// automatic assignment operator
27914static int G__RootEventData_rootcint_559_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27915{
27916 TMcHitTof* dest = (TMcHitTof*) G__getstructoffset();
27917 *dest = *(TMcHitTof*) libp->para[0].ref;
27918 const TMcHitTof& obj = *dest;
27919 result7->ref = (long) (&obj);
27920 result7->obj.i = (long) (&obj);
27921 return(1 || funcname || hash || result7 || libp) ;
27922}
27923
27924
27925/* TMcHitMdc */
27926static int G__RootEventData_rootcint_560_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27927{
27928 TMcHitMdc* p = NULL;
27929 char* gvp = (char*) G__getgvp();
27930 int n = G__getaryconstruct();
27931 if (n) {
27932 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27933 p = new TMcHitMdc[n];
27934 } else {
27935 p = new((void*) gvp) TMcHitMdc[n];
27936 }
27937 } else {
27938 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
27939 p = new TMcHitMdc;
27940 } else {
27941 p = new((void*) gvp) TMcHitMdc;
27942 }
27943 }
27944 result7->obj.i = (long) p;
27945 result7->ref = (long) p;
27946 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
27947 return(1 || funcname || hash || result7 || libp) ;
27948}
27949
27950static int G__RootEventData_rootcint_560_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27951{
27952 ((TMcHitMdc*) G__getstructoffset())->SetTrackID((Int_t) G__int(libp->para[0]));
27953 G__setnull(result7);
27954 return(1 || funcname || hash || result7 || libp) ;
27955}
27956
27957static int G__RootEventData_rootcint_560_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27958{
27959 ((TMcHitMdc*) G__getstructoffset())->SetLayerNo((Int_t) G__int(libp->para[0]));
27960 G__setnull(result7);
27961 return(1 || funcname || hash || result7 || libp) ;
27962}
27963
27964static int G__RootEventData_rootcint_560_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27965{
27966 ((TMcHitMdc*) G__getstructoffset())->SetCellNo((Int_t) G__int(libp->para[0]));
27967 G__setnull(result7);
27968 return(1 || funcname || hash || result7 || libp) ;
27969}
27970
27971static int G__RootEventData_rootcint_560_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27972{
27973 ((TMcHitMdc*) G__getstructoffset())->SetEdep((Double_t) G__double(libp->para[0]));
27974 G__setnull(result7);
27975 return(1 || funcname || hash || result7 || libp) ;
27976}
27977
27978static int G__RootEventData_rootcint_560_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27979{
27980 ((TMcHitMdc*) G__getstructoffset())->SetPos(*((TVector3*) G__int(libp->para[0])));
27981 G__setnull(result7);
27982 return(1 || funcname || hash || result7 || libp) ;
27983}
27984
27985static int G__RootEventData_rootcint_560_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27986{
27987 ((TMcHitMdc*) G__getstructoffset())->SetDriftD((Double_t) G__double(libp->para[0]));
27988 G__setnull(result7);
27989 return(1 || funcname || hash || result7 || libp) ;
27990}
27991
27992static int G__RootEventData_rootcint_560_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
27993{
27994 ((TMcHitMdc*) G__getstructoffset())->SetDriftT((Double_t) G__double(libp->para[0]));
27995 G__setnull(result7);
27996 return(1 || funcname || hash || result7 || libp) ;
27997}
27998
27999static int G__RootEventData_rootcint_560_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28000{
28001 ((TMcHitMdc*) G__getstructoffset())->SetGlobalT((Double_t) G__double(libp->para[0]));
28002 G__setnull(result7);
28003 return(1 || funcname || hash || result7 || libp) ;
28004}
28005
28006static int G__RootEventData_rootcint_560_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28007{
28008 ((TMcHitMdc*) G__getstructoffset())->SetTheta((Double_t) G__double(libp->para[0]));
28009 G__setnull(result7);
28010 return(1 || funcname || hash || result7 || libp) ;
28011}
28012
28013static int G__RootEventData_rootcint_560_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28014{
28015 ((TMcHitMdc*) G__getstructoffset())->SetEnterAngle((Double_t) G__double(libp->para[0]));
28016 G__setnull(result7);
28017 return(1 || funcname || hash || result7 || libp) ;
28018}
28019
28020static int G__RootEventData_rootcint_560_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28021{
28022 ((TMcHitMdc*) G__getstructoffset())->SetPosFlag((Int_t) G__int(libp->para[0]));
28023 G__setnull(result7);
28024 return(1 || funcname || hash || result7 || libp) ;
28025}
28026
28027static int G__RootEventData_rootcint_560_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28028{
28029 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetTrackID());
28030 return(1 || funcname || hash || result7 || libp) ;
28031}
28032
28033static int G__RootEventData_rootcint_560_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28034{
28035 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetLayerNo());
28036 return(1 || funcname || hash || result7 || libp) ;
28037}
28038
28039static int G__RootEventData_rootcint_560_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28040{
28041 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetCellNo());
28042 return(1 || funcname || hash || result7 || libp) ;
28043}
28044
28045static int G__RootEventData_rootcint_560_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28046{
28047 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetEdep());
28048 return(1 || funcname || hash || result7 || libp) ;
28049}
28050
28051static int G__RootEventData_rootcint_560_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28052{
28053 {
28054 const TVector3* pobj;
28055 const TVector3 xobj = ((const TMcHitMdc*) G__getstructoffset())->GetPos();
28056 pobj = new TVector3(xobj);
28057 result7->obj.i = (long) ((void*) pobj);
28058 result7->ref = result7->obj.i;
28059 G__store_tempobject(*result7);
28060 }
28061 return(1 || funcname || hash || result7 || libp) ;
28062}
28063
28064static int G__RootEventData_rootcint_560_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28065{
28066 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetDriftD());
28067 return(1 || funcname || hash || result7 || libp) ;
28068}
28069
28070static int G__RootEventData_rootcint_560_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28071{
28072 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetDriftT());
28073 return(1 || funcname || hash || result7 || libp) ;
28074}
28075
28076static int G__RootEventData_rootcint_560_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28077{
28078 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetGlobalT());
28079 return(1 || funcname || hash || result7 || libp) ;
28080}
28081
28082static int G__RootEventData_rootcint_560_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28083{
28084 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetTheta());
28085 return(1 || funcname || hash || result7 || libp) ;
28086}
28087
28088static int G__RootEventData_rootcint_560_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28089{
28090 G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetEnterAngle());
28091 return(1 || funcname || hash || result7 || libp) ;
28092}
28093
28094static int G__RootEventData_rootcint_560_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28095{
28096 G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetPosFlag());
28097 return(1 || funcname || hash || result7 || libp) ;
28098}
28099
28100static int G__RootEventData_rootcint_560_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28101{
28102 G__letint(result7, 85, (long) TMcHitMdc::Class());
28103 return(1 || funcname || hash || result7 || libp) ;
28104}
28105
28106static int G__RootEventData_rootcint_560_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28107{
28108 G__letint(result7, 67, (long) TMcHitMdc::Class_Name());
28109 return(1 || funcname || hash || result7 || libp) ;
28110}
28111
28112static int G__RootEventData_rootcint_560_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28113{
28114 G__letint(result7, 115, (long) TMcHitMdc::Class_Version());
28115 return(1 || funcname || hash || result7 || libp) ;
28116}
28117
28118static int G__RootEventData_rootcint_560_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28119{
28120 TMcHitMdc::Dictionary();
28121 G__setnull(result7);
28122 return(1 || funcname || hash || result7 || libp) ;
28123}
28124
28125static int G__RootEventData_rootcint_560_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28126{
28127 ((TMcHitMdc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28128 G__setnull(result7);
28129 return(1 || funcname || hash || result7 || libp) ;
28130}
28131
28132static int G__RootEventData_rootcint_560_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28133{
28134 G__letint(result7, 67, (long) TMcHitMdc::DeclFileName());
28135 return(1 || funcname || hash || result7 || libp) ;
28136}
28137
28138static int G__RootEventData_rootcint_560_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28139{
28140 G__letint(result7, 105, (long) TMcHitMdc::ImplFileLine());
28141 return(1 || funcname || hash || result7 || libp) ;
28142}
28143
28144static int G__RootEventData_rootcint_560_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28145{
28146 G__letint(result7, 67, (long) TMcHitMdc::ImplFileName());
28147 return(1 || funcname || hash || result7 || libp) ;
28148}
28149
28150static int G__RootEventData_rootcint_560_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28151{
28152 G__letint(result7, 105, (long) TMcHitMdc::DeclFileLine());
28153 return(1 || funcname || hash || result7 || libp) ;
28154}
28155
28156// automatic copy constructor
28157static int G__RootEventData_rootcint_560_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28158
28159{
28160 TMcHitMdc* p;
28161 void* tmp = (void*) G__int(libp->para[0]);
28162 p = new TMcHitMdc(*(TMcHitMdc*) tmp);
28163 result7->obj.i = (long) p;
28164 result7->ref = (long) p;
28165 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
28166 return(1 || funcname || hash || result7 || libp) ;
28167}
28168
28169// automatic destructor
28170typedef TMcHitMdc G__TTMcHitMdc;
28171static int G__RootEventData_rootcint_560_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28172{
28173 char* gvp = (char*) G__getgvp();
28174 long soff = G__getstructoffset();
28175 int n = G__getaryconstruct();
28176 //
28177 //has_a_delete: 1
28178 //has_own_delete1arg: 0
28179 //has_own_delete2arg: 0
28180 //
28181 if (!soff) {
28182 return(1);
28183 }
28184 if (n) {
28185 if (gvp == (char*)G__PVOID) {
28186 delete[] (TMcHitMdc*) soff;
28187 } else {
28188 G__setgvp((long) G__PVOID);
28189 for (int i = n - 1; i >= 0; --i) {
28190 ((TMcHitMdc*) (soff+(sizeof(TMcHitMdc)*i)))->~G__TTMcHitMdc();
28191 }
28192 G__setgvp((long)gvp);
28193 }
28194 } else {
28195 if (gvp == (char*)G__PVOID) {
28196 delete (TMcHitMdc*) soff;
28197 } else {
28198 G__setgvp((long) G__PVOID);
28199 ((TMcHitMdc*) (soff))->~G__TTMcHitMdc();
28200 G__setgvp((long)gvp);
28201 }
28202 }
28203 G__setnull(result7);
28204 return(1 || funcname || hash || result7 || libp) ;
28205}
28206
28207// automatic assignment operator
28208static int G__RootEventData_rootcint_560_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28209{
28210 TMcHitMdc* dest = (TMcHitMdc*) G__getstructoffset();
28211 *dest = *(TMcHitMdc*) libp->para[0].ref;
28212 const TMcHitMdc& obj = *dest;
28213 result7->ref = (long) (&obj);
28214 result7->obj.i = (long) (&obj);
28215 return(1 || funcname || hash || result7 || libp) ;
28216}
28217
28218
28219/* TMcDigiEmc */
28220static int G__RootEventData_rootcint_561_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28221{
28222 TMcDigiEmc* p = NULL;
28223 char* gvp = (char*) G__getgvp();
28224 int n = G__getaryconstruct();
28225 if (n) {
28226 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28227 p = new TMcDigiEmc[n];
28228 } else {
28229 p = new((void*) gvp) TMcDigiEmc[n];
28230 }
28231 } else {
28232 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28233 p = new TMcDigiEmc;
28234 } else {
28235 p = new((void*) gvp) TMcDigiEmc;
28236 }
28237 }
28238 result7->obj.i = (long) p;
28239 result7->ref = (long) p;
28240 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
28241 return(1 || funcname || hash || result7 || libp) ;
28242}
28243
28244static int G__RootEventData_rootcint_561_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28245{
28246 ((TMcDigiEmc*) G__getstructoffset())->SetPartId((Int_t) G__int(libp->para[0]));
28247 G__setnull(result7);
28248 return(1 || funcname || hash || result7 || libp) ;
28249}
28250
28251static int G__RootEventData_rootcint_561_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28252{
28253 ((TMcDigiEmc*) G__getstructoffset())->SetThetaNb((Int_t) G__int(libp->para[0]));
28254 G__setnull(result7);
28255 return(1 || funcname || hash || result7 || libp) ;
28256}
28257
28258static int G__RootEventData_rootcint_561_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28259{
28260 ((TMcDigiEmc*) G__getstructoffset())->SetPhiNb((Int_t) G__int(libp->para[0]));
28261 G__setnull(result7);
28262 return(1 || funcname || hash || result7 || libp) ;
28263}
28264
28265static int G__RootEventData_rootcint_561_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28266{
28267 ((TMcDigiEmc*) G__getstructoffset())->SetEnergy((Double_t) G__double(libp->para[0]));
28268 G__setnull(result7);
28269 return(1 || funcname || hash || result7 || libp) ;
28270}
28271
28272static int G__RootEventData_rootcint_561_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28273{
28274 ((TMcDigiEmc*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
28275 G__setnull(result7);
28276 return(1 || funcname || hash || result7 || libp) ;
28277}
28278
28279static int G__RootEventData_rootcint_561_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28280{
28281 ((TMcDigiEmc*) G__getstructoffset())->SetTrackIndex((Int_t) G__int(libp->para[0]));
28282 G__setnull(result7);
28283 return(1 || funcname || hash || result7 || libp) ;
28284}
28285
28286static int G__RootEventData_rootcint_561_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28287{
28288 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetPartId());
28289 return(1 || funcname || hash || result7 || libp) ;
28290}
28291
28292static int G__RootEventData_rootcint_561_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28293{
28294 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetThetaNb());
28295 return(1 || funcname || hash || result7 || libp) ;
28296}
28297
28298static int G__RootEventData_rootcint_561_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28299{
28300 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetPhiNb());
28301 return(1 || funcname || hash || result7 || libp) ;
28302}
28303
28304static int G__RootEventData_rootcint_561_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28305{
28306 G__letdouble(result7, 100, (double) ((const TMcDigiEmc*) G__getstructoffset())->GetEnergy());
28307 return(1 || funcname || hash || result7 || libp) ;
28308}
28309
28310static int G__RootEventData_rootcint_561_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28311{
28312 G__letdouble(result7, 100, (double) ((const TMcDigiEmc*) G__getstructoffset())->GetTime());
28313 return(1 || funcname || hash || result7 || libp) ;
28314}
28315
28316static int G__RootEventData_rootcint_561_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28317{
28318 G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetTrackIndex());
28319 return(1 || funcname || hash || result7 || libp) ;
28320}
28321
28322static int G__RootEventData_rootcint_561_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28323{
28324 G__letint(result7, 85, (long) TMcDigiEmc::Class());
28325 return(1 || funcname || hash || result7 || libp) ;
28326}
28327
28328static int G__RootEventData_rootcint_561_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28329{
28330 G__letint(result7, 67, (long) TMcDigiEmc::Class_Name());
28331 return(1 || funcname || hash || result7 || libp) ;
28332}
28333
28334static int G__RootEventData_rootcint_561_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28335{
28336 G__letint(result7, 115, (long) TMcDigiEmc::Class_Version());
28337 return(1 || funcname || hash || result7 || libp) ;
28338}
28339
28340static int G__RootEventData_rootcint_561_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28341{
28342 TMcDigiEmc::Dictionary();
28343 G__setnull(result7);
28344 return(1 || funcname || hash || result7 || libp) ;
28345}
28346
28347static int G__RootEventData_rootcint_561_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28348{
28349 ((TMcDigiEmc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28350 G__setnull(result7);
28351 return(1 || funcname || hash || result7 || libp) ;
28352}
28353
28354static int G__RootEventData_rootcint_561_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28355{
28356 G__letint(result7, 67, (long) TMcDigiEmc::DeclFileName());
28357 return(1 || funcname || hash || result7 || libp) ;
28358}
28359
28360static int G__RootEventData_rootcint_561_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28361{
28362 G__letint(result7, 105, (long) TMcDigiEmc::ImplFileLine());
28363 return(1 || funcname || hash || result7 || libp) ;
28364}
28365
28366static int G__RootEventData_rootcint_561_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28367{
28368 G__letint(result7, 67, (long) TMcDigiEmc::ImplFileName());
28369 return(1 || funcname || hash || result7 || libp) ;
28370}
28371
28372static int G__RootEventData_rootcint_561_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28373{
28374 G__letint(result7, 105, (long) TMcDigiEmc::DeclFileLine());
28375 return(1 || funcname || hash || result7 || libp) ;
28376}
28377
28378// automatic copy constructor
28379static int G__RootEventData_rootcint_561_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28380
28381{
28382 TMcDigiEmc* p;
28383 void* tmp = (void*) G__int(libp->para[0]);
28384 p = new TMcDigiEmc(*(TMcDigiEmc*) tmp);
28385 result7->obj.i = (long) p;
28386 result7->ref = (long) p;
28387 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
28388 return(1 || funcname || hash || result7 || libp) ;
28389}
28390
28391// automatic destructor
28392typedef TMcDigiEmc G__TTMcDigiEmc;
28393static int G__RootEventData_rootcint_561_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28394{
28395 char* gvp = (char*) G__getgvp();
28396 long soff = G__getstructoffset();
28397 int n = G__getaryconstruct();
28398 //
28399 //has_a_delete: 1
28400 //has_own_delete1arg: 0
28401 //has_own_delete2arg: 0
28402 //
28403 if (!soff) {
28404 return(1);
28405 }
28406 if (n) {
28407 if (gvp == (char*)G__PVOID) {
28408 delete[] (TMcDigiEmc*) soff;
28409 } else {
28410 G__setgvp((long) G__PVOID);
28411 for (int i = n - 1; i >= 0; --i) {
28412 ((TMcDigiEmc*) (soff+(sizeof(TMcDigiEmc)*i)))->~G__TTMcDigiEmc();
28413 }
28414 G__setgvp((long)gvp);
28415 }
28416 } else {
28417 if (gvp == (char*)G__PVOID) {
28418 delete (TMcDigiEmc*) soff;
28419 } else {
28420 G__setgvp((long) G__PVOID);
28421 ((TMcDigiEmc*) (soff))->~G__TTMcDigiEmc();
28422 G__setgvp((long)gvp);
28423 }
28424 }
28425 G__setnull(result7);
28426 return(1 || funcname || hash || result7 || libp) ;
28427}
28428
28429// automatic assignment operator
28430static int G__RootEventData_rootcint_561_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28431{
28432 TMcDigiEmc* dest = (TMcDigiEmc*) G__getstructoffset();
28433 *dest = *(TMcDigiEmc*) libp->para[0].ref;
28434 const TMcDigiEmc& obj = *dest;
28435 result7->ref = (long) (&obj);
28436 result7->obj.i = (long) (&obj);
28437 return(1 || funcname || hash || result7 || libp) ;
28438}
28439
28440
28441/* TMcHitEvent */
28442static int G__RootEventData_rootcint_562_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28443{
28444 TMcHitEvent* p = NULL;
28445 char* gvp = (char*) G__getgvp();
28446 int n = G__getaryconstruct();
28447 if (n) {
28448 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28449 p = new TMcHitEvent[n];
28450 } else {
28451 p = new((void*) gvp) TMcHitEvent[n];
28452 }
28453 } else {
28454 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28455 p = new TMcHitEvent;
28456 } else {
28457 p = new((void*) gvp) TMcHitEvent;
28458 }
28459 }
28460 result7->obj.i = (long) p;
28461 result7->ref = (long) p;
28462 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
28463 return(1 || funcname || hash || result7 || libp) ;
28464}
28465
28466static int G__RootEventData_rootcint_562_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28467{
28468 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitTofCol());
28469 return(1 || funcname || hash || result7 || libp) ;
28470}
28471
28472static int G__RootEventData_rootcint_562_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28473{
28474 ((TMcHitEvent*) G__getstructoffset())->addMcHitTof((TMcHitTof*) G__int(libp->para[0]));
28475 G__setnull(result7);
28476 return(1 || funcname || hash || result7 || libp) ;
28477}
28478
28479static int G__RootEventData_rootcint_562_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28480{
28481 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitTof((Int_t) G__int(libp->para[0])));
28482 return(1 || funcname || hash || result7 || libp) ;
28483}
28484
28485static int G__RootEventData_rootcint_562_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28486{
28487 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitMdcCol());
28488 return(1 || funcname || hash || result7 || libp) ;
28489}
28490
28491static int G__RootEventData_rootcint_562_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28492{
28493 ((TMcHitEvent*) G__getstructoffset())->addMcHitMdc((TMcHitMdc*) G__int(libp->para[0]));
28494 G__setnull(result7);
28495 return(1 || funcname || hash || result7 || libp) ;
28496}
28497
28498static int G__RootEventData_rootcint_562_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28499{
28500 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitMdc((Int_t) G__int(libp->para[0])));
28501 return(1 || funcname || hash || result7 || libp) ;
28502}
28503
28504static int G__RootEventData_rootcint_562_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28505{
28506 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcDigiEmcCol());
28507 return(1 || funcname || hash || result7 || libp) ;
28508}
28509
28510static int G__RootEventData_rootcint_562_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28511{
28512 ((TMcHitEvent*) G__getstructoffset())->addMcDigiEmc((TMcDigiEmc*) G__int(libp->para[0]));
28513 G__setnull(result7);
28514 return(1 || funcname || hash || result7 || libp) ;
28515}
28516
28517static int G__RootEventData_rootcint_562_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28518{
28519 G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcDigiEmc((Int_t) G__int(libp->para[0])));
28520 return(1 || funcname || hash || result7 || libp) ;
28521}
28522
28523static int G__RootEventData_rootcint_562_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28524{
28525 ((TMcHitEvent*) G__getstructoffset())->setBeamTime((Double_t) G__double(libp->para[0]));
28526 G__setnull(result7);
28527 return(1 || funcname || hash || result7 || libp) ;
28528}
28529
28530static int G__RootEventData_rootcint_562_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28531{
28532 G__letdouble(result7, 100, (double) ((const TMcHitEvent*) G__getstructoffset())->getBeamTime());
28533 return(1 || funcname || hash || result7 || libp) ;
28534}
28535
28536static int G__RootEventData_rootcint_562_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28537{
28538 G__letint(result7, 85, (long) TMcHitEvent::Class());
28539 return(1 || funcname || hash || result7 || libp) ;
28540}
28541
28542static int G__RootEventData_rootcint_562_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28543{
28544 G__letint(result7, 67, (long) TMcHitEvent::Class_Name());
28545 return(1 || funcname || hash || result7 || libp) ;
28546}
28547
28548static int G__RootEventData_rootcint_562_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28549{
28550 G__letint(result7, 115, (long) TMcHitEvent::Class_Version());
28551 return(1 || funcname || hash || result7 || libp) ;
28552}
28553
28554static int G__RootEventData_rootcint_562_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28555{
28556 TMcHitEvent::Dictionary();
28557 G__setnull(result7);
28558 return(1 || funcname || hash || result7 || libp) ;
28559}
28560
28561static int G__RootEventData_rootcint_562_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28562{
28563 ((TMcHitEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28564 G__setnull(result7);
28565 return(1 || funcname || hash || result7 || libp) ;
28566}
28567
28568static int G__RootEventData_rootcint_562_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28569{
28570 G__letint(result7, 67, (long) TMcHitEvent::DeclFileName());
28571 return(1 || funcname || hash || result7 || libp) ;
28572}
28573
28574static int G__RootEventData_rootcint_562_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28575{
28576 G__letint(result7, 105, (long) TMcHitEvent::ImplFileLine());
28577 return(1 || funcname || hash || result7 || libp) ;
28578}
28579
28580static int G__RootEventData_rootcint_562_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28581{
28582 G__letint(result7, 67, (long) TMcHitEvent::ImplFileName());
28583 return(1 || funcname || hash || result7 || libp) ;
28584}
28585
28586static int G__RootEventData_rootcint_562_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28587{
28588 G__letint(result7, 105, (long) TMcHitEvent::DeclFileLine());
28589 return(1 || funcname || hash || result7 || libp) ;
28590}
28591
28592// automatic copy constructor
28593static int G__RootEventData_rootcint_562_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28594
28595{
28596 TMcHitEvent* p;
28597 void* tmp = (void*) G__int(libp->para[0]);
28598 p = new TMcHitEvent(*(TMcHitEvent*) tmp);
28599 result7->obj.i = (long) p;
28600 result7->ref = (long) p;
28601 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
28602 return(1 || funcname || hash || result7 || libp) ;
28603}
28604
28605// automatic destructor
28606typedef TMcHitEvent G__TTMcHitEvent;
28607static int G__RootEventData_rootcint_562_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28608{
28609 char* gvp = (char*) G__getgvp();
28610 long soff = G__getstructoffset();
28611 int n = G__getaryconstruct();
28612 //
28613 //has_a_delete: 1
28614 //has_own_delete1arg: 0
28615 //has_own_delete2arg: 0
28616 //
28617 if (!soff) {
28618 return(1);
28619 }
28620 if (n) {
28621 if (gvp == (char*)G__PVOID) {
28622 delete[] (TMcHitEvent*) soff;
28623 } else {
28624 G__setgvp((long) G__PVOID);
28625 for (int i = n - 1; i >= 0; --i) {
28626 ((TMcHitEvent*) (soff+(sizeof(TMcHitEvent)*i)))->~G__TTMcHitEvent();
28627 }
28628 G__setgvp((long)gvp);
28629 }
28630 } else {
28631 if (gvp == (char*)G__PVOID) {
28632 delete (TMcHitEvent*) soff;
28633 } else {
28634 G__setgvp((long) G__PVOID);
28635 ((TMcHitEvent*) (soff))->~G__TTMcHitEvent();
28636 G__setgvp((long)gvp);
28637 }
28638 }
28639 G__setnull(result7);
28640 return(1 || funcname || hash || result7 || libp) ;
28641}
28642
28643// automatic assignment operator
28644static int G__RootEventData_rootcint_562_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28645{
28646 TMcHitEvent* dest = (TMcHitEvent*) G__getstructoffset();
28647 *dest = *(TMcHitEvent*) libp->para[0].ref;
28648 const TMcHitEvent& obj = *dest;
28649 result7->ref = (long) (&obj);
28650 result7->obj.i = (long) (&obj);
28651 return(1 || funcname || hash || result7 || libp) ;
28652}
28653
28654
28655/* TBossFullEvent */
28656static int G__RootEventData_rootcint_563_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28657{
28658 TBossFullEvent* p = NULL;
28659 char* gvp = (char*) G__getgvp();
28660 int n = G__getaryconstruct();
28661 if (n) {
28662 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28663 p = new TBossFullEvent[n];
28664 } else {
28665 p = new((void*) gvp) TBossFullEvent[n];
28666 }
28667 } else {
28668 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
28669 p = new TBossFullEvent;
28670 } else {
28671 p = new((void*) gvp) TBossFullEvent;
28672 }
28673 }
28674 result7->obj.i = (long) p;
28675 result7->ref = (long) p;
28676 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
28677 return(1 || funcname || hash || result7 || libp) ;
28678}
28679
28680static int G__RootEventData_rootcint_563_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28681{
28682 ((TBossFullEvent*) G__getstructoffset())->copy((TBossFullEvent*) G__int(libp->para[0]));
28683 G__setnull(result7);
28684 return(1 || funcname || hash || result7 || libp) ;
28685}
28686
28687static int G__RootEventData_rootcint_563_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28688{
28689 ((TBossFullEvent*) G__getstructoffset())->reset();
28690 G__setnull(result7);
28691 return(1 || funcname || hash || result7 || libp) ;
28692}
28693
28694static int G__RootEventData_rootcint_563_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28695{
28696 ((TBossFullEvent*) G__getstructoffset())->setEvtHeader((TEvtHeader*) G__int(libp->para[0]));
28697 G__setnull(result7);
28698 return(1 || funcname || hash || result7 || libp) ;
28699}
28700
28701static int G__RootEventData_rootcint_563_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28702{
28703 ((TBossFullEvent*) G__getstructoffset())->setDigiEvent((TDigiEvent*) G__int(libp->para[0]));
28704 G__setnull(result7);
28705 return(1 || funcname || hash || result7 || libp) ;
28706}
28707
28708static int G__RootEventData_rootcint_563_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28709{
28710 ((TBossFullEvent*) G__getstructoffset())->setDstEvent((TDstEvent*) G__int(libp->para[0]));
28711 G__setnull(result7);
28712 return(1 || funcname || hash || result7 || libp) ;
28713}
28714
28715static int G__RootEventData_rootcint_563_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28716{
28717 ((TBossFullEvent*) G__getstructoffset())->setMcEvent((TMcEvent*) G__int(libp->para[0]));
28718 G__setnull(result7);
28719 return(1 || funcname || hash || result7 || libp) ;
28720}
28721
28722static int G__RootEventData_rootcint_563_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28723{
28724 ((TBossFullEvent*) G__getstructoffset())->setTrigEvent((TTrigEvent*) G__int(libp->para[0]));
28725 G__setnull(result7);
28726 return(1 || funcname || hash || result7 || libp) ;
28727}
28728
28729static int G__RootEventData_rootcint_563_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28730{
28731 ((TBossFullEvent*) G__getstructoffset())->setHltEvent((THltEvent*) G__int(libp->para[0]));
28732 G__setnull(result7);
28733 return(1 || funcname || hash || result7 || libp) ;
28734}
28735
28736static int G__RootEventData_rootcint_563_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28737{
28738 ((TBossFullEvent*) G__getstructoffset())->setRecTrackEvent((TRecTrackEvent*) G__int(libp->para[0]));
28739 G__setnull(result7);
28740 return(1 || funcname || hash || result7 || libp) ;
28741}
28742
28743static int G__RootEventData_rootcint_563_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28744{
28745 ((TBossFullEvent*) G__getstructoffset())->setEvtRecObject((TEvtRecObject*) G__int(libp->para[0]));
28746 G__setnull(result7);
28747 return(1 || funcname || hash || result7 || libp) ;
28748}
28749
28750static int G__RootEventData_rootcint_563_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28751{
28752 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getEvtHeader());
28753 return(1 || funcname || hash || result7 || libp) ;
28754}
28755
28756static int G__RootEventData_rootcint_563_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28757{
28758 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getDigiEvent());
28759 return(1 || funcname || hash || result7 || libp) ;
28760}
28761
28762static int G__RootEventData_rootcint_563_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28763{
28764 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getDstEvent());
28765 return(1 || funcname || hash || result7 || libp) ;
28766}
28767
28768static int G__RootEventData_rootcint_563_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28769{
28770 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getMcEvent());
28771 return(1 || funcname || hash || result7 || libp) ;
28772}
28773
28774static int G__RootEventData_rootcint_563_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28775{
28776 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getTrigEvent());
28777 return(1 || funcname || hash || result7 || libp) ;
28778}
28779
28780static int G__RootEventData_rootcint_563_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28781{
28782 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getHltEvent());
28783 return(1 || funcname || hash || result7 || libp) ;
28784}
28785
28786static int G__RootEventData_rootcint_563_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28787{
28788 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getRecTrackEvent());
28789 return(1 || funcname || hash || result7 || libp) ;
28790}
28791
28792static int G__RootEventData_rootcint_563_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28793{
28794 G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getEvtRecObject());
28795 return(1 || funcname || hash || result7 || libp) ;
28796}
28797
28798static int G__RootEventData_rootcint_563_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28799{
28800 G__letint(result7, 85, (long) TBossFullEvent::Class());
28801 return(1 || funcname || hash || result7 || libp) ;
28802}
28803
28804static int G__RootEventData_rootcint_563_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28805{
28806 G__letint(result7, 67, (long) TBossFullEvent::Class_Name());
28807 return(1 || funcname || hash || result7 || libp) ;
28808}
28809
28810static int G__RootEventData_rootcint_563_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28811{
28812 G__letint(result7, 115, (long) TBossFullEvent::Class_Version());
28813 return(1 || funcname || hash || result7 || libp) ;
28814}
28815
28816static int G__RootEventData_rootcint_563_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28817{
28818 TBossFullEvent::Dictionary();
28819 G__setnull(result7);
28820 return(1 || funcname || hash || result7 || libp) ;
28821}
28822
28823static int G__RootEventData_rootcint_563_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28824{
28825 ((TBossFullEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
28826 G__setnull(result7);
28827 return(1 || funcname || hash || result7 || libp) ;
28828}
28829
28830static int G__RootEventData_rootcint_563_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28831{
28832 G__letint(result7, 67, (long) TBossFullEvent::DeclFileName());
28833 return(1 || funcname || hash || result7 || libp) ;
28834}
28835
28836static int G__RootEventData_rootcint_563_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28837{
28838 G__letint(result7, 105, (long) TBossFullEvent::ImplFileLine());
28839 return(1 || funcname || hash || result7 || libp) ;
28840}
28841
28842static int G__RootEventData_rootcint_563_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28843{
28844 G__letint(result7, 67, (long) TBossFullEvent::ImplFileName());
28845 return(1 || funcname || hash || result7 || libp) ;
28846}
28847
28848static int G__RootEventData_rootcint_563_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28849{
28850 G__letint(result7, 105, (long) TBossFullEvent::DeclFileLine());
28851 return(1 || funcname || hash || result7 || libp) ;
28852}
28853
28854// automatic copy constructor
28855static int G__RootEventData_rootcint_563_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28856
28857{
28858 TBossFullEvent* p;
28859 void* tmp = (void*) G__int(libp->para[0]);
28860 p = new TBossFullEvent(*(TBossFullEvent*) tmp);
28861 result7->obj.i = (long) p;
28862 result7->ref = (long) p;
28863 G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
28864 return(1 || funcname || hash || result7 || libp) ;
28865}
28866
28867// automatic destructor
28868typedef TBossFullEvent G__TTBossFullEvent;
28869static int G__RootEventData_rootcint_563_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28870{
28871 char* gvp = (char*) G__getgvp();
28872 long soff = G__getstructoffset();
28873 int n = G__getaryconstruct();
28874 //
28875 //has_a_delete: 1
28876 //has_own_delete1arg: 0
28877 //has_own_delete2arg: 0
28878 //
28879 if (!soff) {
28880 return(1);
28881 }
28882 if (n) {
28883 if (gvp == (char*)G__PVOID) {
28884 delete[] (TBossFullEvent*) soff;
28885 } else {
28886 G__setgvp((long) G__PVOID);
28887 for (int i = n - 1; i >= 0; --i) {
28888 ((TBossFullEvent*) (soff+(sizeof(TBossFullEvent)*i)))->~G__TTBossFullEvent();
28889 }
28890 G__setgvp((long)gvp);
28891 }
28892 } else {
28893 if (gvp == (char*)G__PVOID) {
28894 delete (TBossFullEvent*) soff;
28895 } else {
28896 G__setgvp((long) G__PVOID);
28897 ((TBossFullEvent*) (soff))->~G__TTBossFullEvent();
28898 G__setgvp((long)gvp);
28899 }
28900 }
28901 G__setnull(result7);
28902 return(1 || funcname || hash || result7 || libp) ;
28903}
28904
28905// automatic assignment operator
28906static int G__RootEventData_rootcint_563_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
28907{
28908 TBossFullEvent* dest = (TBossFullEvent*) G__getstructoffset();
28909 *dest = *(TBossFullEvent*) libp->para[0].ref;
28910 const TBossFullEvent& obj = *dest;
28911 result7->ref = (long) (&obj);
28912 result7->obj.i = (long) (&obj);
28913 return(1 || funcname || hash || result7 || libp) ;
28914}
28915
28916
28917/* Setting up global function */
28918
28919/*********************************************************
28920* Member function Stub
28921*********************************************************/
28922
28923/* TJobInfo */
28924
28925/* TRawData */
28926
28927/* TMdcDigi */
28928
28929/* TEmcDigi */
28930
28931/* TTofDigi */
28932
28933/* TMucDigi */
28934
28935/* TLumiDigi */
28936
28937/* TDigiEvent */
28938
28939/* TRecMdcTrack */
28940
28941/* TRecMdcKalTrack */
28942
28943/* TRecMdcHit */
28944
28945/* TTofTrack */
28946
28947/* TRecTofTrack */
28948
28949/* TRecEmcHit */
28950
28951/* TRecEmcCluster */
28952
28953/* TRecEmcShower */
28954
28955/* TRecMucTrack */
28956
28957/* TRecMdcDedx */
28958
28959/* TRecMdcDedxHit */
28960
28961/* TRecExtTrack */
28962
28963/* TRecEvTime */
28964
28965/* TRecMdcKalHelixSeg */
28966
28967/* TRecZddChannel */
28968
28969/* TRecTrackEvent */
28970
28971/* TMdcTrack */
28972
28973/* TEmcTrack */
28974
28975/* TMucTrack */
28976
28977/* TMdcDedx */
28978
28979/* TExtTrack */
28980
28981/* TMdcKalTrack */
28982
28983/* TDstEvent */
28984
28985/* TMdcMc */
28986
28987/* TEmcMc */
28988
28989/* TTofMc */
28990
28991/* TMucMc */
28992
28993/* TMcParticle */
28994
28995/* TMcEvent */
28996
28997/* TEvtHeader */
28998
28999/* TEvtNavigator */
29000
29001/* TTrigData */
29002
29003/* TTrigEvent */
29004
29005/* THltRaw */
29006
29007/* THltInf */
29008
29009/* TDstHltInf */
29010
29011/* THltEvent */
29012
29013/* TDisTrack */
29014
29015/* TEvtRecEvent */
29016
29017/* TEvtRecTrack */
29018
29019/* TEvtRecPrimaryVertex */
29020
29021/* TEvtRecVeeVertex */
29022
29023/* TEvtRecPi0 */
29024
29025/* TEvtRecEtaToGG */
29026
29027/* TEvtRecDTag */
29028
29029/* TEvtRecObject */
29030
29031/* TMcHitTof */
29032
29033/* TMcHitMdc */
29034
29035/* TMcDigiEmc */
29036
29037/* TMcHitEvent */
29038
29039/* TBossFullEvent */
29040
29041/*********************************************************
29042* Global function Stub
29043*********************************************************/
29044
29045/*********************************************************
29046* Get size of pointer to member function
29047*********************************************************/
29048class G__Sizep2memfuncRootEventData_rootcint {
29049 public:
29050 G__Sizep2memfuncRootEventData_rootcint(): p(&G__Sizep2memfuncRootEventData_rootcint::sizep2memfunc) {}
29051 size_t sizep2memfunc() { return(sizeof(p)); }
29052 private:
29053 size_t (G__Sizep2memfuncRootEventData_rootcint::*p)();
29054};
29055
29056size_t G__get_sizep2memfuncRootEventData_rootcint()
29057{
29058 G__Sizep2memfuncRootEventData_rootcint a;
29059 G__setsizep2memfunc((int)a.sizep2memfunc());
29060 return((size_t)a.sizep2memfunc());
29061}
29062
29063
29064/*********************************************************
29065* virtual base class offset calculation interface
29066*********************************************************/
29067
29068 /* Setting up class inheritance */
29069
29070/*********************************************************
29071* Inheritance information setup/
29072*********************************************************/
29073extern "C" void G__cpp_setup_inheritanceRootEventData_rootcint() {
29074
29075 /* Setting up class inheritance */
29076 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo))) {
29077 TJobInfo *G__Lderived;
29078 G__Lderived=(TJobInfo*)0x1000;
29079 {
29080 TObject *G__Lpbase=(TObject*)G__Lderived;
29081 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29082 }
29083 }
29084 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData))) {
29085 TRawData *G__Lderived;
29086 G__Lderived=(TRawData*)0x1000;
29087 {
29088 TObject *G__Lpbase=(TObject*)G__Lderived;
29089 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29090 }
29091 }
29092 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi))) {
29093 TMdcDigi *G__Lderived;
29094 G__Lderived=(TMdcDigi*)0x1000;
29095 {
29096 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29097 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
29098 }
29099 {
29100 TObject *G__Lpbase=(TObject*)G__Lderived;
29101 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
29102 }
29103 }
29104 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi))) {
29105 TEmcDigi *G__Lderived;
29106 G__Lderived=(TEmcDigi*)0x1000;
29107 {
29108 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29109 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
29110 }
29111 {
29112 TObject *G__Lpbase=(TObject*)G__Lderived;
29113 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
29114 }
29115 }
29116 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi))) {
29117 TTofDigi *G__Lderived;
29118 G__Lderived=(TTofDigi*)0x1000;
29119 {
29120 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29121 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
29122 }
29123 {
29124 TObject *G__Lpbase=(TObject*)G__Lderived;
29125 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
29126 }
29127 }
29128 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi))) {
29129 TMucDigi *G__Lderived;
29130 G__Lderived=(TMucDigi*)0x1000;
29131 {
29132 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29133 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
29134 }
29135 {
29136 TObject *G__Lpbase=(TObject*)G__Lderived;
29137 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
29138 }
29139 }
29140 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi))) {
29141 TLumiDigi *G__Lderived;
29142 G__Lderived=(TLumiDigi*)0x1000;
29143 {
29144 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29145 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
29146 }
29147 {
29148 TObject *G__Lpbase=(TObject*)G__Lderived;
29149 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
29150 }
29151 }
29152 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent))) {
29153 TDigiEvent *G__Lderived;
29154 G__Lderived=(TDigiEvent*)0x1000;
29155 {
29156 TObject *G__Lpbase=(TObject*)G__Lderived;
29157 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29158 }
29159 }
29160 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack))) {
29161 TRecMdcTrack *G__Lderived;
29162 G__Lderived=(TRecMdcTrack*)0x1000;
29163 {
29164 TObject *G__Lpbase=(TObject*)G__Lderived;
29165 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29166 }
29167 }
29168 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack))) {
29169 TRecMdcKalTrack *G__Lderived;
29170 G__Lderived=(TRecMdcKalTrack*)0x1000;
29171 {
29172 TObject *G__Lpbase=(TObject*)G__Lderived;
29173 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29174 }
29175 }
29176 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit))) {
29177 TRecMdcHit *G__Lderived;
29178 G__Lderived=(TRecMdcHit*)0x1000;
29179 {
29180 TObject *G__Lpbase=(TObject*)G__Lderived;
29181 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29182 }
29183 }
29184 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack))) {
29185 TTofTrack *G__Lderived;
29186 G__Lderived=(TTofTrack*)0x1000;
29187 {
29188 TObject *G__Lpbase=(TObject*)G__Lderived;
29189 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29190 }
29191 }
29192 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack))) {
29193 TRecTofTrack *G__Lderived;
29194 G__Lderived=(TRecTofTrack*)0x1000;
29195 {
29196 TObject *G__Lpbase=(TObject*)G__Lderived;
29197 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29198 }
29199 }
29200 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit))) {
29201 TRecEmcHit *G__Lderived;
29202 G__Lderived=(TRecEmcHit*)0x1000;
29203 {
29204 TObject *G__Lpbase=(TObject*)G__Lderived;
29205 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29206 }
29207 }
29208 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster))) {
29209 TRecEmcCluster *G__Lderived;
29210 G__Lderived=(TRecEmcCluster*)0x1000;
29211 {
29212 TObject *G__Lpbase=(TObject*)G__Lderived;
29213 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29214 }
29215 }
29216 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower))) {
29217 TRecEmcShower *G__Lderived;
29218 G__Lderived=(TRecEmcShower*)0x1000;
29219 {
29220 TObject *G__Lpbase=(TObject*)G__Lderived;
29221 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29222 }
29223 }
29224 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack))) {
29225 TRecMucTrack *G__Lderived;
29226 G__Lderived=(TRecMucTrack*)0x1000;
29227 {
29228 TObject *G__Lpbase=(TObject*)G__Lderived;
29229 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29230 }
29231 }
29232 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx))) {
29233 TRecMdcDedx *G__Lderived;
29234 G__Lderived=(TRecMdcDedx*)0x1000;
29235 {
29236 TObject *G__Lpbase=(TObject*)G__Lderived;
29237 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29238 }
29239 }
29240 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit))) {
29241 TRecMdcDedxHit *G__Lderived;
29242 G__Lderived=(TRecMdcDedxHit*)0x1000;
29243 {
29244 TObject *G__Lpbase=(TObject*)G__Lderived;
29245 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29246 }
29247 }
29248 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack))) {
29249 TRecExtTrack *G__Lderived;
29250 G__Lderived=(TRecExtTrack*)0x1000;
29251 {
29252 TObject *G__Lpbase=(TObject*)G__Lderived;
29253 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29254 }
29255 }
29256 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime))) {
29257 TRecEvTime *G__Lderived;
29258 G__Lderived=(TRecEvTime*)0x1000;
29259 {
29260 TObject *G__Lpbase=(TObject*)G__Lderived;
29261 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29262 }
29263 }
29264 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg))) {
29265 TRecMdcKalHelixSeg *G__Lderived;
29266 G__Lderived=(TRecMdcKalHelixSeg*)0x1000;
29267 {
29268 TObject *G__Lpbase=(TObject*)G__Lderived;
29269 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29270 }
29271 }
29272 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel))) {
29273 TRecZddChannel *G__Lderived;
29274 G__Lderived=(TRecZddChannel*)0x1000;
29275 {
29276 TObject *G__Lpbase=(TObject*)G__Lderived;
29277 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29278 }
29279 }
29280 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent))) {
29281 TRecTrackEvent *G__Lderived;
29282 G__Lderived=(TRecTrackEvent*)0x1000;
29283 {
29284 TObject *G__Lpbase=(TObject*)G__Lderived;
29285 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29286 }
29287 }
29288 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack))) {
29289 TMdcTrack *G__Lderived;
29290 G__Lderived=(TMdcTrack*)0x1000;
29291 {
29292 TObject *G__Lpbase=(TObject*)G__Lderived;
29293 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29294 }
29295 }
29296 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack))) {
29297 TEmcTrack *G__Lderived;
29298 G__Lderived=(TEmcTrack*)0x1000;
29299 {
29300 TObject *G__Lpbase=(TObject*)G__Lderived;
29301 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29302 }
29303 }
29304 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack))) {
29305 TMucTrack *G__Lderived;
29306 G__Lderived=(TMucTrack*)0x1000;
29307 {
29308 TObject *G__Lpbase=(TObject*)G__Lderived;
29309 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29310 }
29311 }
29312 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx))) {
29313 TMdcDedx *G__Lderived;
29314 G__Lderived=(TMdcDedx*)0x1000;
29315 {
29316 TObject *G__Lpbase=(TObject*)G__Lderived;
29317 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29318 }
29319 }
29320 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack))) {
29321 TExtTrack *G__Lderived;
29322 G__Lderived=(TExtTrack*)0x1000;
29323 {
29324 TObject *G__Lpbase=(TObject*)G__Lderived;
29325 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29326 }
29327 }
29328 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack))) {
29329 TMdcKalTrack *G__Lderived;
29330 G__Lderived=(TMdcKalTrack*)0x1000;
29331 {
29332 TObject *G__Lpbase=(TObject*)G__Lderived;
29333 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29334 }
29335 }
29336 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent))) {
29337 TDstEvent *G__Lderived;
29338 G__Lderived=(TDstEvent*)0x1000;
29339 {
29340 TObject *G__Lpbase=(TObject*)G__Lderived;
29341 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29342 }
29343 }
29344 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc))) {
29345 TMdcMc *G__Lderived;
29346 G__Lderived=(TMdcMc*)0x1000;
29347 {
29348 TObject *G__Lpbase=(TObject*)G__Lderived;
29349 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29350 }
29351 }
29352 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc))) {
29353 TEmcMc *G__Lderived;
29354 G__Lderived=(TEmcMc*)0x1000;
29355 {
29356 TObject *G__Lpbase=(TObject*)G__Lderived;
29357 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29358 }
29359 }
29360 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc))) {
29361 TTofMc *G__Lderived;
29362 G__Lderived=(TTofMc*)0x1000;
29363 {
29364 TObject *G__Lpbase=(TObject*)G__Lderived;
29365 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29366 }
29367 }
29368 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc))) {
29369 TMucMc *G__Lderived;
29370 G__Lderived=(TMucMc*)0x1000;
29371 {
29372 TObject *G__Lpbase=(TObject*)G__Lderived;
29373 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29374 }
29375 }
29376 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle))) {
29377 TMcParticle *G__Lderived;
29378 G__Lderived=(TMcParticle*)0x1000;
29379 {
29380 TObject *G__Lpbase=(TObject*)G__Lderived;
29381 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29382 }
29383 }
29384 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent))) {
29385 TMcEvent *G__Lderived;
29386 G__Lderived=(TMcEvent*)0x1000;
29387 {
29388 TObject *G__Lpbase=(TObject*)G__Lderived;
29389 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29390 }
29391 }
29392 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader))) {
29393 TEvtHeader *G__Lderived;
29394 G__Lderived=(TEvtHeader*)0x1000;
29395 {
29396 TObject *G__Lpbase=(TObject*)G__Lderived;
29397 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29398 }
29399 }
29400 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator))) {
29401 TEvtNavigator *G__Lderived;
29402 G__Lderived=(TEvtNavigator*)0x1000;
29403 {
29404 TObject *G__Lpbase=(TObject*)G__Lderived;
29405 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29406 }
29407 }
29408 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData))) {
29409 TTrigData *G__Lderived;
29410 G__Lderived=(TTrigData*)0x1000;
29411 {
29412 TObject *G__Lpbase=(TObject*)G__Lderived;
29413 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29414 }
29415 }
29416 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent))) {
29417 TTrigEvent *G__Lderived;
29418 G__Lderived=(TTrigEvent*)0x1000;
29419 {
29420 TObject *G__Lpbase=(TObject*)G__Lderived;
29421 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29422 }
29423 }
29424 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw))) {
29425 THltRaw *G__Lderived;
29426 G__Lderived=(THltRaw*)0x1000;
29427 {
29428 TRawData *G__Lpbase=(TRawData*)G__Lderived;
29429 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
29430 }
29431 {
29432 TObject *G__Lpbase=(TObject*)G__Lderived;
29433 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
29434 }
29435 }
29436 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf))) {
29437 THltInf *G__Lderived;
29438 G__Lderived=(THltInf*)0x1000;
29439 {
29440 TObject *G__Lpbase=(TObject*)G__Lderived;
29441 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29442 }
29443 }
29444 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf))) {
29445 TDstHltInf *G__Lderived;
29446 G__Lderived=(TDstHltInf*)0x1000;
29447 {
29448 TObject *G__Lpbase=(TObject*)G__Lderived;
29449 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29450 }
29451 }
29452 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent))) {
29453 THltEvent *G__Lderived;
29454 G__Lderived=(THltEvent*)0x1000;
29455 {
29456 TObject *G__Lpbase=(TObject*)G__Lderived;
29457 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29458 }
29459 }
29460 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack))) {
29461 TDisTrack *G__Lderived;
29462 G__Lderived=(TDisTrack*)0x1000;
29463 {
29464 TObject *G__Lpbase=(TObject*)G__Lderived;
29465 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29466 }
29467 }
29468 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent))) {
29469 TEvtRecEvent *G__Lderived;
29470 G__Lderived=(TEvtRecEvent*)0x1000;
29471 {
29472 TObject *G__Lpbase=(TObject*)G__Lderived;
29473 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29474 }
29475 }
29476 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack))) {
29477 TEvtRecTrack *G__Lderived;
29478 G__Lderived=(TEvtRecTrack*)0x1000;
29479 {
29480 TObject *G__Lpbase=(TObject*)G__Lderived;
29481 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29482 }
29483 }
29484 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex))) {
29485 TEvtRecPrimaryVertex *G__Lderived;
29486 G__Lderived=(TEvtRecPrimaryVertex*)0x1000;
29487 {
29488 TObject *G__Lpbase=(TObject*)G__Lderived;
29489 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29490 }
29491 }
29492 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex))) {
29493 TEvtRecVeeVertex *G__Lderived;
29494 G__Lderived=(TEvtRecVeeVertex*)0x1000;
29495 {
29496 TObject *G__Lpbase=(TObject*)G__Lderived;
29497 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29498 }
29499 }
29500 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0))) {
29501 TEvtRecPi0 *G__Lderived;
29502 G__Lderived=(TEvtRecPi0*)0x1000;
29503 {
29504 TObject *G__Lpbase=(TObject*)G__Lderived;
29505 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29506 }
29507 }
29508 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG))) {
29509 TEvtRecEtaToGG *G__Lderived;
29510 G__Lderived=(TEvtRecEtaToGG*)0x1000;
29511 {
29512 TObject *G__Lpbase=(TObject*)G__Lderived;
29513 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29514 }
29515 }
29516 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag))) {
29517 TEvtRecDTag *G__Lderived;
29518 G__Lderived=(TEvtRecDTag*)0x1000;
29519 {
29520 TObject *G__Lpbase=(TObject*)G__Lderived;
29521 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29522 }
29523 }
29524 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject))) {
29525 TEvtRecObject *G__Lderived;
29526 G__Lderived=(TEvtRecObject*)0x1000;
29527 {
29528 TObject *G__Lpbase=(TObject*)G__Lderived;
29529 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29530 }
29531 }
29532 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof))) {
29533 TMcHitTof *G__Lderived;
29534 G__Lderived=(TMcHitTof*)0x1000;
29535 {
29536 TObject *G__Lpbase=(TObject*)G__Lderived;
29537 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29538 }
29539 }
29540 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc))) {
29541 TMcHitMdc *G__Lderived;
29542 G__Lderived=(TMcHitMdc*)0x1000;
29543 {
29544 TObject *G__Lpbase=(TObject*)G__Lderived;
29545 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29546 }
29547 }
29548 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc))) {
29549 TMcDigiEmc *G__Lderived;
29550 G__Lderived=(TMcDigiEmc*)0x1000;
29551 {
29552 TObject *G__Lpbase=(TObject*)G__Lderived;
29553 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29554 }
29555 }
29556 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent))) {
29557 TMcHitEvent *G__Lderived;
29558 G__Lderived=(TMcHitEvent*)0x1000;
29559 {
29560 TObject *G__Lpbase=(TObject*)G__Lderived;
29561 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29562 }
29563 }
29564 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent))) {
29565 TBossFullEvent *G__Lderived;
29566 G__Lderived=(TBossFullEvent*)0x1000;
29567 {
29568 TObject *G__Lpbase=(TObject*)G__Lderived;
29569 G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
29570 }
29571 }
29572}
29573
29574/*********************************************************
29575* typedef information setup/
29576*********************************************************/
29577extern "C" void G__cpp_setup_typetableRootEventData_rootcint() {
29578
29579 /* Setting up typedef entry */
29580 G__search_typename2("Int_t",105,-1,0,-1);
29581 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
29582 G__search_typename2("UInt_t",104,-1,0,-1);
29583 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
29584 G__search_typename2("Double_t",100,-1,0,-1);
29585 G__setnewtype(-1,"Double 8 bytes",0);
29586 G__search_typename2("Bool_t",103,-1,0,-1);
29587 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
29588 G__search_typename2("Version_t",115,-1,0,-1);
29589 G__setnewtype(-1,"Class version identifier (short)",0);
29590 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
29591 G__setnewtype(-1,NULL,0);
29592 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
29593 G__setnewtype(-1,NULL,0);
29594 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
29595 G__setnewtype(-1,NULL,0);
29596 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
29597 G__setnewtype(-1,NULL,0);
29598 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
29599 G__setnewtype(-1,NULL,0);
29600 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
29601 G__setnewtype(-1,NULL,0);
29602 G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
29603 G__setnewtype(-1,NULL,0);
29604 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR));
29605 G__setnewtype(-1,NULL,0);
29606 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR));
29607 G__setnewtype(-1,NULL,0);
29608 G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
29609 G__setnewtype(-1,NULL,0);
29610 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
29611 G__setnewtype(-1,NULL,0);
29612 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
29613 G__setnewtype(-1,NULL,0);
29614 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29615 G__setnewtype(-1,NULL,0);
29616 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29617 G__setnewtype(-1,NULL,0);
29618 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29619 G__setnewtype(-1,NULL,0);
29620 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29621 G__setnewtype(-1,NULL,0);
29622 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
29623 G__setnewtype(-1,NULL,0);
29624 G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
29625 G__setnewtype(-1,NULL,0);
29626 G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
29627 G__setnewtype(-1,NULL,0);
29628 G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
29629 G__setnewtype(-1,NULL,0);
29630 G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
29631 G__setnewtype(-1,NULL,0);
29632 G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
29633 G__setnewtype(-1,NULL,0);
29634 G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
29635 G__setnewtype(-1,NULL,0);
29636 G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
29637 G__setnewtype(-1,NULL,0);
29638 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
29639 G__setnewtype(-1,NULL,0);
29640 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
29641 G__setnewtype(-1,NULL,0);
29642 G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
29643 G__setnewtype(-1,NULL,0);
29644 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
29645 G__setnewtype(-1,NULL,0);
29646 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
29647 G__setnewtype(-1,NULL,0);
29648 G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
29649 G__setnewtype(-1,NULL,0);
29650 G__search_typename2("pair<Int_t,Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_pairlEintcOfloatgR),0,-1);
29651 G__setnewtype(-1,NULL,0);
29652 G__search_typename2("vector<std::pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
29653 G__setnewtype(-1,NULL,0);
29654 G__search_typename2("vector<pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
29655 G__setnewtype(-1,NULL,0);
29656 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
29657 G__setnewtype(-1,NULL,0);
29658 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
29659 G__setnewtype(-1,NULL,0);
29660 G__search_typename2("vector<pair<int,float> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
29661 G__setnewtype(-1,NULL,0);
29662 G__search_typename2("Fragments",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
29663 G__setnewtype(-1,NULL,0);
29664 G__search_typename2("multimap<int,int>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,-1);
29665 G__setnewtype(-1,NULL,0);
29666 G__search_typename2("multimap<int,int,less<int> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,-1);
29667 G__setnewtype(-1,NULL,0);
29668 G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR),0,-1);
29669 G__setnewtype(-1,NULL,0);
29670 G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR),0,-1);
29671 G__setnewtype(-1,NULL,0);
29672 G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVectorTlEfloatgR),0,-1);
29673 G__setnewtype(-1,NULL,0);
29674 G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVectorTlEdoublegR),0,-1);
29675 G__setnewtype(-1,NULL,0);
29676 G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTlEfloatgR),0,-1);
29677 G__setnewtype(-1,NULL,0);
29678 G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR),0,-1);
29679 G__setnewtype(-1,NULL,0);
29680 G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR),0,-1);
29681 G__setnewtype(-1,NULL,0);
29682 G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR),0,-1);
29683 G__setnewtype(-1,NULL,0);
29684 G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR),0,-1);
29685 G__setnewtype(-1,NULL,0);
29686 G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR),0,-1);
29687 G__setnewtype(-1,NULL,0);
29688 G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
29689 G__setnewtype(-1,NULL,0);
29690 G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
29691 G__setnewtype(-1,NULL,0);
29692 G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR),0,-1);
29693 G__setnewtype(-1,NULL,0);
29694 G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR),0,-1);
29695 G__setnewtype(-1,NULL,0);
29696 G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR),0,-1);
29697 G__setnewtype(-1,NULL,0);
29698 G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR),0,-1);
29699 G__setnewtype(-1,NULL,0);
29700 G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSublEfloatgR),0,-1);
29701 G__setnewtype(-1,NULL,0);
29702 G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR),0,-1);
29703 G__setnewtype(-1,NULL,0);
29704 G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
29705 G__setnewtype(-1,NULL,0);
29706 G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TElementActionTlEfloatgR),0,-1);
29707 G__setnewtype(-1,NULL,0);
29708 G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR),0,-1);
29709 G__setnewtype(-1,NULL,0);
29710}
29711
29712/*********************************************************
29713* Data Member information setup/
29714*********************************************************/
29715
29716 /* Setting up class,struct,union tag member variable */
29717
29718 /* TJobInfo */
29719static void G__setup_memvarTJobInfo(void) {
29720 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
29721 { TJobInfo *p; p=(TJobInfo*)0x1000; if (p) { }
29722 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_string),-1,-1,4,"m_decayOptions=",0,(char*)NULL);
29723 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_string),-1,-1,4,"m_bossVer=",0,(char*)NULL);
29724 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<string>"),-1,4,"m_jobOptions=",0,(char*)NULL);
29725 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"m_totEvtNo=",0,(char*)NULL);
29726 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29727 }
29728 G__tag_memvar_reset();
29729}
29730
29731
29732 /* TRawData */
29733static void G__setup_memvarTRawData(void) {
29734 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
29735 { TRawData *p; p=(TRawData*)0x1000; if (p) { }
29736 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_intId=",0,(char*)NULL);
29737 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_timeChannel=",0,(char*)NULL);
29738 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_chargeChannel=",0,(char*)NULL);
29739 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
29740 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29741 }
29742 G__tag_memvar_reset();
29743}
29744
29745
29746 /* TMdcDigi */
29747static void G__setup_memvarTMdcDigi(void) {
29748 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
29749 { TMdcDigi *p; p=(TMdcDigi*)0x1000; if (p) { }
29750 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
29751 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29752 }
29753 G__tag_memvar_reset();
29754}
29755
29756
29757 /* TEmcDigi */
29758static void G__setup_memvarTEmcDigi(void) {
29759 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
29760 { TEmcDigi *p; p=(TEmcDigi*)0x1000; if (p) { }
29761 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_measure=",0,(char*)NULL);
29762 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29763 }
29764 G__tag_memvar_reset();
29765}
29766
29767
29768 /* TTofDigi */
29769static void G__setup_memvarTTofDigi(void) {
29770 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
29771 { TTofDigi *p; p=(TTofDigi*)0x1000; if (p) { }
29772 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
29773 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29774 }
29775 G__tag_memvar_reset();
29776}
29777
29778
29779 /* TMucDigi */
29780static void G__setup_memvarTMucDigi(void) {
29781 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
29782 { TMucDigi *p; p=(TMucDigi*)0x1000; if (p) { }
29783 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29784 }
29785 G__tag_memvar_reset();
29786}
29787
29788
29789 /* TLumiDigi */
29790static void G__setup_memvarTLumiDigi(void) {
29791 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
29792 { TLumiDigi *p; p=(TLumiDigi*)0x1000; if (p) { }
29793 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
29794 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29795 }
29796 G__tag_memvar_reset();
29797}
29798
29799
29800 /* TDigiEvent */
29801static void G__setup_memvarTDigiEvent(void) {
29802 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
29803 { TDigiEvent *p; p=(TDigiEvent*)0x1000; if (p) { }
29804 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_fromMc=",0,(char*)NULL);
29805 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcDigiCol=",0,(char*)NULL);
29806 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcDigiCol=",0,"-> ");
29807 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcDigiCol=",0,(char*)NULL);
29808 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcDigiCol=",0,"->");
29809 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofDigiCol=",0,(char*)NULL);
29810 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofDigiCol=",0,"->");
29811 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucDigiCol=",0,(char*)NULL);
29812 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucDigiCol=",0,"->");
29813 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticLumiDigiCol=",0,(char*)NULL);
29814 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_lumiDigiCol=",0,"->");
29815 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29816 }
29817 G__tag_memvar_reset();
29818}
29819
29820
29821 /* TRecMdcTrack */
29822static void G__setup_memvarTRecMdcTrack(void) {
29823 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
29824 { TRecMdcTrack *p; p=(TRecMdcTrack*)0x1000; if (p) { }
29825 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id Wensp add 2005-10-19 ");
29826 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helix[5]=",0,"5 track parameters");
29827 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"Track Fit Quality");
29828 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,(char*)NULL);
29829 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,(char*)NULL);
29830 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[15]=",0,"Error Matrix");
29831 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nhits=",0,"number of total hits contained");
29832 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nster=",0,"number of stereo hits contained");
29833 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer=",0,"number of layer hits contained");
29834 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vx0=",0,"The coordinate of pivot(cm)");
29835 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vy0=",0,(char*)NULL);
29836 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vz0=",0,(char*)NULL);
29837 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fiTerm=",0,"phi angle value at track terminated point");
29838 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29839 }
29840 G__tag_memvar_reset();
29841}
29842
29843
29844 /* TRecMdcKalTrack */
29845static void G__setup_memvarTRecMdcKalTrack(void) {
29846 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
29847 { TRecMdcKalTrack *p; p=(TRecMdcKalTrack*)0x1000; if (p) { }
29848 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19 ");
29849 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass[5]=",0,"mass assumption during the fit ");
29850 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_length[5]=",0,"track path length from closest point to coord. origin to the last hit");
29851 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof[5]=",0,"time of flight correspond to length; ");
29852 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fiTerm[5]=",0,"terminal phi ");
29853 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pathSM[5]=",0,(char*)NULL);
29854 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nhits[5]=",0,"number of total hits contained ");
29855 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer[5]=",0,"number of layer that track passed");
29856 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat[2][5]=",0,"status flag ");
29857 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq[2][5]=",0,"chi square of fit 0:filter 1:smoother ");
29858 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndf[2][5]=",0,"degree of freedom for the fit 0:filter 1:smoother ");
29859 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nSegs[5]=",0,"number of segments");
29860 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca[3]=",0,(char*)NULL);
29861 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_e[3]=",0,(char*)NULL);
29862 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_mu[3]=",0,(char*)NULL);
29863 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_k[3]=",0,(char*)NULL);
29864 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_p[3]=",0,(char*)NULL);
29865 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint[3]=",0,(char*)NULL);
29866 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_e[3]=",0,(char*)NULL);
29867 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_mu[3]=",0,(char*)NULL);
29868 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_k[3]=",0,(char*)NULL);
29869 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_p[3]=",0,(char*)NULL);
29870 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot[3]=",0,(char*)NULL);
29871 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_e[3]=",0,(char*)NULL);
29872 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_mu[3]=",0,(char*)NULL);
29873 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_k[3]=",0,(char*)NULL);
29874 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_p[3]=",0,(char*)NULL);
29875 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix[5]=",0,"5 track parameters at zero point for pi ");
29876 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror[5][5]=",0,"error matrix at zero point for pion ");
29877 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_e[5]=",0,"5 track parameters at zero point for el ");
29878 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_e[5][5]=",0,"error matrix at zero point for electron ");
29879 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_mu[5]=",0,"5 track parameters at zero point for mu ");
29880 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_mu[5][5]=",0,"error matrix at zero point for muon ; ");
29881 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_k[5]=",0,"5 track parameters at zero point for ka ");
29882 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_k[5][5]=",0,"error matrix at zero point for kaon ");
29883 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_p[5]=",0,"5 track parameters at zero point for pr ");
29884 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_p[5][5]=",0,"error matrix at zero point for proton ");
29885 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix[5]=",0,"5 track parameters at zero point for pi ");
29886 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror[5][5]=",0,"error matrix at zero point for pion ");
29887 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_e[5]=",0,"5 track parameters at zero point for el ");
29888 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_e[5][5]=",0,"error matrix at zero point for electron ");
29889 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_mu[5]=",0,"5 track parameters at zero point for mu ");
29890 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_mu[5][5]=",0,"error matrix at zero point for muon ; ");
29891 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_k[5]=",0,"5 track parameters at zero point for ka ");
29892 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_k[5][5]=",0,"error matrix at zero point for kaon ");
29893 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_p[5]=",0,"5 track parameters at zero point for pr ");
29894 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_p[5][5]=",0,"error matrix at zero point for proton ");
29895 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix[5]=",0,"5 track parameters at zero point for pi ");
29896 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror[5][5]=",0,"error matrix at zero point for pion ");
29897 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_e[5]=",0,"5 track parameters at zero point for el ");
29898 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_e[5][5]=",0,"error matrix at zero point for electron ");
29899 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_mu[5]=",0,"5 track parameters at zero point for mu ");
29900 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_mu[5][5]=",0,"error matrix at zero point for muon ; ");
29901 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_k[5]=",0,"5 track parameters at zero point for ka ");
29902 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_k[5][5]=",0,"error matrix at zero point for kaon ");
29903 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_p[5]=",0,"5 track parameters at zero point for pr ");
29904 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_p[5][5]=",0,"error matrix at zero point for proton ");
29905 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_thelix[5]=",0,"5 track parameters of track finding ");
29906 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_terror[15]=",0,"error matrix of track finding ");
29907 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29908 }
29909 G__tag_memvar_reset();
29910}
29911
29912
29913 /* TRecMdcHit */
29914static void G__setup_memvarTRecMdcHit(void) {
29915 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
29916 { TRecMdcHit *p; p=(TRecMdcHit*)0x1000; if (p) { }
29917 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isGrouped=",0,(char*)NULL);
29918 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,(char*)NULL);
29919 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trkid=",0,"id of track containing this hit,if this hit ");
29920 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ddl=",0,"drift distance left");
29921 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ddr=",0,"drift distance right");
29922 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_erddl=",0,"error of drift distance left");
29923 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_erddr=",0,"error of drift distance right");
29924 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pChisq=",0,"contribution to chisquare");
29925 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lr=",0,"flag indicating left or right 0:left 1:right 2:ambig");
29926 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"status flag");
29927 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
29928 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tdc=",0,"corrected TDC");
29929 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_adc=",0,"corrected ADC");
29930 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftT=",0,"drift time");
29931 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_doca=",0,"distance of closesest approach for helix in the cell");
29932 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_entra=",0,"entrance angle in azimuth");
29933 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhit=",0,"z coordinate of the hit");
29934 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fltLen=",0,"flight length of this hit");
29935 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29936 }
29937 G__tag_memvar_reset();
29938}
29939
29940
29941 /* TTofTrack */
29942static void G__setup_memvarTTofTrack(void) {
29943 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
29944 { TTofTrack *p; p=(TTofTrack*)0x1000; if (p) { }
29945 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofTrackID=",0,"The ID of Tof Cluster reconstruction");
29946 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackID=",0,"Track ID from MDC / Shower ID from EMC.");
29947 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofID=",0,"Tof Counter ID.");
29948 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_status=",0,"Status.");
29949 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_path=",0,"Distance of flight.");
29950 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zrhit=",0,"Track extrapolate Z or R Hit position.");
29951 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ph=",0,"Pulse height.");
29952 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"Time of flight.");
29953 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beta=",0,"Beta value of the track.");
29954 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_texp[5]=",0,"Expected time of flight of 5 sorts of particle.");
29955 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_toffset[6]=",0,"Time offset of e, mu, pi, k and p and pbar.");
29956 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_sigma[6]=",0,"Time resolution of 5+1 sorts of particle.");
29957 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,"Data quality of reconstruction.");
29958 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_t0=",0,"t0 from data set calibration.");
29959 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errt0=",0,"t0 sigma from tof calibration.");
29960 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errz=",0,"Error of zTDC(m_zrhit) for neutral track.");
29961 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,"Angle of phi used for neutral track.");
29962 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errphi=",0,"Error of angle of phi.");
29963 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Energy deposit for neutral track.");
29964 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errenergy=",0,"Error of energy deposit for neutral track. ");
29965 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29966 }
29967 G__tag_memvar_reset();
29968}
29969
29970
29971 /* TRecTofTrack */
29972static void G__setup_memvarTRecTofTrack(void) {
29973 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
29974 { TRecTofTrack *p; p=(TRecTofTrack*)0x1000; if (p) { }
29975 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofTrackID=",0,"The ID of Tof Cluster reconstruction");
29976 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackID=",0,"Track ID from MDC / Shower ID from EMC.");
29977 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofID=",0,"Tof Counter ID.");
29978 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_status=",0,"Status.");
29979 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_path=",0,"Distance of flight.");
29980 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zrhit=",0,"Track extrapolate Z or R Hit position.");
29981 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ph=",0,"Pulse height.");
29982 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"Time of flight.");
29983 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beta=",0,"Beta value of the track.");
29984 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_texp[5]=",0,"Expected time of flight of 5 sorts of particle.");
29985 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_toffset[6]=",0,"Time offset of e, mu, pi, k and p and pbar.");
29986 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_sigma[6]=",0,"Time resolution of 5+1 sorts of particle.");
29987 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,"Data quality of reconstruction.");
29988 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_t0=",0,"t0 from data set calibration.");
29989 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errt0=",0,"t0 sigma from tof calibration.");
29990 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errz=",0,"Error of zTDC(m_zrhit) for neutral track.");
29991 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,"Angle of phi used for neutral track.");
29992 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errphi=",0,"Error of angle of phi.");
29993 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Energy deposit for neutral track");
29994 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errenergy=",0,"Error of energy deposit for neutral track. ");
29995 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
29996 }
29997 G__tag_memvar_reset();
29998}
29999
30000
30001 /* TRecEmcHit */
30002static void G__setup_memvarTRecEmcHit(void) {
30003 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
30004 { TRecEmcHit *p; p=(TRecEmcHit*)0x1000; if (p) { }
30005 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,(char*)NULL);
30006 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,(char*)NULL);
30007 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
30008 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30009 }
30010 G__tag_memvar_reset();
30011}
30012
30013
30014 /* TRecEmcCluster */
30015static void G__setup_memvarTRecEmcCluster(void) {
30016 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
30017 { TRecEmcCluster *p; p=(TRecEmcCluster*)0x1000; if (p) { }
30018 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_clusterId=",0,(char*)NULL);
30019 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecHits=",0,(char*)NULL);
30020 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecSeeds=",0,(char*)NULL);
30021 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecShowers=",0,(char*)NULL);
30022 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30023 }
30024 G__tag_memvar_reset();
30025}
30026
30027
30028 /* TRecEmcShower */
30029static void G__setup_memvarTRecEmcShower(void) {
30030 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
30031 { TRecEmcShower *p; p=(TRecEmcShower*)0x1000; if (p) { }
30032 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19 ");
30033 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Total number of hits");
30034 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30035 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,"Cell ID");
30036 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_module=",0,"Module");
30037 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_x=",0,"Shower coordinates and errors");
30038 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_y=",0,(char*)NULL);
30039 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_z=",0,(char*)NULL);
30040 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_theta=",0,"Shower Counter angles and errors");
30041 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dTheta=",0,(char*)NULL);
30042 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,(char*)NULL);
30043 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dPhi=",0,(char*)NULL);
30044 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Total energy observed in Emc");
30045 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dE=",0,(char*)NULL);
30046 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eSeed=",0,"// Energy of seed, only one");
30047 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e3x3=",0,"Energy of 3x3 crystals, totally 9 ones");
30048 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e5x5=",0,"Energy of 5x5 crystals, totally 25 ones");
30049 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eall=",0,"Energy of all crystals in the shower");
30050 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_elepton=",0,"Energy of all various number of crystals");
30051 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,"Time");
30052 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_secondMoment=",0,"add 2006-07-03");
30053 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_latMoment=",0,"Lateral moment");
30054 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a20Moment=",0,"Zernike moment");
30055 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a42Moment=",0,(char*)NULL);
30056 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[6]=",0,"Error Matrix: 0:dxx, 1:dyy, 2:dzz");
30057 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),G__defined_typename("map<Int_t,Double_t>"),-1,4,"m_cellIdMap=",0,"Hit list and its fraction");
30058 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_cellId3x3=",0,"Cell ID 3x3");
30059 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_cellId5x5=",0,"Cell ID 5x5");
30060 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_clusterId=",0,"Cluster ID");
30061 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30062 }
30063 G__tag_memvar_reset();
30064}
30065
30066
30067 /* TRecMucTrack */
30068static void G__setup_memvarTRecMucTrack(void) {
30069 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
30070 { TRecMucTrack *p; p=(TRecMucTrack*)0x1000; if (p) { }
30071 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track ID wensp Add 2005-10-19");
30072 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,"Muc Identifier");
30073 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Muc Status");
30074 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,"Method of judge?");
30075 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_startPart=",0,"In which part does the start position of track locate");
30076 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_endPart=",0,"In which part does the end position of track locate");
30077 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_brLastLayer=",0,"Last layer with hits in barrel ");
30078 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ecLastLayer=",0,"Last layer with hits in endcap ");
30079 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Number of hits on track");
30080 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numLayers=",0,"Number of layer with hits");
30081 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_maxHitsInLayer=",0,"Max number of hits in a layer");
30082 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depth=",0,"Depth of iron penetrated");
30083 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"Fit parameters");
30084 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_dof=",0,(char*)NULL);
30085 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_rms=",0,(char*)NULL);
30086 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPos=",0,"x position of muc track vertex");
30087 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPos=",0,"y position of muc track vertex");
30088 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPos=",0,"z position of muc track vertex");
30089 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosSigma=",0,"Sigma of x position of muc track vertex");
30090 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosSigma=",0,"Sigma of y position of muc track vertex");
30091 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosSigma=",0,"Sigma of z position of muc track vertex");
30092 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,"px on muc track vertex");
30093 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,"py on muc track vertex");
30094 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,"pz on muc track vertex");
30095 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_distance=",0,"distance match of ext track with inner layer of Muc");
30096 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaPhi=",0,"delta phi of mdc track and Muc hit in first layer");
30097 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecHits=",0,"// hit list of the track wensp Add 2005-10-20");
30098 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_expHits=",0,"// expected hit list of the track ");
30099 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"m_distHits=",0,"// distance between attached hit and track ");
30100 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kalrechi2=",0,(char*)NULL);
30101 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kaldof=",0,(char*)NULL);
30102 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kaldepth=",0,(char*)NULL);
30103 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalbrLastLayer=",0,(char*)NULL);
30104 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalecLastLayer=",0,(char*)NULL);
30105 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30106 }
30107 G__tag_memvar_reset();
30108}
30109
30110
30111 /* TRecMdcDedx */
30112static void G__setup_memvarTRecMdcDedx(void) {
30113 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
30114 { TRecMdcDedx *p; p=(TRecMdcDedx*)0x1000; if (p) { }
30115 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_hit=",0,"double trucation mean of hit-level calib");
30116 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_esat=",0,"double trucation mean of hit-level+electron saturation calib");
30117 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_norun=",0,"double trucation mean of no run gain calib");
30118 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_momentum=",0,"dE/dx calib used momentum");
30119 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
30120 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcTrackId=",0,(char*)NULL);
30121 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalTrackId=",0,(char*)NULL);
30122 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleId=",0,"Particle ID from De/Dx fit");
30123 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30124 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trunc_alg=",0,"truncate method");
30125 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiE=",0,"Number of sigama from e");
30126 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiMu=",0,"Number of sigama from muon");
30127 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiPi=",0,"Number of sigama from pion");
30128 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiK=",0,"Number of sigama from k");
30129 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiP=",0,"Number of sigama from p");
30130 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numGoodHits=",0,"No. of good de/dx hits(exclude overflow)");
30131 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numTotalHits=",0,"No. of good de/dx hits(include overflow)");
30132 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_probPH=",0,"Most probable pulse height from truncated mean");
30133 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_normPH=",0,"normalizd pulse height // Changed on Oct. 10 following by Wangdy");
30134 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errorPH=",0,"resolution of truncated mean ");
30135 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_twentyPH=",0,"de/dx value of bitrunction rate equal to 20% ");
30136 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi[5]=",0,"Number of Chi_dEdx for different particles");
30137 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_exp[5]=",0,"expected value of dE/dx for 5 particle hypotheses");
30138 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_sigma_dedx[5]=",0,"sigma value of dE/dx for 5 particle hypotheses");
30139 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pid_prob[5]=",0,"probability for each of the 5 particle hypotheses");
30140 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30141 }
30142 G__tag_memvar_reset();
30143}
30144
30145
30146 /* TRecMdcDedxHit */
30147static void G__setup_memvarTRecMdcDedxHit(void) {
30148 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
30149 { TRecMdcDedxHit *p; p=(TRecMdcDedxHit*)0x1000; if (p) { }
30150 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isGrouped=",0,(char*)NULL);
30151 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trkid=",0,"id of track containing this hit,if this hit belongs to no track, set as -1;");
30152 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcHitId=",0,"dE/dx hit reference to MdcHit;");
30153 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalHelixSegId=",0,"dE/dx hit reference to MdcKalHelixSeg;");
30154 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lr=",0,"flag indicating left or right 0:left 1:right 2:ambig");
30155 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
30156 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pathlength=",0,(char*)NULL);
30157 G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"m_dedx=",0,(char*)NULL);
30158 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30159 }
30160 G__tag_memvar_reset();
30161}
30162
30163
30164 /* TRecExtTrack */
30165static void G__setup_memvarTRecExtTrack(void) {
30166 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
30167 { TRecExtTrack *p; p=(TRecExtTrack*)0x1000; if (p) { }
30168 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
30169 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionX[5]=",0,"Position when the particle enters the TOF layer1.");
30170 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionY[5]=",0,"Position when the particle enters the TOF layer1");
30171 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionZ[5]=",0,"Position when the particle enters the TOF layer1");
30172 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumX[5]=",0,"Momentum when the particle enters the TOF layer1.");
30173 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumY[5]=",0,"Momentum when the particle enters the TOF layer1.");
30174 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumZ[5]=",0,"Momentum when the particle enters the TOF layer1.");
30175 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof1VolumeName[5]=",0,"Scintillator volume name");
30176 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof1VolumeNumber[5]=",0,"Scintillator volume number");
30177 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1[5]=",0,"Time of flight");
30178 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1Path[5]=",0,"Path of flight");
30179 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongZ[5]=",0,"Sigma Z");
30180 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongT[5]=",0,"Sigma along Z x R");
30181 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongX[5]=",0,"Sigma X");
30182 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongY[5]=",0,"Sigma Y");
30183 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1ErrorMatrix[5][6][6]=",0,"Error matrix 6x6 (x,p)");
30184 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionX[5]=",0,"Position when the particle enters the TOF layer2.");
30185 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionY[5]=",0,"Position when the particle enters the TOF layer2");
30186 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionZ[5]=",0,"Position when the particle enters the TOF layer2");
30187 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumX[5]=",0,"Momentum when the particle enters the TOF layer2");
30188 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumY[5]=",0,"Momentum when the particle enters the TOF layer2");
30189 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumZ[5]=",0,"Momentum when the particle enters the TOF layer2");
30190 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof2VolumeName[5]=",0,"Scintillator volume name");
30191 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof2VolumeNumber[5]=",0,"Scintillator volume number");
30192 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2[5]=",0,"Time of flight");
30193 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2Path[5]=",0,"Path of flight");
30194 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongZ[5]=",0,"Sigma Z");
30195 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongT[5]=",0,"Sigma along Z x R");
30196 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongX[5]=",0,"Sigma X");
30197 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongY[5]=",0,"Sigma Y");
30198 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2ErrorMatrix[5][6][6]=",0,"Error matrix 6x6 (x,p)");
30199 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionX[5]=",0,"Position 2.");
30200 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionY[5]=",0,"Position 2");
30201 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionZ[5]=",0,"Position 2");
30202 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumX[5]=",0,"Momentum ");
30203 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumY[5]=",0,"Momentum ");
30204 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumZ[5]=",0,"Momentum ");
30205 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myEmcVolumeName[5]=",0,"Scintillator volume name");
30206 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myEmcVolumeNumber[5]=",0,"Scintillator volume number");
30207 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongTheta[5]=",0,(char*)NULL);
30208 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongPhi[5]=",0,(char*)NULL);
30209 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcErrorMatrix[5][6][6]=",0,"Error matrix 6x6 (x,p)");
30210 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPath[5]=",0,(char*)NULL);
30211 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionX[5]=",0,"Position 2.");
30212 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionY[5]=",0,"Position 2");
30213 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionZ[5]=",0,"Position 2");
30214 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumX[5]=",0,"Momentum ");
30215 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumY[5]=",0,"Momentum ");
30216 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumZ[5]=",0,"Momentum ");
30217 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myMucVolumeName[5]=",0,"Scintillator volume name");
30218 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myMucVolumeNumber[5]=",0,"Scintillator volume number");
30219 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongZ[5]=",0,(char*)NULL);
30220 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongT[5]=",0,(char*)NULL);
30221 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongX[5]=",0,(char*)NULL);
30222 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongY[5]=",0,(char*)NULL);
30223 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucErrorMatrix[5][6][6]=",0,(char*)NULL);
30224 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"mySize[5]=",0,"size of the vector ");
30225 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPositionX[5]=",0,(char*)NULL);
30226 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPositionY[5]=",0,(char*)NULL);
30227 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPositionZ[5]=",0,(char*)NULL);
30228 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myMomentumX[5]=",0,(char*)NULL);
30229 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myMomentumY[5]=",0,(char*)NULL);
30230 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myMomentumZ[5]=",0,(char*)NULL);
30231 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"myVolumeName[5]=",0,(char*)NULL);
30232 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"myVolumeNumber[5]=",0,(char*)NULL);
30233 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongZ[5]=",0,(char*)NULL);
30234 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongT[5]=",0,(char*)NULL);
30235 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongX[5]=",0,(char*)NULL);
30236 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongY[5]=",0,(char*)NULL);
30237 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),G__defined_typename("vector<vector<Double_t> >"),-1,4,"myErrorMatrix[5]=",0,(char*)NULL);
30238 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30239 }
30240 G__tag_memvar_reset();
30241}
30242
30243
30244 /* TRecEvTime */
30245static void G__setup_memvarTRecEvTime(void) {
30246 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
30247 { TRecEvTime *p; p=(TRecEvTime*)0x1000; if (p) { }
30248 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,(char*)NULL);
30249 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_estime=",0,(char*)NULL);
30250 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_quality=",0,(char*)NULL);
30251 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30252 }
30253 G__tag_memvar_reset();
30254}
30255
30256
30257 /* TRecMdcKalHelixSeg */
30258static void G__setup_memvarTRecMdcKalHelixSeg(void) {
30259 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
30260 { TRecMdcKalHelixSeg *p; p=(TRecMdcKalHelixSeg*)0x1000; if (p) { }
30261 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackid=",0,"id of track containing this hit,if this hit ");
30262 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lr=",0,"flag indicating left or right 0:left 1:right 2:ambig");
30263 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
30264 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tdc=",0,"corrected TDC");
30265 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_adc=",0,"corrected ADC");
30266 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhit=",0,"z coordinate of the hit");
30267 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"time of flight ");
30268 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_docaincl=",0,"distance of closesest approach for helix in the cell");
30269 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_docaexcl=",0,(char*)NULL);
30270 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dd=",0,"drift distance ");
30271 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_entra=",0,"entrance angle in azimuth");
30272 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftT=",0,"drift time");
30273 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helixincl[5]=",0,(char*)NULL);
30274 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helixexcl[5]=",0,(char*)NULL);
30275 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30276 }
30277 G__tag_memvar_reset();
30278}
30279
30280
30281 /* TRecZddChannel */
30282static void G__setup_memvarTRecZddChannel(void) {
30283 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
30284 { TRecZddChannel *p; p=(TRecZddChannel*)0x1000; if (p) { }
30285 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_chId=",0,(char*)NULL);
30286 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_scanCode=",0,(char*)NULL);
30287 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_baseLine=",0,(char*)NULL);
30288 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_phase=",0,(char*)NULL);
30289 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),G__defined_typename("vector<std::pair<Int_t,Float_t> >"),-1,4,"m_frags=",0,(char*)NULL);
30290 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30291 }
30292 G__tag_memvar_reset();
30293}
30294
30295
30296 /* TRecTrackEvent */
30297static void G__setup_memvarTRecTrackEvent(void) {
30298 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
30299 { TRecTrackEvent *p; p=(TRecTrackEvent*)0x1000; if (p) { }
30300 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcTrackCol=",0,(char*)NULL);
30301 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcTrackCol=",0,"-> ");
30302 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcHitCol=",0,(char*)NULL);
30303 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcHitCol=",0,"->");
30304 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcHitCol=",0,(char*)NULL);
30305 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcHitCol=",0,"-> ");
30306 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcClusterCol=",0,(char*)NULL);
30307 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcClusterCol=",0,"-> ");
30308 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcShowerCol=",0,(char*)NULL);
30309 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcShowerCol=",0,"-> ");
30310 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofTrackCol=",0,(char*)NULL);
30311 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recTofTrackCol=",0,"->");
30312 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucTrackCol=",0,(char*)NULL);
30313 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMucTrackCol=",0,"->");
30314 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcDedxCol=",0,(char*)NULL);
30315 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcDedxCol=",0,"-> ");
30316 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcDedxHitCol=",0,(char*)NULL);
30317 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcDedxHitCol=",0,"->");
30318 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticExtTrackCol=",0,(char*)NULL);
30319 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recExtTrackCol=",0,"-> ");
30320 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcKalTrackCol=",0,(char*)NULL);
30321 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcKalTrackCol=",0,"->");
30322 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcKalHelixSegCol=",0,(char*)NULL);
30323 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcKalHelixSegCol=",0,"->");
30324 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvTimeCol=",0,(char*)NULL);
30325 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEvTimeCol=",0,"->");
30326 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecZddChannelCol=",0,(char*)NULL);
30327 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recZddChannelCol=",0,"->");
30328 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30329 }
30330 G__tag_memvar_reset();
30331}
30332
30333
30334 /* TMdcTrack */
30335static void G__setup_memvarTMdcTrack(void) {
30336 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
30337 { TMdcTrack *p; p=(TMdcTrack*)0x1000; if (p) { }
30338 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id Wensp add 2005-10-19 ");
30339 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helix[5]=",0,"5 track parameters");
30340 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[15]=",0,"Error Matrix");
30341 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"Track Fit Quality");
30342 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,(char*)NULL);
30343 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,(char*)NULL);
30344 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nster=",0,"number of stereo hits contained");
30345 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer=",0,"number of layer track passed");
30346 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_firstLayer=",0,(char*)NULL);
30347 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lastLayer=",0,(char*)NULL);
30348 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30349 }
30350 G__tag_memvar_reset();
30351}
30352
30353
30354 /* TEmcTrack */
30355static void G__setup_memvarTEmcTrack(void) {
30356 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
30357 { TEmcTrack *p; p=(TEmcTrack*)0x1000; if (p) { }
30358 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19 ");
30359 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Total number of hits");
30360 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30361 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,"Cell ID");
30362 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_module=",0,"Module");
30363 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_x=",0,"Shower coordinates and errors");
30364 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_y=",0,(char*)NULL);
30365 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_z=",0,(char*)NULL);
30366 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dTheta=",0,(char*)NULL);
30367 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dPhi=",0,(char*)NULL);
30368 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Total energy observed in Emc");
30369 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dE=",0,(char*)NULL);
30370 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eSeed=",0,"// Energy of seed, only one");
30371 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e3x3=",0,"Energy of 3x3 crystals, totally 9 ones");
30372 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e5x5=",0,"Energy of 5x5 crystals, totally 25 ones");
30373 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,"Time measurement");
30374 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_secondMoment=",0,"add 2006-07-03");
30375 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_latMoment=",0,"Lateral moment");
30376 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a20Moment=",0,"Zernike moment");
30377 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a42Moment=",0,(char*)NULL);
30378 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[6]=",0,"Error Matrix: 0:dxx, 1:dyy, 2:dzz");
30379 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30380 }
30381 G__tag_memvar_reset();
30382}
30383
30384
30385 /* TMucTrack */
30386static void G__setup_memvarTMucTrack(void) {
30387 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
30388 { TMucTrack *p; p=(TMucTrack*)0x1000; if (p) { }
30389 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track ID wensp Add 2005-10-19");
30390 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,"Muc Identifier");
30391 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Muc Status");
30392 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,"Method of judge?");
30393 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_startPart=",0,"In which part does the start position of track locate");
30394 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_endPart=",0,"In which part does the end position of track locate");
30395 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_brLastLayer=",0,"Last layer with hits in barrel ");
30396 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ecLastLayer=",0,"Last layer with hits in endcap ");
30397 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Number of hits on track");
30398 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numLayers=",0,"Number of layer with hits");
30399 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_maxHitsInLayer=",0,"Max number of hits in a layer");
30400 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depth=",0,"Depth of iron penetrated");
30401 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"Fit parameters");
30402 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_dof=",0,(char*)NULL);
30403 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_rms=",0,(char*)NULL);
30404 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPos=",0,"x position of muc track vertex");
30405 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPos=",0,"y position of muc track vertex");
30406 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPos=",0,"z position of muc track vertex");
30407 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosSigma=",0,(char*)NULL);
30408 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosSigma=",0,(char*)NULL);
30409 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosSigma=",0,(char*)NULL);
30410 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,"px on muc track vertex");
30411 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,"py on muc track vertex");
30412 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,"pz on muc track vertex");
30413 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_distance=",0,(char*)NULL);
30414 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaPhi=",0,(char*)NULL);
30415 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kalrechi2=",0,(char*)NULL);
30416 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kaldof=",0,(char*)NULL);
30417 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kaldepth=",0,(char*)NULL);
30418 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalbrLastLayer=",0,(char*)NULL);
30419 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalecLastLayer=",0,(char*)NULL);
30420 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30421 }
30422 G__tag_memvar_reset();
30423}
30424
30425
30426 /* TMdcDedx */
30427static void G__setup_memvarTMdcDedx(void) {
30428 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
30429 { TMdcDedx *p; p=(TMdcDedx*)0x1000; if (p) { }
30430 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
30431 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleId=",0,"Particle ID from De/Dx fit");
30432 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
30433 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trunc_alg=",0,"truncate method");
30434 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiE=",0,"Number of sigama from e");
30435 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiMu=",0,"Number of sigama from muon");
30436 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiPi=",0,"Number of sigama from pion");
30437 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiK=",0,"Number of sigama from k");
30438 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiP=",0,"Number of sigama from p");
30439 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numGoodHits=",0,"No. of good de/dx hits(exclude overflow)");
30440 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numTotalHits=",0,"No. of good de/dx hits(include overflow)");
30441 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_probPH=",0,"Most probable pulse height from truncated mean");
30442 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_normPH=",0,"normalizd pulse height // Changed on Oct. 10 following by Wangdy");
30443 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errorPH=",0,"resolution of truncated mean ");
30444 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_twentyPH=",0,"de/dx value of bitrunction rate equal to 20% ");
30445 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30446 }
30447 G__tag_memvar_reset();
30448}
30449
30450
30451 /* TExtTrack */
30452static void G__setup_memvarTExtTrack(void) {
30453 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
30454 { TExtTrack *p; p=(TExtTrack*)0x1000; if (p) { }
30455 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
30456 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionX=",0,"Position when the particle enters the TOF layer1.");
30457 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionY=",0,"Position when the particle enters the TOF layer1");
30458 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionZ=",0,"Position when the particle enters the TOF layer1");
30459 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumX=",0,"Momentum when the particle enters the TOF layer1.");
30460 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumY=",0,"Momentum when the particle enters the TOF layer1.");
30461 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumZ=",0,"Momentum when the particle enters the TOF layer1.");
30462 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof1VolumeName=",0,"Scintillator volume name");
30463 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof1VolumeNumber=",0,"Scintillator volume number");
30464 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1=",0,"Time of flight");
30465 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1Path=",0,"Path of flight");
30466 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongZ=",0,"Sigma Z");
30467 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongT=",0,"Sigma along Z x R");
30468 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongX=",0,"Sigma X");
30469 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongY=",0,"Sigma Y");
30470 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1ErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
30471 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionX=",0,"Position when the particle enters the TOF layer2.");
30472 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionY=",0,"Position when the particle enters the TOF layer2");
30473 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionZ=",0,"Position when the particle enters the TOF layer2");
30474 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumX=",0,"Momentum when the particle enters the TOF layer2");
30475 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumY=",0,"Momentum when the particle enters the TOF layer2");
30476 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumZ=",0,"Momentum when the particle enters the TOF layer2");
30477 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof2VolumeName=",0,"Scintillator volume name");
30478 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof2VolumeNumber=",0,"Scintillator volume number");
30479 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2=",0,"Time of flight");
30480 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2Path=",0,"Path of flight");
30481 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongZ=",0,"Sigma Z");
30482 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongT=",0,"Sigma along Z x R");
30483 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongX=",0,"Sigma X");
30484 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongY=",0,"Sigma Y");
30485 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2ErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
30486 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionX=",0,"Position 2.");
30487 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionY=",0,"Position 2");
30488 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionZ=",0,"Position 2");
30489 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumX=",0,"Momentum ");
30490 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumY=",0,"Momentum ");
30491 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumZ=",0,"Momentum ");
30492 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myEmcVolumeName=",0,"Scintillator volume name");
30493 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myEmcVolumeNumber=",0,"Scintillator volume number");
30494 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongTheta=",0,(char*)NULL);
30495 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongPhi=",0,(char*)NULL);
30496 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
30497 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPath=",0,(char*)NULL);
30498 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionX=",0,"Position 2.");
30499 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionY=",0,"Position 2");
30500 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionZ=",0,"Position 2");
30501 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumX=",0,"Momentum ");
30502 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumY=",0,"Momentum ");
30503 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumZ=",0,"Momentum ");
30504 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myMucVolumeName=",0,"Scintillator volume name");
30505 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myMucVolumeNumber=",0,"Scintillator volume number");
30506 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongZ=",0,(char*)NULL);
30507 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongT=",0,(char*)NULL);
30508 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongX=",0,(char*)NULL);
30509 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongY=",0,(char*)NULL);
30510 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucErrorMatrix[21]=",0,(char*)NULL);
30511 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30512 }
30513 G__tag_memvar_reset();
30514}
30515
30516
30517 /* TMdcKalTrack */
30518static void G__setup_memvarTMdcKalTrack(void) {
30519 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
30520 { TMdcKalTrack *p; p=(TMdcKalTrack*)0x1000; if (p) { }
30521 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,(char*)NULL);
30522 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat[5]=",0,(char*)NULL);
30523 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat2[5]=",0,(char*)NULL);
30524 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq[5]=",0,(char*)NULL);
30525 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndf[5]=",0,(char*)NULL);
30526 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer[5]=",0,(char*)NULL);
30527 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix[5]=",0,"5 track parameters at zero point for pi ");
30528 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror[15]=",0,"error matrix at zero point for pion ");
30529 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_e[5]=",0,"5 track parameters at zero point for el ");
30530 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_e[15]=",0,"error matrix at zero point for electron ");
30531 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_mu[5]=",0,"5 track parameters at zero point for mu ");
30532 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_mu[15]=",0,"error matrix at zero point for muon ; ");
30533 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_k[5]=",0,"5 track parameters at zero point for ka ");
30534 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_k[15]=",0,"error matrix at zero point for kaon ");
30535 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_p[5]=",0,"5 track parameters at zero point for pr ");
30536 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_p[15]=",0,"error matrix at zero point for proton ");
30537 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix[5]=",0,"5 track parameters at first Mdchit for pi ");
30538 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror[15]=",0,"error matrix at first Mdc hit for pion ");
30539 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_e[5]=",0,(char*)NULL);
30540 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_e[15]=",0,(char*)NULL);
30541 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_mu[5]=",0,(char*)NULL);
30542 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_mu[15]=",0,(char*)NULL);
30543 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_k[5]=",0,(char*)NULL);
30544 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_k[15]=",0,(char*)NULL);
30545 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_p[5]=",0,(char*)NULL);
30546 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_p[15]=",0,(char*)NULL);
30547 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30548 }
30549 G__tag_memvar_reset();
30550}
30551
30552
30553 /* TDstEvent */
30554static void G__setup_memvarTDstEvent(void) {
30555 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
30556 { TDstEvent *p; p=(TDstEvent*)0x1000; if (p) { }
30557 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcTrackCol=",0,(char*)NULL);
30558 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcTrackCol=",0,"->");
30559 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcTrackCol=",0,(char*)NULL);
30560 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcTrackCol=",0,"-> ");
30561 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofTrackCol=",0,(char*)NULL);
30562 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofTrackCol=",0,"->");
30563 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucTrackCol=",0,(char*)NULL);
30564 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucTrackCol=",0,"->");
30565 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcDedxCol=",0,(char*)NULL);
30566 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcDedxCol=",0,"->");
30567 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticExtTrackCol=",0,(char*)NULL);
30568 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_extTrackCol=",0,"->");
30569 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcKalTrackCol=",0,(char*)NULL);
30570 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcKalTrackCol=",0,"->");
30571 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30572 }
30573 G__tag_memvar_reset();
30574}
30575
30576
30577 /* TMdcMc */
30578static void G__setup_memvarTMdcMc(void) {
30579 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
30580 { TMdcMc *p; p=(TMdcMc*)0x1000; if (p) { }
30581 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30582 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30583 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30584 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30585 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30586 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftDistance=",0,(char*)NULL);
30587 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
30588 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_posFlag=",0,(char*)NULL);
30589 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30590 }
30591 G__tag_memvar_reset();
30592}
30593
30594
30595 /* TEmcMc */
30596static void G__setup_memvarTEmcMc(void) {
30597 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
30598 { TEmcMc *p; p=(TEmcMc*)0x1000; if (p) { }
30599 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hitEmc=",0,(char*)NULL);
30600 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_PDGCode=",0,(char*)NULL);
30601 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_PDGCharge=",0,(char*)NULL);
30602 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
30603 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30604 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30605 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30606 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30607 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30608 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30609 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30610 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30611 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
30612 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),G__defined_typename("map<Int_t,Double_t>"),-1,4,"m_hitMap=",0,(char*)NULL);
30613 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30614 }
30615 G__tag_memvar_reset();
30616}
30617
30618
30619 /* TTofMc */
30620static void G__setup_memvarTTofMc(void) {
30621 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
30622 { TTofMc *p; p=(TTofMc*)0x1000; if (p) { }
30623 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30624 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30625 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30626 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30627 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30628 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30629 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30630 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30631 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_trackLength=",0,(char*)NULL);
30632 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_flightTime=",0,(char*)NULL);
30633 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30634 }
30635 G__tag_memvar_reset();
30636}
30637
30638
30639 /* TMucMc */
30640static void G__setup_memvarTMucMc(void) {
30641 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
30642 { TMucMc *p; p=(TMucMc*)0x1000; if (p) { }
30643 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
30644 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30645 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
30646 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
30647 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
30648 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30649 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30650 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30651 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
30652 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30653 }
30654 G__tag_memvar_reset();
30655}
30656
30657
30658 /* TMcParticle */
30659static void G__setup_memvarTMcParticle(void) {
30660 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
30661 { TMcParticle *p; p=(TMcParticle*)0x1000; if (p) { }
30662 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("DECAYED=%lldLL",(long long)TMcParticle::DECAYED).data(),0,(char*)NULL);
30663 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("DECAYFLT=%lldLL",(long long)TMcParticle::DECAYFLT).data(),0,(char*)NULL);
30664 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("PRIMARY=%lldLL",(long long)TMcParticle::PRIMARY).data(),0,(char*)NULL);
30665 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("LEAF=%lldLL",(long long)TMcParticle::LEAF).data(),0,(char*)NULL);
30666 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("ERROR=%lldLL",(long long)TMcParticle::ERROR).data(),0,(char*)NULL);
30667 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleID=",0,(char*)NULL);
30668 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
30669 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexIndex0=",0,(char*)NULL);
30670 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexIndex1=",0,(char*)NULL);
30671 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_statusFlags=",0,(char*)NULL);
30672 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xInitialPosition=",0,(char*)NULL);
30673 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yInitialPosition=",0,(char*)NULL);
30674 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zInitialPosition=",0,(char*)NULL);
30675 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tInitialPosition=",0,(char*)NULL);
30676 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xFinalPosition=",0,(char*)NULL);
30677 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yFinalPosition=",0,(char*)NULL);
30678 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zFinalPosition=",0,(char*)NULL);
30679 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tFinalPosition=",0,(char*)NULL);
30680 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xInitialMomentum=",0,(char*)NULL);
30681 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yInitialMomentum=",0,(char*)NULL);
30682 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zInitialMomentum=",0,(char*)NULL);
30683 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eInitialMomentum=",0,(char*)NULL);
30684 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mother=",0,(char*)NULL);
30685 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_daughters=",0,(char*)NULL);
30686 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30687 }
30688 G__tag_memvar_reset();
30689}
30690
30691
30692 /* TMcEvent */
30693static void G__setup_memvarTMcEvent(void) {
30694 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
30695 { TMcEvent *p; p=(TMcEvent*)0x1000; if (p) { }
30696 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcMcHitCol=",0,(char*)NULL);
30697 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcMcHitCol=",0,"-> ");
30698 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcMcHitCol=",0,(char*)NULL);
30699 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcMcHitCol=",0,"->");
30700 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofMcHitCol=",0,(char*)NULL);
30701 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofMcHitCol=",0,"->");
30702 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucMcHitCol=",0,(char*)NULL);
30703 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucMcHitCol=",0,"->");
30704 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMcParticleCol=",0,(char*)NULL);
30705 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mcParticleCol=",0,"->");
30706 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30707 }
30708 G__tag_memvar_reset();
30709}
30710
30711
30712 /* TEvtHeader */
30713static void G__setup_memvarTEvtHeader(void) {
30714 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
30715 { TEvtHeader *p; p=(TEvtHeader*)0x1000; if (p) { }
30716 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_eventId=",0,(char*)NULL);
30717 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_runId=",0,(char*)NULL);
30718 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_time=",0,(char*)NULL);
30719 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_eventTag=",0,(char*)NULL);
30720 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_flag1=",0,(char*)NULL);
30721 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_flag2=",0,(char*)NULL);
30722 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30723 }
30724 G__tag_memvar_reset();
30725}
30726
30727
30728 /* TEvtNavigator */
30729static void G__setup_memvarTEvtNavigator(void) {
30730 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
30731 { TEvtNavigator *p; p=(TEvtNavigator*)0x1000; if (p) { }
30732 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcMdcMcHits=",0,"auxillary list McParticle id <-> MdcMcHit (=MdcRecHit) id");
30733 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcMdcTracks=",0,"McParticle id <-> RecMdcTrack (RecMdcKalTrack) id");
30734 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcEmcMcHits=",0,"auxiallry list McParticle id <-> EmcMcHit (=EmcRecHit) id");
30735 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcEmcRecShowers=",0,"McParticle id <-> EmcRecShower id");
30736 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30737 }
30738 G__tag_memvar_reset();
30739}
30740
30741
30742 /* TTrigData */
30743static void G__setup_memvarTTrigData(void) {
30744 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
30745 { TTrigData *p; p=(TTrigData*)0x1000; if (p) { }
30746 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_preScale=",0,"PreScale for bhabha events");
30747 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trigcond[48]=",0,"Trigger conditions from 0 to 47");
30748 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trigChan[16]=",0,"Trigger channel from 0 to 15");
30749 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_timeWindow=",0,"The time window of trigger system");
30750 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_Timing=",0,"Time type, 0: No timing 1: TOF 2: MDC 3: EMC");
30751 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30752 }
30753 G__tag_memvar_reset();
30754}
30755
30756
30757 /* TTrigEvent */
30758static void G__setup_memvarTTrigEvent(void) {
30759 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
30760 { TTrigEvent *p; p=(TTrigEvent*)0x1000; if (p) { }
30761 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),-1,-2,4,"s_staticTrigData=",0,(char*)NULL);
30762 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),-1,-1,4,"m_trigData=",0,"->");
30763 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30764 }
30765 G__tag_memvar_reset();
30766}
30767
30768
30769 /* THltRaw */
30770static void G__setup_memvarTHltRaw(void) {
30771 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
30772 { THltRaw *p; p=(THltRaw*)0x1000; if (p) { }
30773 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30774 }
30775 G__tag_memvar_reset();
30776}
30777
30778
30779 /* THltInf */
30780static void G__setup_memvarTHltInf(void) {
30781 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
30782 { THltInf *p; p=(THltInf*)0x1000; if (p) { }
30783 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_evtType=",0,(char*)NULL);
30784 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_algProcess=",0,(char*)NULL);
30785 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_criTable=",0,(char*)NULL);
30786 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_verNumber=",0,(char*)NULL);
30787 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eTotal=",0,(char*)NULL);
30788 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_subNumber=",0,(char*)NULL);
30789 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_conNumber=",0,(char*)NULL);
30790 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_mdcData=",0,(char*)NULL);
30791 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_tofData=",0,(char*)NULL);
30792 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_emcData=",0,(char*)NULL);
30793 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_mucData=",0,(char*)NULL);
30794 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_conData=",0,(char*)NULL);
30795 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30796 }
30797 G__tag_memvar_reset();
30798}
30799
30800
30801 /* TDstHltInf */
30802static void G__setup_memvarTDstHltInf(void) {
30803 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
30804 { TDstHltInf *p; p=(TDstHltInf*)0x1000; if (p) { }
30805 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_evtType=",0,(char*)NULL);
30806 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_algProcess=",0,(char*)NULL);
30807 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_criTable=",0,(char*)NULL);
30808 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_verNumber=",0,(char*)NULL);
30809 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eTotal=",0,(char*)NULL);
30810 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_subNumber=",0,(char*)NULL);
30811 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_conNumber=",0,(char*)NULL);
30812 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30813 }
30814 G__tag_memvar_reset();
30815}
30816
30817
30818 /* THltEvent */
30819static void G__setup_memvarTHltEvent(void) {
30820 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
30821 { THltEvent *p; p=(THltEvent*)0x1000; if (p) { }
30822 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticHltRawCol=",0,(char*)NULL);
30823 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_hltRawCol=",0,"->");
30824 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),-1,-2,4,"s_staticHltInf=",0,(char*)NULL);
30825 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),-1,-1,4,"m_hltInf=",0,"->");
30826 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),-1,-2,4,"s_staticDstHltInf=",0,(char*)NULL);
30827 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),-1,-1,4,"m_dstHltInf=",0,"->");
30828 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30829 }
30830 G__tag_memvar_reset();
30831}
30832
30833
30834 /* TDisTrack */
30835static void G__setup_memvarTDisTrack(void) {
30836 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
30837 { TDisTrack *p; p=(TDisTrack*)0x1000; if (p) { }
30838 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcTrackCol=",0,"->");
30839 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recTofTrackCol=",0,"->");
30840 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcHitCol=",0,"->");
30841 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMucTrackCol=",0,"->");
30842 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcShowerCol=",0,"->");
30843 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30844 }
30845 G__tag_memvar_reset();
30846}
30847
30848
30849 /* TEvtRecEvent */
30850static void G__setup_memvarTEvtRecEvent(void) {
30851 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
30852 { TEvtRecEvent *p; p=(TEvtRecEvent*)0x1000; if (p) { }
30853 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tottks=",0,"total tracks");
30854 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nchrg=",0,"total charged tracks");
30855 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nneu=",0,"total neutral tracks");
30856 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nvee=",0,"number of VEEs: Ks, Lambda, gamma conversion");
30857 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_npi0=",0,"number of pi0'");
30858 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_neta=",0,"number of eta'");
30859 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndtag=",0,"number of dtags'");
30860 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30861 }
30862 G__tag_memvar_reset();
30863}
30864
30865
30866 /* TEvtRecTrack */
30867static void G__setup_memvarTEvtRecTrack(void) {
30868 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
30869 { TEvtRecTrack *p; p=(TEvtRecTrack*)0x1000; if (p) { }
30870 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,(char*)NULL);
30871 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
30872 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,(char*)NULL);
30873 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcTrackId=",0,(char*)NULL);
30874 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalTrackId=",0,(char*)NULL);
30875 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcDedxId=",0,(char*)NULL);
30876 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_extTrackId=",0,(char*)NULL);
30877 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_emcShowerId=",0,(char*)NULL);
30878 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mucTrackId=",0,(char*)NULL);
30879 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_tofTrackIds=",0,(char*)NULL);
30880 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30881 }
30882 G__tag_memvar_reset();
30883}
30884
30885
30886 /* TEvtRecPrimaryVertex */
30887static void G__setup_memvarTEvtRecPrimaryVertex(void) {
30888 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
30889 { TEvtRecPrimaryVertex *p; p=(TEvtRecPrimaryVertex*)0x1000; if (p) { }
30890 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isValid=",0,(char*)NULL);
30891 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTracks=",0,"number of tracks contributing to vertex fitting");
30892 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_trackIdList=",0,"id list of tracks contributing to vertex fitting");
30893 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"chi square of vertex fitting");
30894 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,"degree of freedom ");
30895 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_fitMethod=",0,"vertex fitting algorithm ");
30896 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vtx[3]=",0,"primary vertex position : (Vx, Vy, Vz)");
30897 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_Evtx[6]=",0,"error matrix of primary vertex ");
30898 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30899 }
30900 G__tag_memvar_reset();
30901}
30902
30903
30904 /* TEvtRecVeeVertex */
30905static void G__setup_memvarTEvtRecVeeVertex(void) {
30906 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
30907 { TEvtRecVeeVertex *p; p=(TEvtRecVeeVertex*)0x1000; if (p) { }
30908 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexId=",0,(char*)NULL);
30909 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexType=",0,"0 : Ks; 1 : Lambda; 2 : gamma conversion");
30910 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"chi square of vertex fitting");
30911 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,"degree of freedom");
30912 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass=",0,"mass of \"V\" type decay particle");
30913 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_w[7]=",0,"(px, py, pz, E, x, y, z) of \"V\" type decay particle");
30914 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_Ew[28]=",0,"error matrix");
30915 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_pair[2]=",0,"identification of daughter particles");
30916 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nCharge=",0,"total charges of daughter particles ");
30917 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTracks=",0,"total tracks of daughter particles");
30918 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_daughter[2]=",0,(char*)NULL);
30919 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30920 }
30921 G__tag_memvar_reset();
30922}
30923
30924
30925 /* TEvtRecPi0 */
30926static void G__setup_memvarTEvtRecPi0(void) {
30927 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
30928 { TEvtRecPi0 *p; p=(TEvtRecPi0*)0x1000; if (p) { }
30929 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_unconMass=",0,(char*)NULL);
30930 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq=",0,(char*)NULL);
30931 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPx=",0,(char*)NULL);
30932 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPy=",0,(char*)NULL);
30933 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPz=",0,(char*)NULL);
30934 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPe=",0,(char*)NULL);
30935 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPx=",0,(char*)NULL);
30936 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPy=",0,(char*)NULL);
30937 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPz=",0,(char*)NULL);
30938 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPe=",0,(char*)NULL);
30939 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hiEnGamma=",0,(char*)NULL);
30940 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_loEnGamma=",0,(char*)NULL);
30941 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30942 }
30943 G__tag_memvar_reset();
30944}
30945
30946
30947 /* TEvtRecEtaToGG */
30948static void G__setup_memvarTEvtRecEtaToGG(void) {
30949 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
30950 { TEvtRecEtaToGG *p; p=(TEvtRecEtaToGG*)0x1000; if (p) { }
30951 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_unconMass=",0,(char*)NULL);
30952 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq=",0,(char*)NULL);
30953 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPx=",0,(char*)NULL);
30954 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPy=",0,(char*)NULL);
30955 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPz=",0,(char*)NULL);
30956 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPe=",0,(char*)NULL);
30957 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPx=",0,(char*)NULL);
30958 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPy=",0,(char*)NULL);
30959 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPz=",0,(char*)NULL);
30960 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPe=",0,(char*)NULL);
30961 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hiEnGamma=",0,(char*)NULL);
30962 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_loEnGamma=",0,(char*)NULL);
30963 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30964 }
30965 G__tag_memvar_reset();
30966}
30967
30968
30969 /* TEvtRecDTag */
30970static void G__setup_memvarTEvtRecDTag(void) {
30971 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
30972 { TEvtRecDTag *p; p=(TEvtRecDTag*)0x1000; if (p) { }
30973 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_decayMode=",0,(char*)NULL);
30974 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,(char*)NULL);
30975 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beamE=",0,(char*)NULL);
30976 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass=",0,(char*)NULL);
30977 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mBC=",0,(char*)NULL);
30978 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaE=",0,(char*)NULL);
30979 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charge=",0,(char*)NULL);
30980 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charm=",0,(char*)NULL);
30981 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_numOfChildren=",0,(char*)NULL);
30982 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
30983 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
30984 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
30985 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pe=",0,(char*)NULL);
30986 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_tracks=",0,(char*)NULL);
30987 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_showers=",0,(char*)NULL);
30988 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_otherTracks=",0,(char*)NULL);
30989 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_otherShowers=",0,(char*)NULL);
30990 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_pionId=",0,(char*)NULL);
30991 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_kaonId=",0,(char*)NULL);
30992 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
30993 }
30994 G__tag_memvar_reset();
30995}
30996
30997
30998 /* TEvtRecObject */
30999static void G__setup_memvarTEvtRecObject(void) {
31000 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
31001 { TEvtRecObject *p; p=(TEvtRecObject*)0x1000; if (p) { }
31002 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),-1,-2,4,"s_staticEvtRecEvent=",0,(char*)NULL);
31003 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),-1,-1,4,"m_evtRecEvent=",0,"->");
31004 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecTrackCol=",0,(char*)NULL);
31005 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecTrackCol=",0,"->");
31006 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),-1,-2,4,"s_staticEvtRecPrimaryVertex=",0,(char*)NULL);
31007 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),-1,-1,4,"m_evtRecPrimaryVertex=",0,"->");
31008 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecVeeVertexCol=",0,(char*)NULL);
31009 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecVeeVertexCol=",0,"->");
31010 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecPi0Col=",0,(char*)NULL);
31011 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecPi0Col=",0,"->");
31012 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecEtaToGGCol=",0,(char*)NULL);
31013 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecEtaToGGCol=",0,"->");
31014 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecDTagCol=",0,(char*)NULL);
31015 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecDTagCol=",0,"->");
31016 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31017 }
31018 G__tag_memvar_reset();
31019}
31020
31021
31022 /* TMcHitTof */
31023static void G__setup_memvarTMcHitTof(void) {
31024 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
31025 { TMcHitTof *p; p=(TMcHitTof*)0x1000; if (p) { }
31026 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
31027 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_g4Index=",0,(char*)NULL);
31028 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
31029 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_scinNb=",0,(char*)NULL);
31030 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_edep=",0,(char*)NULL);
31031 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_stepL=",0,(char*)NULL);
31032 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_trackL=",0,(char*)NULL);
31033 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_pos=",0,(char*)NULL);
31034 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
31035 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaT=",0,(char*)NULL);
31036 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_pDirection=",0,(char*)NULL);
31037 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_momentum=",0,(char*)NULL);
31038 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charge=",0,(char*)NULL);
31039 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31040 }
31041 G__tag_memvar_reset();
31042}
31043
31044
31045 /* TMcHitMdc */
31046static void G__setup_memvarTMcHitMdc(void) {
31047 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
31048 { TMcHitMdc *p; p=(TMcHitMdc*)0x1000; if (p) { }
31049 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"trackID=",0,(char*)NULL);
31050 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"layerNo=",0,(char*)NULL);
31051 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cellNo=",0,(char*)NULL);
31052 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"edep=",0,(char*)NULL);
31053 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"pos=",0,(char*)NULL);
31054 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"driftD=",0,(char*)NULL);
31055 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"driftT=",0,(char*)NULL);
31056 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"globalT=",0,(char*)NULL);
31057 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"theta=",0,(char*)NULL);
31058 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"enterAngle=",0,(char*)NULL);
31059 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"posFlag=",0,(char*)NULL);
31060 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31061 }
31062 G__tag_memvar_reset();
31063}
31064
31065
31066 /* TMcDigiEmc */
31067static void G__setup_memvarTMcDigiEmc(void) {
31068 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
31069 { TMcDigiEmc *p; p=(TMcDigiEmc*)0x1000; if (p) { }
31070 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
31071 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTheta=",0,(char*)NULL);
31072 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nPhi=",0,(char*)NULL);
31073 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,(char*)NULL);
31074 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
31075 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
31076 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31077 }
31078 G__tag_memvar_reset();
31079}
31080
31081
31082 /* TMcHitEvent */
31083static void G__setup_memvarTMcHitEvent(void) {
31084 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
31085 { TMcHitEvent *p; p=(TMcHitEvent*)0x1000; if (p) { }
31086 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tTofMcHitCol=",0,"->");
31087 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tMdcMcHitCol=",0,"->");
31088 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tEmcMcDigiCol=",0,"->");
31089 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beamTime=",0,(char*)NULL);
31090 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31091 }
31092 G__tag_memvar_reset();
31093}
31094
31095
31096 /* TBossFullEvent */
31097static void G__setup_memvarTBossFullEvent(void) {
31098 G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
31099 { TBossFullEvent *p; p=(TBossFullEvent*)0x1000; if (p) { }
31100 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasEvtHeader=1LL",0,(char*)NULL);
31101 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasDigiEvent=2LL",0,(char*)NULL);
31102 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasDstEvent=4LL",0,(char*)NULL);
31103 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasMcEvent=8LL",0,(char*)NULL);
31104 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasTrigEvent=16LL",0,(char*)NULL);
31105 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasHltEvent=32LL",0,(char*)NULL);
31106 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasRecTrackEvent=64LL",0,(char*)NULL);
31107 G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasEvtRecObject=128LL",0,(char*)NULL);
31108 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mask=",0,(char*)NULL);
31109 G__memvar_setup((void*)((long)(&p->m_EvtHeader)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader),-1,-1,1,"m_EvtHeader=",0,"->");
31110 G__memvar_setup((void*)((long)(&p->m_digiEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent),-1,-1,1,"m_digiEvt=",0,"->");
31111 G__memvar_setup((void*)((long)(&p->m_dstEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent),-1,-1,1,"m_dstEvt=",0,"->");
31112 G__memvar_setup((void*)((long)(&p->m_mcEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent),-1,-1,1,"m_mcEvt=",0,"->");
31113 G__memvar_setup((void*)((long)(&p->m_trigEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent),-1,-1,1,"m_trigEvt=",0,"->");
31114 G__memvar_setup((void*)((long)(&p->m_hltEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent),-1,-1,1,"m_hltEvt=",0,"->");
31115 G__memvar_setup((void*)((long)(&p->m_rectrackEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent),-1,-1,1,"m_rectrackEvt=",0,"->");
31116 G__memvar_setup((void*)((long)(&p->m_evtRecObject)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject),-1,-1,1,"m_evtRecObject=",0,"->");
31117 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
31118 }
31119 G__tag_memvar_reset();
31120}
31121
31122extern "C" void G__cpp_setup_memvarRootEventData_rootcint() {
31123}
31124/***********************************************************
31125************************************************************
31126************************************************************
31127************************************************************
31128************************************************************
31129************************************************************
31130************************************************************
31131***********************************************************/
31132
31133/*********************************************************
31134* Member function information setup for each class
31135*********************************************************/
31136static void G__setup_memfuncTJobInfo(void) {
31137 /* TJobInfo */
31138 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
31139 G__memfunc_setup("TJobInfo",763,G__RootEventData_rootcint_168_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31140 G__memfunc_setup("getBossVer",1028,G__RootEventData_rootcint_168_0_2, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31141 G__memfunc_setup("getJobOptions",1351,G__RootEventData_rootcint_168_0_3, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31142 G__memfunc_setup("getDecayOptions",1554,G__RootEventData_rootcint_168_0_4, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31143 G__memfunc_setup("getTotEvtNo",1123,G__RootEventData_rootcint_168_0_5, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31144 G__memfunc_setup("setBossVer",1040,G__RootEventData_rootcint_168_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - ver", (char*)NULL, (void*) NULL, 0);
31145 G__memfunc_setup("addJobOptions",1328,G__RootEventData_rootcint_168_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - opt", (char*)NULL, (void*) NULL, 0);
31146 G__memfunc_setup("setJobOptions",1363,G__RootEventData_rootcint_168_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >' 'vector<string>' 0 - opt", (char*)NULL, (void*) NULL, 0);
31147 G__memfunc_setup("setDecayOptions",1566,G__RootEventData_rootcint_168_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - opt", (char*)NULL, (void*) NULL, 0);
31148 G__memfunc_setup("setTotEvtNo",1135,G__RootEventData_rootcint_168_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<int>' 0 - i", (char*)NULL, (void*) NULL, 0);
31149 G__memfunc_setup("Class",502,G__RootEventData_rootcint_168_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TJobInfo::Class) ), 0);
31150 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_168_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TJobInfo::Class_Name) ), 0);
31151 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_168_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TJobInfo::Class_Version) ), 0);
31152 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_168_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TJobInfo::Dictionary) ), 0);
31153 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31154 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31155 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31156 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_168_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31157 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_168_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TJobInfo::DeclFileName) ), 0);
31158 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_168_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TJobInfo::ImplFileLine) ), 0);
31159 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_168_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TJobInfo::ImplFileName) ), 0);
31160 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_168_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TJobInfo::DeclFileLine) ), 0);
31161 // automatic copy constructor
31162 G__memfunc_setup("TJobInfo", 763, G__RootEventData_rootcint_168_0_23, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo), -1, 0, 1, 1, 1, 0, "u 'TJobInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
31163 // automatic destructor
31164 G__memfunc_setup("~TJobInfo", 889, G__RootEventData_rootcint_168_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31165 // automatic assignment operator
31166 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_168_0_25, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo), -1, 1, 1, 1, 1, 0, "u 'TJobInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
31167 G__tag_memfunc_reset();
31168}
31169
31170static void G__setup_memfuncTRawData(void) {
31171 /* TRawData */
31172 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
31173 G__memfunc_setup("TRawData",760,G__RootEventData_rootcint_200_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31174 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_200_0_2, 121, -1, -1, 0, 3, 1, 1, 0,
31175"h - 'UInt_t' 0 - id h - 'UInt_t' 0 '0' time "
31176"h - 'UInt_t' 0 '0' charge", (char*)NULL, (void*) NULL, 0);
31177 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
31178 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);
31179 G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_200_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - trackIndex", (char*)NULL, (void*) NULL, 0);
31180 G__memfunc_setup("getIntId",792,G__RootEventData_rootcint_200_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31181 G__memfunc_setup("getTimeChannel",1416,G__RootEventData_rootcint_200_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31182 G__memfunc_setup("getChargeChannel",1603,G__RootEventData_rootcint_200_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31183 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_200_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31184 G__memfunc_setup("Class",502,G__RootEventData_rootcint_200_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRawData::Class) ), 0);
31185 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_200_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRawData::Class_Name) ), 0);
31186 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_200_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRawData::Class_Version) ), 0);
31187 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_200_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRawData::Dictionary) ), 0);
31188 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31189 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31190 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31191 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_200_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31192 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_200_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRawData::DeclFileName) ), 0);
31193 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_200_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRawData::ImplFileLine) ), 0);
31194 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_200_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRawData::ImplFileName) ), 0);
31195 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_200_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRawData::DeclFileLine) ), 0);
31196 // automatic copy constructor
31197 G__memfunc_setup("TRawData", 760, G__RootEventData_rootcint_200_0_22, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData), -1, 0, 1, 1, 1, 0, "u 'TRawData' - 11 - -", (char*) NULL, (void*) NULL, 0);
31198 // automatic destructor
31199 G__memfunc_setup("~TRawData", 886, G__RootEventData_rootcint_200_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31200 // automatic assignment operator
31201 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_200_0_24, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData), -1, 1, 1, 1, 1, 0, "u 'TRawData' - 11 - -", (char*) NULL, (void*) NULL, 0);
31202 G__tag_memfunc_reset();
31203}
31204
31205static void G__setup_memfuncTMdcDigi(void) {
31206 /* TMdcDigi */
31207 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
31208 G__memfunc_setup("TMdcDigi",741,G__RootEventData_rootcint_201_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31209 G__memfunc_setup("setOverflow",1184,G__RootEventData_rootcint_201_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - overflow", (char*)NULL, (void*) NULL, 0);
31210 G__memfunc_setup("getOverflow",1172,G__RootEventData_rootcint_201_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31211 G__memfunc_setup("Class",502,G__RootEventData_rootcint_201_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcDigi::Class) ), 0);
31212 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_201_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDigi::Class_Name) ), 0);
31213 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_201_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcDigi::Class_Version) ), 0);
31214 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_201_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcDigi::Dictionary) ), 0);
31215 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31216 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31217 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31218 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_201_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31219 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_201_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDigi::DeclFileName) ), 0);
31220 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_201_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDigi::ImplFileLine) ), 0);
31221 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDigi::ImplFileName) ), 0);
31222 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDigi::DeclFileLine) ), 0);
31223 // automatic copy constructor
31224 G__memfunc_setup("TMdcDigi", 741, G__RootEventData_rootcint_201_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 0, 1, 1, 1, 0, "u 'TMdcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31225 // automatic destructor
31226 G__memfunc_setup("~TMdcDigi", 867, G__RootEventData_rootcint_201_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31227 // automatic assignment operator
31228 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_201_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 1, 1, 1, 1, 0, "u 'TMdcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31229 G__tag_memfunc_reset();
31230}
31231
31232static void G__setup_memfuncTEmcDigi(void) {
31233 /* TEmcDigi */
31234 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
31235 G__memfunc_setup("TEmcDigi",742,G__RootEventData_rootcint_202_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31236 G__memfunc_setup("setMeasure",1054,G__RootEventData_rootcint_202_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - measure", (char*)NULL, (void*) NULL, 0);
31237 G__memfunc_setup("getMeasure",1042,G__RootEventData_rootcint_202_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31238 G__memfunc_setup("Class",502,G__RootEventData_rootcint_202_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEmcDigi::Class) ), 0);
31239 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_202_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcDigi::Class_Name) ), 0);
31240 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_202_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEmcDigi::Class_Version) ), 0);
31241 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_202_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEmcDigi::Dictionary) ), 0);
31242 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31243 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31244 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31245 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_202_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31246 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_202_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcDigi::DeclFileName) ), 0);
31247 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_202_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcDigi::ImplFileLine) ), 0);
31248 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_202_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcDigi::ImplFileName) ), 0);
31249 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_202_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcDigi::DeclFileLine) ), 0);
31250 // automatic copy constructor
31251 G__memfunc_setup("TEmcDigi", 742, G__RootEventData_rootcint_202_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 0, 1, 1, 1, 0, "u 'TEmcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31252 // automatic destructor
31253 G__memfunc_setup("~TEmcDigi", 868, G__RootEventData_rootcint_202_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31254 // automatic assignment operator
31255 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_202_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 1, 1, 1, 1, 0, "u 'TEmcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31256 G__tag_memfunc_reset();
31257}
31258
31259static void G__setup_memfuncTTofDigi(void) {
31260 /* TTofDigi */
31261 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
31262 G__memfunc_setup("TTofDigi",762,G__RootEventData_rootcint_203_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31263 G__memfunc_setup("setOverflow",1184,G__RootEventData_rootcint_203_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - overflow", (char*)NULL, (void*) NULL, 0);
31264 G__memfunc_setup("getOverflow",1172,G__RootEventData_rootcint_203_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31265 G__memfunc_setup("Class",502,G__RootEventData_rootcint_203_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTofDigi::Class) ), 0);
31266 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_203_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofDigi::Class_Name) ), 0);
31267 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_203_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTofDigi::Class_Version) ), 0);
31268 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_203_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTofDigi::Dictionary) ), 0);
31269 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31270 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31271 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31272 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_203_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31273 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_203_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofDigi::DeclFileName) ), 0);
31274 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_203_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofDigi::ImplFileLine) ), 0);
31275 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_203_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofDigi::ImplFileName) ), 0);
31276 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_203_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofDigi::DeclFileLine) ), 0);
31277 // automatic copy constructor
31278 G__memfunc_setup("TTofDigi", 762, G__RootEventData_rootcint_203_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 0, 1, 1, 1, 0, "u 'TTofDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31279 // automatic destructor
31280 G__memfunc_setup("~TTofDigi", 888, G__RootEventData_rootcint_203_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31281 // automatic assignment operator
31282 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_203_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 1, 1, 1, 1, 0, "u 'TTofDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31283 G__tag_memfunc_reset();
31284}
31285
31286static void G__setup_memfuncTMucDigi(void) {
31287 /* TMucDigi */
31288 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
31289 G__memfunc_setup("TMucDigi",758,G__RootEventData_rootcint_204_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31290 G__memfunc_setup("Class",502,G__RootEventData_rootcint_204_0_2, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMucDigi::Class) ), 0);
31291 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_204_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucDigi::Class_Name) ), 0);
31292 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_204_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMucDigi::Class_Version) ), 0);
31293 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_204_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMucDigi::Dictionary) ), 0);
31294 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31295 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31296 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31297 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_204_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31298 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_204_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucDigi::DeclFileName) ), 0);
31299 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_204_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucDigi::ImplFileLine) ), 0);
31300 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_204_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucDigi::ImplFileName) ), 0);
31301 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_204_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucDigi::DeclFileLine) ), 0);
31302 // automatic copy constructor
31303 G__memfunc_setup("TMucDigi", 758, G__RootEventData_rootcint_204_0_14, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 0, 1, 1, 1, 0, "u 'TMucDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31304 // automatic destructor
31305 G__memfunc_setup("~TMucDigi", 884, G__RootEventData_rootcint_204_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31306 // automatic assignment operator
31307 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_204_0_16, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 1, 1, 1, 1, 0, "u 'TMucDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31308 G__tag_memfunc_reset();
31309}
31310
31311static void G__setup_memfuncTLumiDigi(void) {
31312 /* TLumiDigi */
31313 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
31314 G__memfunc_setup("TLumiDigi",872,G__RootEventData_rootcint_205_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31315 G__memfunc_setup("setOverflow",1184,G__RootEventData_rootcint_205_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - overflow", (char*)NULL, (void*) NULL, 0);
31316 G__memfunc_setup("getOverflow",1172,G__RootEventData_rootcint_205_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31317 G__memfunc_setup("Class",502,G__RootEventData_rootcint_205_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLumiDigi::Class) ), 0);
31318 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_205_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLumiDigi::Class_Name) ), 0);
31319 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_205_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLumiDigi::Class_Version) ), 0);
31320 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_205_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLumiDigi::Dictionary) ), 0);
31321 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31322 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31323 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31324 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_205_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31325 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_205_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLumiDigi::DeclFileName) ), 0);
31326 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_205_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLumiDigi::ImplFileLine) ), 0);
31327 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_205_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLumiDigi::ImplFileName) ), 0);
31328 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_205_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLumiDigi::DeclFileLine) ), 0);
31329 // automatic copy constructor
31330 G__memfunc_setup("TLumiDigi", 872, G__RootEventData_rootcint_205_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 0, 1, 1, 1, 0, "u 'TLumiDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31331 // automatic destructor
31332 G__memfunc_setup("~TLumiDigi", 998, G__RootEventData_rootcint_205_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31333 // automatic assignment operator
31334 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_205_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 1, 1, 1, 1, 0, "u 'TLumiDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
31335 G__tag_memfunc_reset();
31336}
31337
31338static void G__setup_memfuncTDigiEvent(void) {
31339 /* TDigiEvent */
31340 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
31341 G__memfunc_setup("TDigiEvent",979,G__RootEventData_rootcint_206_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31342 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_206_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' fromMc", (char*)NULL, (void*) NULL, 0);
31343 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
31344 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);
31345 G__memfunc_setup("getFromMc",900,G__RootEventData_rootcint_206_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31346 G__memfunc_setup("getMdcDigiCol",1263,G__RootEventData_rootcint_206_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31347 G__memfunc_setup("addMdcDigi",954,G__RootEventData_rootcint_206_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
31348 G__memfunc_setup("getMdcDigi",977,G__RootEventData_rootcint_206_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31349 G__memfunc_setup("clearMdcDigiCol",1462,G__RootEventData_rootcint_206_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31350 G__memfunc_setup("getEmcDigiCol",1264,G__RootEventData_rootcint_206_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31351 G__memfunc_setup("addEmcDigi",955,G__RootEventData_rootcint_206_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEmcDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
31352 G__memfunc_setup("getEmcDigi",978,G__RootEventData_rootcint_206_0_12, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31353 G__memfunc_setup("clearEmcDigiCol",1463,G__RootEventData_rootcint_206_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31354 G__memfunc_setup("getTofDigiCol",1284,G__RootEventData_rootcint_206_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31355 G__memfunc_setup("addTofDigi",975,G__RootEventData_rootcint_206_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTofDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
31356 G__memfunc_setup("getTofDigi",998,G__RootEventData_rootcint_206_0_16, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31357 G__memfunc_setup("clearTofDigiCol",1483,G__RootEventData_rootcint_206_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31358 G__memfunc_setup("getMucDigiCol",1280,G__RootEventData_rootcint_206_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31359 G__memfunc_setup("addMucDigi",971,G__RootEventData_rootcint_206_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMucDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
31360 G__memfunc_setup("getMucDigi",994,G__RootEventData_rootcint_206_0_20, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31361 G__memfunc_setup("clearMucDigiCol",1479,G__RootEventData_rootcint_206_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31362 G__memfunc_setup("getLumiDigiCol",1394,G__RootEventData_rootcint_206_0_22, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31363 G__memfunc_setup("addLumiDigi",1085,G__RootEventData_rootcint_206_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TLumiDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
31364 G__memfunc_setup("getLumiDigi",1108,G__RootEventData_rootcint_206_0_24, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31365 G__memfunc_setup("clearLumiDigiCol",1593,G__RootEventData_rootcint_206_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31366 G__memfunc_setup("Class",502,G__RootEventData_rootcint_206_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDigiEvent::Class) ), 0);
31367 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_206_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDigiEvent::Class_Name) ), 0);
31368 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_206_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDigiEvent::Class_Version) ), 0);
31369 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_206_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDigiEvent::Dictionary) ), 0);
31370 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31371 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31372 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31373 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_206_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31374 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_206_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDigiEvent::DeclFileName) ), 0);
31375 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_206_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDigiEvent::ImplFileLine) ), 0);
31376 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_206_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDigiEvent::ImplFileName) ), 0);
31377 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_206_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDigiEvent::DeclFileLine) ), 0);
31378 // automatic copy constructor
31379 G__memfunc_setup("TDigiEvent", 979, G__RootEventData_rootcint_206_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 0, 1, 1, 1, 0, "u 'TDigiEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
31380 // automatic destructor
31381 G__memfunc_setup("~TDigiEvent", 1105, G__RootEventData_rootcint_206_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31382 // automatic assignment operator
31383 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_206_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 1, 1, 1, 1, 0, "u 'TDigiEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
31384 G__tag_memfunc_reset();
31385}
31386
31387static void G__setup_memfuncTRecMdcTrack(void) {
31388 /* TRecMdcTrack */
31389 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
31390 G__memfunc_setup("TRecMdcTrack",1143,G__RootEventData_rootcint_207_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31391 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_207_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31392 G__memfunc_setup("helix",538,G__RootEventData_rootcint_207_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31393 G__memfunc_setup("charge",618,G__RootEventData_rootcint_207_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31394 G__memfunc_setup("pxy",353,G__RootEventData_rootcint_207_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31395 G__memfunc_setup("px",232,G__RootEventData_rootcint_207_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31396 G__memfunc_setup("py",233,G__RootEventData_rootcint_207_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31397 G__memfunc_setup("pz",234,G__RootEventData_rootcint_207_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31398 G__memfunc_setup("p",112,G__RootEventData_rootcint_207_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31399 G__memfunc_setup("theta",534,G__RootEventData_rootcint_207_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31400 G__memfunc_setup("phi",321,G__RootEventData_rootcint_207_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31401 G__memfunc_setup("x",120,G__RootEventData_rootcint_207_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31402 G__memfunc_setup("y",121,G__RootEventData_rootcint_207_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31403 G__memfunc_setup("z",122,G__RootEventData_rootcint_207_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31404 G__memfunc_setup("r",114,G__RootEventData_rootcint_207_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31405 G__memfunc_setup("stat",444,G__RootEventData_rootcint_207_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31406 G__memfunc_setup("chi2",358,G__RootEventData_rootcint_207_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31407 G__memfunc_setup("ndof",423,G__RootEventData_rootcint_207_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31408 G__memfunc_setup("err",329,G__RootEventData_rootcint_207_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31409 G__memfunc_setup("nhits",550,G__RootEventData_rootcint_207_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31410 G__memfunc_setup("nster",556,G__RootEventData_rootcint_207_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31411 G__memfunc_setup("nlayer",651,G__RootEventData_rootcint_207_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31412 G__memfunc_setup("vx0",286,G__RootEventData_rootcint_207_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31413 G__memfunc_setup("vy0",287,G__RootEventData_rootcint_207_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31414 G__memfunc_setup("vz0",288,G__RootEventData_rootcint_207_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31415 G__memfunc_setup("fiTerm",615,G__RootEventData_rootcint_207_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31416 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_207_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
31417 G__memfunc_setup("setHelix",838,G__RootEventData_rootcint_207_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
31418 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_207_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - stat", (char*)NULL, (void*) NULL, 0);
31419 G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_207_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chi", (char*)NULL, (void*) NULL, 0);
31420 G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_207_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ndof", (char*)NULL, (void*) NULL, 0);
31421 G__memfunc_setup("setErr",629,G__RootEventData_rootcint_207_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - er", (char*)NULL, (void*) NULL, 0);
31422 G__memfunc_setup("setNhits",850,G__RootEventData_rootcint_207_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nh", (char*)NULL, (void*) NULL, 0);
31423 G__memfunc_setup("setNster",856,G__RootEventData_rootcint_207_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ns", (char*)NULL, (void*) NULL, 0);
31424 G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_207_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nlayer", (char*)NULL, (void*) NULL, 0);
31425 G__memfunc_setup("setVX0",554,G__RootEventData_rootcint_207_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - vx0", (char*)NULL, (void*) NULL, 0);
31426 G__memfunc_setup("setVY0",555,G__RootEventData_rootcint_207_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - vy0", (char*)NULL, (void*) NULL, 0);
31427 G__memfunc_setup("setVZ0",556,G__RootEventData_rootcint_207_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - vz0", (char*)NULL, (void*) NULL, 0);
31428 G__memfunc_setup("setFiTerm",915,G__RootEventData_rootcint_207_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - fiterm", (char*)NULL, (void*) NULL, 0);
31429 G__memfunc_setup("setTRecMdcTrack",1475,G__RootEventData_rootcint_207_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcTrack' - 10 - mdcTrk", (char*)NULL, (void*) NULL, 0);
31430 G__memfunc_setup("Class",502,G__RootEventData_rootcint_207_0_41, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcTrack::Class) ), 0);
31431 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_207_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcTrack::Class_Name) ), 0);
31432 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_207_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcTrack::Class_Version) ), 0);
31433 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_207_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcTrack::Dictionary) ), 0);
31434 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31435 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31436 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31437 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_207_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31438 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_207_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcTrack::DeclFileName) ), 0);
31439 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_207_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcTrack::ImplFileLine) ), 0);
31440 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_207_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcTrack::ImplFileName) ), 0);
31441 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_207_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcTrack::DeclFileLine) ), 0);
31442 // automatic copy constructor
31443 G__memfunc_setup("TRecMdcTrack", 1143, G__RootEventData_rootcint_207_0_53, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 1, 1, 1, 0, "u 'TRecMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31444 // automatic destructor
31445 G__memfunc_setup("~TRecMdcTrack", 1269, G__RootEventData_rootcint_207_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31446 // automatic assignment operator
31447 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_207_0_55, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 1, 1, 1, 1, 0, "u 'TRecMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31448 G__tag_memfunc_reset();
31449}
31450
31451static void G__setup_memfuncTRecMdcKalTrack(void) {
31452 /* TRecMdcKalTrack */
31453 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
31454 G__memfunc_setup("TRecMdcKalTrack",1423,G__RootEventData_rootcint_208_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31455 G__memfunc_setup("getTrackId",994,G__RootEventData_rootcint_208_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31456 G__memfunc_setup("getMass",724,G__RootEventData_rootcint_208_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31457 G__memfunc_setup("getLength",930,G__RootEventData_rootcint_208_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31458 G__memfunc_setup("getTof",617,G__RootEventData_rootcint_208_0_5, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31459 G__memfunc_setup("getfiTerm",935,G__RootEventData_rootcint_208_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31460 G__memfunc_setup("getPathSM",877,G__RootEventData_rootcint_208_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31461 G__memfunc_setup("getNhits",838,G__RootEventData_rootcint_208_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31462 G__memfunc_setup("getNlayer",939,G__RootEventData_rootcint_208_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31463 G__memfunc_setup("getStat",732,G__RootEventData_rootcint_208_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 9,
31464"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31465 G__memfunc_setup("getChisq",824,G__RootEventData_rootcint_208_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31466"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31467 G__memfunc_setup("getNdf",600,G__RootEventData_rootcint_208_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 9,
31468"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31469 G__memfunc_setup("getNseg",717,G__RootEventData_rootcint_208_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31470 G__memfunc_setup("getZHelix",916,G__RootEventData_rootcint_208_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31471 G__memfunc_setup("getZError",932,G__RootEventData_rootcint_208_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31472"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31473 G__memfunc_setup("getZHelixE",985,G__RootEventData_rootcint_208_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31474 G__memfunc_setup("getZErrorE",1001,G__RootEventData_rootcint_208_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31475"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31476 G__memfunc_setup("getZHelixMu",1110,G__RootEventData_rootcint_208_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31477 G__memfunc_setup("getZErrorMu",1126,G__RootEventData_rootcint_208_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31478"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31479 G__memfunc_setup("getZHelixK",991,G__RootEventData_rootcint_208_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31480 G__memfunc_setup("getZErrorK",1007,G__RootEventData_rootcint_208_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31481"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31482 G__memfunc_setup("getZHelixP",996,G__RootEventData_rootcint_208_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31483 G__memfunc_setup("getZErrorP",1012,G__RootEventData_rootcint_208_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31484"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31485 G__memfunc_setup("getFHelix",896,G__RootEventData_rootcint_208_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31486 G__memfunc_setup("getFError",912,G__RootEventData_rootcint_208_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31487"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31488 G__memfunc_setup("getFHelixE",965,G__RootEventData_rootcint_208_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31489 G__memfunc_setup("getFErrorE",981,G__RootEventData_rootcint_208_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31490"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31491 G__memfunc_setup("getFHelixMu",1090,G__RootEventData_rootcint_208_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31492 G__memfunc_setup("getFErrorMu",1106,G__RootEventData_rootcint_208_0_29, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31493"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31494 G__memfunc_setup("getFHelixK",971,G__RootEventData_rootcint_208_0_30, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31495 G__memfunc_setup("getFErrorK",987,G__RootEventData_rootcint_208_0_31, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31496"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31497 G__memfunc_setup("getFHelixP",976,G__RootEventData_rootcint_208_0_32, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31498 G__memfunc_setup("getFErrorP",992,G__RootEventData_rootcint_208_0_33, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31499"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31500 G__memfunc_setup("getLHelix",902,G__RootEventData_rootcint_208_0_34, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31501 G__memfunc_setup("getLError",918,G__RootEventData_rootcint_208_0_35, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31502"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31503 G__memfunc_setup("getLHelixE",971,G__RootEventData_rootcint_208_0_36, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31504 G__memfunc_setup("getLErrorE",987,G__RootEventData_rootcint_208_0_37, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31505"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31506 G__memfunc_setup("getLHelixMu",1096,G__RootEventData_rootcint_208_0_38, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31507 G__memfunc_setup("getLErrorMu",1112,G__RootEventData_rootcint_208_0_39, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31508"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31509 G__memfunc_setup("getLHelixK",977,G__RootEventData_rootcint_208_0_40, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31510 G__memfunc_setup("getLErrorK",993,G__RootEventData_rootcint_208_0_41, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31511"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31512 G__memfunc_setup("getLHelixP",982,G__RootEventData_rootcint_208_0_42, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31513 G__memfunc_setup("getLErrorP",998,G__RootEventData_rootcint_208_0_43, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9,
31514"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
31515 G__memfunc_setup("getTHelix",910,G__RootEventData_rootcint_208_0_44, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31516 G__memfunc_setup("getTError",926,G__RootEventData_rootcint_208_0_45, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31517 G__memfunc_setup("getPocaE",776,G__RootEventData_rootcint_208_0_46, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31518 G__memfunc_setup("getPocaMu",901,G__RootEventData_rootcint_208_0_47, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31519 G__memfunc_setup("getPoca",707,G__RootEventData_rootcint_208_0_48, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31520 G__memfunc_setup("getPocaK",782,G__RootEventData_rootcint_208_0_49, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31521 G__memfunc_setup("getPocaP",787,G__RootEventData_rootcint_208_0_50, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31522 G__memfunc_setup("getLPointE",987,G__RootEventData_rootcint_208_0_51, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31523 G__memfunc_setup("getLPointMu",1112,G__RootEventData_rootcint_208_0_52, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31524 G__memfunc_setup("getLPoint",918,G__RootEventData_rootcint_208_0_53, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31525 G__memfunc_setup("getLPointK",993,G__RootEventData_rootcint_208_0_54, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31526 G__memfunc_setup("getLPointP",998,G__RootEventData_rootcint_208_0_55, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31527 G__memfunc_setup("getLPivotE",995,G__RootEventData_rootcint_208_0_56, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31528 G__memfunc_setup("getLPivotMu",1120,G__RootEventData_rootcint_208_0_57, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31529 G__memfunc_setup("getLPivot",926,G__RootEventData_rootcint_208_0_58, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31530 G__memfunc_setup("getLPivotK",1001,G__RootEventData_rootcint_208_0_59, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31531 G__memfunc_setup("getLPivotP",1006,G__RootEventData_rootcint_208_0_60, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31532 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_208_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
31533 G__memfunc_setup("setMass",736,G__RootEventData_rootcint_208_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - mass", (char*)NULL, (void*) NULL, 0);
31534 G__memfunc_setup("setLength",942,G__RootEventData_rootcint_208_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - length", (char*)NULL, (void*) NULL, 0);
31535 G__memfunc_setup("setFiTerm",915,G__RootEventData_rootcint_208_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fiTerm", (char*)NULL, (void*) NULL, 0);
31536 G__memfunc_setup("setPathSM",889,G__RootEventData_rootcint_208_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - pathSM", (char*)NULL, (void*) NULL, 0);
31537 G__memfunc_setup("setTof",629,G__RootEventData_rootcint_208_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - tof", (char*)NULL, (void*) NULL, 0);
31538 G__memfunc_setup("setNhits",850,G__RootEventData_rootcint_208_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 10 - nhits", (char*)NULL, (void*) NULL, 0);
31539 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_208_0_68, 121, -1, -1, 0, 3, 1, 1, 0,
31540"i - 'Int_t' 10 - stat i - 'Int_t' 0 - i "
31541"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31542 G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_208_0_69, 121, -1, -1, 0, 3, 1, 1, 0,
31543"d - 'Double_t' 10 - chisq i - 'Int_t' 0 - i "
31544"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31545 G__memfunc_setup("setNdf",612,G__RootEventData_rootcint_208_0_70, 121, -1, -1, 0, 3, 1, 1, 0,
31546"i - 'Int_t' 10 - ndf i - 'Int_t' 0 - i "
31547"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31548 G__memfunc_setup("setNseg",729,G__RootEventData_rootcint_208_0_71, 121, -1, -1, 0, 2, 1, 1, 0,
31549"i - 'Int_t' 10 - nSeg i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31550 G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_208_0_72, 121, -1, -1, 0, 2, 1, 1, 0,
31551"i - 'Int_t' 10 - nlayer i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
31552 G__memfunc_setup("setZHelix",928,G__RootEventData_rootcint_208_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix", (char*)NULL, (void*) NULL, 0);
31553 G__memfunc_setup("setZError",944,G__RootEventData_rootcint_208_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror", (char*)NULL, (void*) NULL, 0);
31554 G__memfunc_setup("setZHelixE",997,G__RootEventData_rootcint_208_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_e", (char*)NULL, (void*) NULL, 0);
31555 G__memfunc_setup("setZErrorE",1013,G__RootEventData_rootcint_208_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_e", (char*)NULL, (void*) NULL, 0);
31556 G__memfunc_setup("setZHelixMu",1122,G__RootEventData_rootcint_208_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_mu", (char*)NULL, (void*) NULL, 0);
31557 G__memfunc_setup("setZErrorMu",1138,G__RootEventData_rootcint_208_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_mu", (char*)NULL, (void*) NULL, 0);
31558 G__memfunc_setup("setZHelixK",1003,G__RootEventData_rootcint_208_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_k", (char*)NULL, (void*) NULL, 0);
31559 G__memfunc_setup("setZErrorK",1019,G__RootEventData_rootcint_208_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_k", (char*)NULL, (void*) NULL, 0);
31560 G__memfunc_setup("setZHelixP",1008,G__RootEventData_rootcint_208_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_p", (char*)NULL, (void*) NULL, 0);
31561 G__memfunc_setup("setZErrorP",1024,G__RootEventData_rootcint_208_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_p", (char*)NULL, (void*) NULL, 0);
31562 G__memfunc_setup("setFHelix",908,G__RootEventData_rootcint_208_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix", (char*)NULL, (void*) NULL, 0);
31563 G__memfunc_setup("setFError",924,G__RootEventData_rootcint_208_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror", (char*)NULL, (void*) NULL, 0);
31564 G__memfunc_setup("setFHelixE",977,G__RootEventData_rootcint_208_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_e", (char*)NULL, (void*) NULL, 0);
31565 G__memfunc_setup("setFErrorE",993,G__RootEventData_rootcint_208_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_e", (char*)NULL, (void*) NULL, 0);
31566 G__memfunc_setup("setFHelixMu",1102,G__RootEventData_rootcint_208_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_mu", (char*)NULL, (void*) NULL, 0);
31567 G__memfunc_setup("setFErrorMu",1118,G__RootEventData_rootcint_208_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_mu", (char*)NULL, (void*) NULL, 0);
31568 G__memfunc_setup("setFHelixK",983,G__RootEventData_rootcint_208_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_k", (char*)NULL, (void*) NULL, 0);
31569 G__memfunc_setup("setFErrorK",999,G__RootEventData_rootcint_208_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_k", (char*)NULL, (void*) NULL, 0);
31570 G__memfunc_setup("setFHelixP",988,G__RootEventData_rootcint_208_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_p", (char*)NULL, (void*) NULL, 0);
31571 G__memfunc_setup("setFErrorP",1004,G__RootEventData_rootcint_208_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_p", (char*)NULL, (void*) NULL, 0);
31572 G__memfunc_setup("setLHelix",914,G__RootEventData_rootcint_208_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix", (char*)NULL, (void*) NULL, 0);
31573 G__memfunc_setup("setLError",930,G__RootEventData_rootcint_208_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror", (char*)NULL, (void*) NULL, 0);
31574 G__memfunc_setup("setLHelixE",983,G__RootEventData_rootcint_208_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_e", (char*)NULL, (void*) NULL, 0);
31575 G__memfunc_setup("setLErrorE",999,G__RootEventData_rootcint_208_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_e", (char*)NULL, (void*) NULL, 0);
31576 G__memfunc_setup("setLHelixMu",1108,G__RootEventData_rootcint_208_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_mu", (char*)NULL, (void*) NULL, 0);
31577 G__memfunc_setup("setLErrorMu",1124,G__RootEventData_rootcint_208_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_mu", (char*)NULL, (void*) NULL, 0);
31578 G__memfunc_setup("setLHelixK",989,G__RootEventData_rootcint_208_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_k", (char*)NULL, (void*) NULL, 0);
31579 G__memfunc_setup("setLErrorK",1005,G__RootEventData_rootcint_208_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_k", (char*)NULL, (void*) NULL, 0);
31580 G__memfunc_setup("setLHelixP",994,G__RootEventData_rootcint_208_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_p", (char*)NULL, (void*) NULL, 0);
31581 G__memfunc_setup("setLErrorP",1010,G__RootEventData_rootcint_208_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_p", (char*)NULL, (void*) NULL, 0);
31582 G__memfunc_setup("setTHelix",922,G__RootEventData_rootcint_208_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - thelix", (char*)NULL, (void*) NULL, 0);
31583 G__memfunc_setup("setTError",938,G__RootEventData_rootcint_208_0_104, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - terror", (char*)NULL, (void*) NULL, 0);
31584 G__memfunc_setup("setPocaE",788,G__RootEventData_rootcint_208_0_105, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_e", (char*)NULL, (void*) NULL, 0);
31585 G__memfunc_setup("setPocaMu",913,G__RootEventData_rootcint_208_0_106, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_mu", (char*)NULL, (void*) NULL, 0);
31586 G__memfunc_setup("setPoca",719,G__RootEventData_rootcint_208_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca", (char*)NULL, (void*) NULL, 0);
31587 G__memfunc_setup("setPocaK",794,G__RootEventData_rootcint_208_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_k", (char*)NULL, (void*) NULL, 0);
31588 G__memfunc_setup("setPocaP",799,G__RootEventData_rootcint_208_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_p", (char*)NULL, (void*) NULL, 0);
31589 G__memfunc_setup("setLPointE",999,G__RootEventData_rootcint_208_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_e", (char*)NULL, (void*) NULL, 0);
31590 G__memfunc_setup("setLPointMu",1124,G__RootEventData_rootcint_208_0_111, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_mu", (char*)NULL, (void*) NULL, 0);
31591 G__memfunc_setup("setLPoint",930,G__RootEventData_rootcint_208_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint", (char*)NULL, (void*) NULL, 0);
31592 G__memfunc_setup("setLPointK",1005,G__RootEventData_rootcint_208_0_113, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_k", (char*)NULL, (void*) NULL, 0);
31593 G__memfunc_setup("setLPointP",1010,G__RootEventData_rootcint_208_0_114, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_p", (char*)NULL, (void*) NULL, 0);
31594 G__memfunc_setup("setLPivotE",1007,G__RootEventData_rootcint_208_0_115, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_e", (char*)NULL, (void*) NULL, 0);
31595 G__memfunc_setup("setLPivotMu",1132,G__RootEventData_rootcint_208_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_mu", (char*)NULL, (void*) NULL, 0);
31596 G__memfunc_setup("setLPivot",938,G__RootEventData_rootcint_208_0_117, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot", (char*)NULL, (void*) NULL, 0);
31597 G__memfunc_setup("setLPivotK",1013,G__RootEventData_rootcint_208_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_k", (char*)NULL, (void*) NULL, 0);
31598 G__memfunc_setup("setLPivotP",1018,G__RootEventData_rootcint_208_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_p", (char*)NULL, (void*) NULL, 0);
31599 G__memfunc_setup("Class",502,G__RootEventData_rootcint_208_0_120, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcKalTrack::Class) ), 0);
31600 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_208_0_121, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalTrack::Class_Name) ), 0);
31601 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_208_0_122, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcKalTrack::Class_Version) ), 0);
31602 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_208_0_123, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcKalTrack::Dictionary) ), 0);
31603 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31604 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31605 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31606 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_208_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31607 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_208_0_128, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalTrack::DeclFileName) ), 0);
31608 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_208_0_129, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalTrack::ImplFileLine) ), 0);
31609 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_208_0_130, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalTrack::ImplFileName) ), 0);
31610 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_208_0_131, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalTrack::DeclFileLine) ), 0);
31611 // automatic copy constructor
31612 G__memfunc_setup("TRecMdcKalTrack", 1423, G__RootEventData_rootcint_208_0_132, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 0, 1, 1, 1, 0, "u 'TRecMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31613 // automatic destructor
31614 G__memfunc_setup("~TRecMdcKalTrack", 1549, G__RootEventData_rootcint_208_0_133, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31615 // automatic assignment operator
31616 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_208_0_134, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 1, 1, 1, 1, 0, "u 'TRecMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31617 G__tag_memfunc_reset();
31618}
31619
31620static void G__setup_memfuncTRecMdcHit(void) {
31621 /* TRecMdcHit */
31622 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
31623 G__memfunc_setup("TRecMdcHit",935,G__RootEventData_rootcint_209_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31624 G__memfunc_setup("isGrouped",946,G__RootEventData_rootcint_209_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31625 G__memfunc_setup("getId",493,G__RootEventData_rootcint_209_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31626 G__memfunc_setup("getTrkId",798,G__RootEventData_rootcint_209_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31627 G__memfunc_setup("getDriftDistLeft",1624,G__RootEventData_rootcint_209_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31628 G__memfunc_setup("getDriftDistRight",1739,G__RootEventData_rootcint_209_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31629 G__memfunc_setup("getErrDriftDistLeft",1921,G__RootEventData_rootcint_209_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31630 G__memfunc_setup("getErrDriftDistRight",2036,G__RootEventData_rootcint_209_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31631 G__memfunc_setup("getChisqAdd",1089,G__RootEventData_rootcint_209_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31632 G__memfunc_setup("getFlagLR",856,G__RootEventData_rootcint_209_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31633 G__memfunc_setup("getStat",732,G__RootEventData_rootcint_209_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31634 G__memfunc_setup("getMdcId",769,G__RootEventData_rootcint_209_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31635 G__memfunc_setup("getTdc",603,G__RootEventData_rootcint_209_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31636 G__memfunc_setup("getAdc",584,G__RootEventData_rootcint_209_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31637 G__memfunc_setup("getDriftT",909,G__RootEventData_rootcint_209_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31638 G__memfunc_setup("getDoca",695,G__RootEventData_rootcint_209_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31639 G__memfunc_setup("getEntra",826,G__RootEventData_rootcint_209_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31640 G__memfunc_setup("getZhit",735,G__RootEventData_rootcint_209_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31641 G__memfunc_setup("getFltLen",901,G__RootEventData_rootcint_209_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
31642 G__memfunc_setup("setIsGrouped",1246,G__RootEventData_rootcint_209_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isGrouped", (char*)NULL, (void*) NULL, 0);
31643 G__memfunc_setup("setId",505,G__RootEventData_rootcint_209_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
31644 G__memfunc_setup("setTrkId",810,G__RootEventData_rootcint_209_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trkid", (char*)NULL, (void*) NULL, 0);
31645 G__memfunc_setup("setDriftDistLeft",1636,G__RootEventData_rootcint_209_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ddl", (char*)NULL, (void*) NULL, 0);
31646 G__memfunc_setup("setDriftDistRight",1751,G__RootEventData_rootcint_209_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ddr", (char*)NULL, (void*) NULL, 0);
31647 G__memfunc_setup("setErrDriftDistLeft",1933,G__RootEventData_rootcint_209_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - erddl", (char*)NULL, (void*) NULL, 0);
31648 G__memfunc_setup("setErrDriftDistRight",2048,G__RootEventData_rootcint_209_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - erddr", (char*)NULL, (void*) NULL, 0);
31649 G__memfunc_setup("setChisqAdd",1101,G__RootEventData_rootcint_209_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pChisq", (char*)NULL, (void*) NULL, 0);
31650 G__memfunc_setup("setFlagLR",868,G__RootEventData_rootcint_209_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lr", (char*)NULL, (void*) NULL, 0);
31651 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_209_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - stat", (char*)NULL, (void*) NULL, 0);
31652 G__memfunc_setup("setMdcId",781,G__RootEventData_rootcint_209_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mdcid", (char*)NULL, (void*) NULL, 0);
31653 G__memfunc_setup("setTdc",615,G__RootEventData_rootcint_209_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tdc", (char*)NULL, (void*) NULL, 0);
31654 G__memfunc_setup("setAdc",596,G__RootEventData_rootcint_209_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - adc", (char*)NULL, (void*) NULL, 0);
31655 G__memfunc_setup("setDriftT",921,G__RootEventData_rootcint_209_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - driftT", (char*)NULL, (void*) NULL, 0);
31656 G__memfunc_setup("setDoca",707,G__RootEventData_rootcint_209_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - doca", (char*)NULL, (void*) NULL, 0);
31657 G__memfunc_setup("setEntra",838,G__RootEventData_rootcint_209_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - entra", (char*)NULL, (void*) NULL, 0);
31658 G__memfunc_setup("setZhit",747,G__RootEventData_rootcint_209_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zhit", (char*)NULL, (void*) NULL, 0);
31659 G__memfunc_setup("setFltLen",913,G__RootEventData_rootcint_209_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - fltLen", (char*)NULL, (void*) NULL, 0);
31660 G__memfunc_setup("setTRecMdcHit",1267,G__RootEventData_rootcint_209_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcHit' - 10 - mdchit", (char*)NULL, (void*) NULL, 0);
31661 G__memfunc_setup("Class",502,G__RootEventData_rootcint_209_0_39, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcHit::Class) ), 0);
31662 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_209_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcHit::Class_Name) ), 0);
31663 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_209_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcHit::Class_Version) ), 0);
31664 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_209_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcHit::Dictionary) ), 0);
31665 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31666 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31667 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31668 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_209_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31669 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_209_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcHit::DeclFileName) ), 0);
31670 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_209_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcHit::ImplFileLine) ), 0);
31671 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_209_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcHit::ImplFileName) ), 0);
31672 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_209_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcHit::DeclFileLine) ), 0);
31673 // automatic copy constructor
31674 G__memfunc_setup("TRecMdcHit", 935, G__RootEventData_rootcint_209_0_51, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 1, 1, 1, 0, "u 'TRecMdcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
31675 // automatic destructor
31676 G__memfunc_setup("~TRecMdcHit", 1061, G__RootEventData_rootcint_209_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31677 // automatic assignment operator
31678 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_209_0_53, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 1, 1, 1, 1, 0, "u 'TRecMdcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
31679 G__tag_memfunc_reset();
31680}
31681
31682static void G__setup_memfuncTTofTrack(void) {
31683 /* TTofTrack */
31684 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
31685 G__memfunc_setup("TTofTrack",882,G__RootEventData_rootcint_210_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31686 G__memfunc_setup("setTofTrackID",1271,G__RootEventData_rootcint_210_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofTrackID", (char*)NULL, (void*) NULL, 0);
31687 G__memfunc_setup("setTrackID",974,G__RootEventData_rootcint_210_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackID", (char*)NULL, (void*) NULL, 0);
31688 G__memfunc_setup("setTofID",770,G__RootEventData_rootcint_210_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofID", (char*)NULL, (void*) NULL, 0);
31689 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_210_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
31690 G__memfunc_setup("setPath",729,G__RootEventData_rootcint_210_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - path", (char*)NULL, (void*) NULL, 0);
31691 G__memfunc_setup("setZrHit",829,G__RootEventData_rootcint_210_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zrhit", (char*)NULL, (void*) NULL, 0);
31692 G__memfunc_setup("setPh",516,G__RootEventData_rootcint_210_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ph", (char*)NULL, (void*) NULL, 0);
31693 G__memfunc_setup("setTof",629,G__RootEventData_rootcint_210_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
31694 G__memfunc_setup("setErrTof",926,G__RootEventData_rootcint_210_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - etof", (char*)NULL, (void*) NULL, 0);
31695 G__memfunc_setup("setBeta",712,G__RootEventData_rootcint_210_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beta", (char*)NULL, (void*) NULL, 0);
31696 G__memfunc_setup("setTexp",749,G__RootEventData_rootcint_210_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - texp", (char*)NULL, (void*) NULL, 0);
31697 G__memfunc_setup("setTexpElectron",1577,G__RootEventData_rootcint_210_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpe", (char*)NULL, (void*) NULL, 0);
31698 G__memfunc_setup("setTexpMuon",1164,G__RootEventData_rootcint_210_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpmu", (char*)NULL, (void*) NULL, 0);
31699 G__memfunc_setup("setTexpPion",1155,G__RootEventData_rootcint_210_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texppi", (char*)NULL, (void*) NULL, 0);
31700 G__memfunc_setup("setTexpKaon",1142,G__RootEventData_rootcint_210_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpk", (char*)NULL, (void*) NULL, 0);
31701 G__memfunc_setup("setTexpProton",1391,G__RootEventData_rootcint_210_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpp", (char*)NULL, (void*) NULL, 0);
31702 G__memfunc_setup("setToffset",1063,G__RootEventData_rootcint_210_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - toffset", (char*)NULL, (void*) NULL, 0);
31703 G__memfunc_setup("setToffsetElectron",1891,G__RootEventData_rootcint_210_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - toe", (char*)NULL, (void*) NULL, 0);
31704 G__memfunc_setup("setToffsetMuon",1478,G__RootEventData_rootcint_210_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tomu", (char*)NULL, (void*) NULL, 0);
31705 G__memfunc_setup("setToffsetPion",1469,G__RootEventData_rootcint_210_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topi", (char*)NULL, (void*) NULL, 0);
31706 G__memfunc_setup("setToffsetKaon",1456,G__RootEventData_rootcint_210_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tok", (char*)NULL, (void*) NULL, 0);
31707 G__memfunc_setup("setToffsetProton",1705,G__RootEventData_rootcint_210_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - top", (char*)NULL, (void*) NULL, 0);
31708 G__memfunc_setup("setToffsetAntiProton",2101,G__RootEventData_rootcint_210_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topb", (char*)NULL, (void*) NULL, 0);
31709 G__memfunc_setup("setSigma",829,G__RootEventData_rootcint_210_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - sigma", (char*)NULL, (void*) NULL, 0);
31710 G__memfunc_setup("setSigmaElectron",1657,G__RootEventData_rootcint_210_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - se", (char*)NULL, (void*) NULL, 0);
31711 G__memfunc_setup("setSigmaMuon",1244,G__RootEventData_rootcint_210_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - smu", (char*)NULL, (void*) NULL, 0);
31712 G__memfunc_setup("setSigmaPion",1235,G__RootEventData_rootcint_210_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spi", (char*)NULL, (void*) NULL, 0);
31713 G__memfunc_setup("setSigmaKaon",1222,G__RootEventData_rootcint_210_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sk", (char*)NULL, (void*) NULL, 0);
31714 G__memfunc_setup("setSigmaProton",1471,G__RootEventData_rootcint_210_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sp", (char*)NULL, (void*) NULL, 0);
31715 G__memfunc_setup("setSigmaAntiProton",1867,G__RootEventData_rootcint_210_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spb", (char*)NULL, (void*) NULL, 0);
31716 G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_210_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - quality", (char*)NULL, (void*) NULL, 0);
31717 G__memfunc_setup("setT0",464,G__RootEventData_rootcint_210_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t0", (char*)NULL, (void*) NULL, 0);
31718 G__memfunc_setup("setErrT0",761,G__RootEventData_rootcint_210_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errt0", (char*)NULL, (void*) NULL, 0);
31719 G__memfunc_setup("setErrZ",719,G__RootEventData_rootcint_210_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errz", (char*)NULL, (void*) NULL, 0);
31720 G__memfunc_setup("setPhi",621,G__RootEventData_rootcint_210_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
31721 G__memfunc_setup("setErrPhi",918,G__RootEventData_rootcint_210_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errphi", (char*)NULL, (void*) NULL, 0);
31722 G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_210_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
31723 G__memfunc_setup("setErrEnergy",1247,G__RootEventData_rootcint_210_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errenergy", (char*)NULL, (void*) NULL, 0);
31724 G__memfunc_setup("tofTrackID",971,G__RootEventData_rootcint_210_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31725 G__memfunc_setup("trackID",674,G__RootEventData_rootcint_210_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31726 G__memfunc_setup("tofID",470,G__RootEventData_rootcint_210_0_42, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31727 G__memfunc_setup("status",676,G__RootEventData_rootcint_210_0_43, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31728 G__memfunc_setup("path",429,G__RootEventData_rootcint_210_0_44, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31729 G__memfunc_setup("zrhit",561,G__RootEventData_rootcint_210_0_45, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31730 G__memfunc_setup("ph",216,G__RootEventData_rootcint_210_0_46, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31731 G__memfunc_setup("tof",329,G__RootEventData_rootcint_210_0_47, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31732 G__memfunc_setup("errtof",658,G__RootEventData_rootcint_210_0_48, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31733 G__memfunc_setup("beta",412,G__RootEventData_rootcint_210_0_49, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31734 G__memfunc_setup("texp",449,G__RootEventData_rootcint_210_0_50, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31735 G__memfunc_setup("texpElectron",1277,G__RootEventData_rootcint_210_0_51, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31736 G__memfunc_setup("texpMuon",864,G__RootEventData_rootcint_210_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31737 G__memfunc_setup("texpPion",855,G__RootEventData_rootcint_210_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31738 G__memfunc_setup("texpKaon",842,G__RootEventData_rootcint_210_0_54, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31739 G__memfunc_setup("texpProton",1091,G__RootEventData_rootcint_210_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31740 G__memfunc_setup("toffset",763,G__RootEventData_rootcint_210_0_56, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31741 G__memfunc_setup("toffsetElectron",1591,G__RootEventData_rootcint_210_0_57, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31742 G__memfunc_setup("toffsetMuon",1178,G__RootEventData_rootcint_210_0_58, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31743 G__memfunc_setup("toffsetPion",1169,G__RootEventData_rootcint_210_0_59, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31744 G__memfunc_setup("toffsetKaon",1156,G__RootEventData_rootcint_210_0_60, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31745 G__memfunc_setup("toffsetProton",1405,G__RootEventData_rootcint_210_0_61, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31746 G__memfunc_setup("toffsetAntiProton",1801,G__RootEventData_rootcint_210_0_62, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31747 G__memfunc_setup("sigma",529,G__RootEventData_rootcint_210_0_63, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31748 G__memfunc_setup("sigmaElectron",1357,G__RootEventData_rootcint_210_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31749 G__memfunc_setup("sigmaMuon",944,G__RootEventData_rootcint_210_0_65, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31750 G__memfunc_setup("sigmaPion",935,G__RootEventData_rootcint_210_0_66, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31751 G__memfunc_setup("sigmaKaon",922,G__RootEventData_rootcint_210_0_67, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31752 G__memfunc_setup("sigmaProton",1171,G__RootEventData_rootcint_210_0_68, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31753 G__memfunc_setup("sigmaAntiProton",1567,G__RootEventData_rootcint_210_0_69, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31754 G__memfunc_setup("quality",777,G__RootEventData_rootcint_210_0_70, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31755 G__memfunc_setup("t0",164,G__RootEventData_rootcint_210_0_71, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31756 G__memfunc_setup("errt0",493,G__RootEventData_rootcint_210_0_72, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31757 G__memfunc_setup("errz",451,G__RootEventData_rootcint_210_0_73, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31758 G__memfunc_setup("phi",321,G__RootEventData_rootcint_210_0_74, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31759 G__memfunc_setup("errphi",650,G__RootEventData_rootcint_210_0_75, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31760 G__memfunc_setup("energy",650,G__RootEventData_rootcint_210_0_76, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31761 G__memfunc_setup("errenergy",979,G__RootEventData_rootcint_210_0_77, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31762 G__memfunc_setup("Class",502,G__RootEventData_rootcint_210_0_78, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTofTrack::Class) ), 0);
31763 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_210_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofTrack::Class_Name) ), 0);
31764 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_210_0_80, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTofTrack::Class_Version) ), 0);
31765 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_210_0_81, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTofTrack::Dictionary) ), 0);
31766 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31767 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31768 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31769 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_210_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31770 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_210_0_86, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofTrack::DeclFileName) ), 0);
31771 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_210_0_87, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofTrack::ImplFileLine) ), 0);
31772 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_210_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofTrack::ImplFileName) ), 0);
31773 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_210_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofTrack::DeclFileLine) ), 0);
31774 // automatic copy constructor
31775 G__memfunc_setup("TTofTrack", 882, G__RootEventData_rootcint_210_0_90, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 0, 1, 1, 1, 0, "u 'TTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31776 // automatic destructor
31777 G__memfunc_setup("~TTofTrack", 1008, G__RootEventData_rootcint_210_0_91, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31778 // automatic assignment operator
31779 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_210_0_92, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 1, 1, 1, 1, 0, "u 'TTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31780 G__tag_memfunc_reset();
31781}
31782
31783static void G__setup_memfuncTRecTofTrack(void) {
31784 /* TRecTofTrack */
31785 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
31786 G__memfunc_setup("TRecTofTrack",1164,G__RootEventData_rootcint_211_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31787 G__memfunc_setup("tofTrackID",971,G__RootEventData_rootcint_211_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31788 G__memfunc_setup("trackID",674,G__RootEventData_rootcint_211_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31789 G__memfunc_setup("tofID",470,G__RootEventData_rootcint_211_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31790 G__memfunc_setup("status",676,G__RootEventData_rootcint_211_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31791 G__memfunc_setup("path",429,G__RootEventData_rootcint_211_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31792 G__memfunc_setup("zrhit",561,G__RootEventData_rootcint_211_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31793 G__memfunc_setup("ph",216,G__RootEventData_rootcint_211_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31794 G__memfunc_setup("tof",329,G__RootEventData_rootcint_211_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31795 G__memfunc_setup("errtof",658,G__RootEventData_rootcint_211_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31796 G__memfunc_setup("beta",412,G__RootEventData_rootcint_211_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31797 G__memfunc_setup("texp",449,G__RootEventData_rootcint_211_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31798 G__memfunc_setup("texpElectron",1277,G__RootEventData_rootcint_211_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31799 G__memfunc_setup("texpMuon",864,G__RootEventData_rootcint_211_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31800 G__memfunc_setup("texpPion",855,G__RootEventData_rootcint_211_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31801 G__memfunc_setup("texpKaon",842,G__RootEventData_rootcint_211_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31802 G__memfunc_setup("texpProton",1091,G__RootEventData_rootcint_211_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31803 G__memfunc_setup("toffset",763,G__RootEventData_rootcint_211_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31804 G__memfunc_setup("toffsetElectron",1591,G__RootEventData_rootcint_211_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31805 G__memfunc_setup("toffsetMuon",1178,G__RootEventData_rootcint_211_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31806 G__memfunc_setup("toffsetPion",1169,G__RootEventData_rootcint_211_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31807 G__memfunc_setup("toffsetKaon",1156,G__RootEventData_rootcint_211_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31808 G__memfunc_setup("toffsetProton",1405,G__RootEventData_rootcint_211_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31809 G__memfunc_setup("toffsetAntiProton",1801,G__RootEventData_rootcint_211_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31810 G__memfunc_setup("sigma",529,G__RootEventData_rootcint_211_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31811 G__memfunc_setup("sigmaElectron",1357,G__RootEventData_rootcint_211_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31812 G__memfunc_setup("sigmaMuon",944,G__RootEventData_rootcint_211_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31813 G__memfunc_setup("sigmaPion",935,G__RootEventData_rootcint_211_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31814 G__memfunc_setup("sigmaKaon",922,G__RootEventData_rootcint_211_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31815 G__memfunc_setup("sigmaProton",1171,G__RootEventData_rootcint_211_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31816 G__memfunc_setup("sigmaAntiProton",1567,G__RootEventData_rootcint_211_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31817 G__memfunc_setup("quality",777,G__RootEventData_rootcint_211_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31818 G__memfunc_setup("t0",164,G__RootEventData_rootcint_211_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31819 G__memfunc_setup("errt0",493,G__RootEventData_rootcint_211_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31820 G__memfunc_setup("errz",451,G__RootEventData_rootcint_211_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31821 G__memfunc_setup("phi",321,G__RootEventData_rootcint_211_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31822 G__memfunc_setup("errphi",650,G__RootEventData_rootcint_211_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31823 G__memfunc_setup("energy",650,G__RootEventData_rootcint_211_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31824 G__memfunc_setup("errenergy",979,G__RootEventData_rootcint_211_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31825 G__memfunc_setup("setTofTrackID",1271,G__RootEventData_rootcint_211_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofTrackID", (char*)NULL, (void*) NULL, 0);
31826 G__memfunc_setup("setTrackID",974,G__RootEventData_rootcint_211_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackID", (char*)NULL, (void*) NULL, 0);
31827 G__memfunc_setup("setTofID",770,G__RootEventData_rootcint_211_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofID", (char*)NULL, (void*) NULL, 0);
31828 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_211_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
31829 G__memfunc_setup("setPath",729,G__RootEventData_rootcint_211_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - path", (char*)NULL, (void*) NULL, 0);
31830 G__memfunc_setup("setZrHit",829,G__RootEventData_rootcint_211_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zrhit", (char*)NULL, (void*) NULL, 0);
31831 G__memfunc_setup("setPh",516,G__RootEventData_rootcint_211_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ph", (char*)NULL, (void*) NULL, 0);
31832 G__memfunc_setup("setTof",629,G__RootEventData_rootcint_211_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
31833 G__memfunc_setup("setErrTof",926,G__RootEventData_rootcint_211_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - etof", (char*)NULL, (void*) NULL, 0);
31834 G__memfunc_setup("setBeta",712,G__RootEventData_rootcint_211_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beta", (char*)NULL, (void*) NULL, 0);
31835 G__memfunc_setup("setTexp",749,G__RootEventData_rootcint_211_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - texp", (char*)NULL, (void*) NULL, 0);
31836 G__memfunc_setup("setTexpElectron",1577,G__RootEventData_rootcint_211_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpe", (char*)NULL, (void*) NULL, 0);
31837 G__memfunc_setup("setTexpMuon",1164,G__RootEventData_rootcint_211_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpmu", (char*)NULL, (void*) NULL, 0);
31838 G__memfunc_setup("setTexpPion",1155,G__RootEventData_rootcint_211_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texppi", (char*)NULL, (void*) NULL, 0);
31839 G__memfunc_setup("setTexpKaon",1142,G__RootEventData_rootcint_211_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpk", (char*)NULL, (void*) NULL, 0);
31840 G__memfunc_setup("setTexpProton",1391,G__RootEventData_rootcint_211_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpp", (char*)NULL, (void*) NULL, 0);
31841 G__memfunc_setup("setToffset",1063,G__RootEventData_rootcint_211_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - toffset", (char*)NULL, (void*) NULL, 0);
31842 G__memfunc_setup("setToffsetElectron",1891,G__RootEventData_rootcint_211_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - toe", (char*)NULL, (void*) NULL, 0);
31843 G__memfunc_setup("setToffsetMuon",1478,G__RootEventData_rootcint_211_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tomu", (char*)NULL, (void*) NULL, 0);
31844 G__memfunc_setup("setToffsetPion",1469,G__RootEventData_rootcint_211_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topi", (char*)NULL, (void*) NULL, 0);
31845 G__memfunc_setup("setToffsetKaon",1456,G__RootEventData_rootcint_211_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tok", (char*)NULL, (void*) NULL, 0);
31846 G__memfunc_setup("setToffsetProton",1705,G__RootEventData_rootcint_211_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - top", (char*)NULL, (void*) NULL, 0);
31847 G__memfunc_setup("setToffsetAntiProton",2101,G__RootEventData_rootcint_211_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topb", (char*)NULL, (void*) NULL, 0);
31848 G__memfunc_setup("setSigma",829,G__RootEventData_rootcint_211_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - sigma", (char*)NULL, (void*) NULL, 0);
31849 G__memfunc_setup("setSigmaElectron",1657,G__RootEventData_rootcint_211_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - se", (char*)NULL, (void*) NULL, 0);
31850 G__memfunc_setup("setSigmaMuon",1244,G__RootEventData_rootcint_211_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - smu", (char*)NULL, (void*) NULL, 0);
31851 G__memfunc_setup("setSigmaPion",1235,G__RootEventData_rootcint_211_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spi", (char*)NULL, (void*) NULL, 0);
31852 G__memfunc_setup("setSigmaKaon",1222,G__RootEventData_rootcint_211_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sk", (char*)NULL, (void*) NULL, 0);
31853 G__memfunc_setup("setSigmaProton",1471,G__RootEventData_rootcint_211_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sp", (char*)NULL, (void*) NULL, 0);
31854 G__memfunc_setup("setSigmaAntiProton",1867,G__RootEventData_rootcint_211_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spb", (char*)NULL, (void*) NULL, 0);
31855 G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_211_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - quality", (char*)NULL, (void*) NULL, 0);
31856 G__memfunc_setup("setT0",464,G__RootEventData_rootcint_211_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t0", (char*)NULL, (void*) NULL, 0);
31857 G__memfunc_setup("setErrT0",761,G__RootEventData_rootcint_211_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errt0", (char*)NULL, (void*) NULL, 0);
31858 G__memfunc_setup("setErrZ",719,G__RootEventData_rootcint_211_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errz", (char*)NULL, (void*) NULL, 0);
31859 G__memfunc_setup("setPhi",621,G__RootEventData_rootcint_211_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
31860 G__memfunc_setup("setErrPhi",918,G__RootEventData_rootcint_211_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errphi", (char*)NULL, (void*) NULL, 0);
31861 G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_211_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
31862 G__memfunc_setup("setErrEnergy",1247,G__RootEventData_rootcint_211_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errenergy", (char*)NULL, (void*) NULL, 0);
31863 G__memfunc_setup("setTRecTofTrack",1496,G__RootEventData_rootcint_211_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTofTrack' - 10 - toftrk", (char*)NULL, (void*) NULL, 0);
31864 G__memfunc_setup("Class",502,G__RootEventData_rootcint_211_0_79, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecTofTrack::Class) ), 0);
31865 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_211_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTofTrack::Class_Name) ), 0);
31866 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_211_0_81, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecTofTrack::Class_Version) ), 0);
31867 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_211_0_82, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecTofTrack::Dictionary) ), 0);
31868 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31869 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31870 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31871 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_211_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31872 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_211_0_87, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTofTrack::DeclFileName) ), 0);
31873 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_211_0_88, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTofTrack::ImplFileLine) ), 0);
31874 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_211_0_89, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTofTrack::ImplFileName) ), 0);
31875 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_211_0_90, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTofTrack::DeclFileLine) ), 0);
31876 // automatic copy constructor
31877 G__memfunc_setup("TRecTofTrack", 1164, G__RootEventData_rootcint_211_0_91, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 1, 1, 1, 0, "u 'TRecTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31878 // automatic destructor
31879 G__memfunc_setup("~TRecTofTrack", 1290, G__RootEventData_rootcint_211_0_92, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31880 // automatic assignment operator
31881 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_211_0_93, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 1, 1, 1, 1, 0, "u 'TRecTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
31882 G__tag_memfunc_reset();
31883}
31884
31885static void G__setup_memfuncTRecEmcHit(void) {
31886 /* TRecEmcHit */
31887 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
31888 G__memfunc_setup("TRecEmcHit",936,G__RootEventData_rootcint_212_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31889 G__memfunc_setup("cellId",589,G__RootEventData_rootcint_212_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31890 G__memfunc_setup("energy",650,G__RootEventData_rootcint_212_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31891 G__memfunc_setup("time",431,G__RootEventData_rootcint_212_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31892 G__memfunc_setup("setCellId",889,G__RootEventData_rootcint_212_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
31893 G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_212_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e", (char*)NULL, (void*) NULL, 0);
31894 G__memfunc_setup("setTime",731,G__RootEventData_rootcint_212_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
31895 G__memfunc_setup("Class",502,G__RootEventData_rootcint_212_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEmcHit::Class) ), 0);
31896 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_212_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcHit::Class_Name) ), 0);
31897 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_212_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEmcHit::Class_Version) ), 0);
31898 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_212_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEmcHit::Dictionary) ), 0);
31899 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31900 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31901 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31902 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_212_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31903 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_212_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcHit::DeclFileName) ), 0);
31904 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_212_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcHit::ImplFileLine) ), 0);
31905 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_212_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcHit::ImplFileName) ), 0);
31906 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_212_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcHit::DeclFileLine) ), 0);
31907 // automatic copy constructor
31908 G__memfunc_setup("TRecEmcHit", 936, G__RootEventData_rootcint_212_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 0, 1, 1, 1, 0, "u 'TRecEmcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
31909 // automatic destructor
31910 G__memfunc_setup("~TRecEmcHit", 1062, G__RootEventData_rootcint_212_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31911 // automatic assignment operator
31912 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_212_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 1, 1, 1, 1, 0, "u 'TRecEmcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
31913 G__tag_memfunc_reset();
31914}
31915
31916static void G__setup_memfuncTRecEmcCluster(void) {
31917 /* TRecEmcCluster */
31918 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
31919 G__memfunc_setup("TRecEmcCluster",1381,G__RootEventData_rootcint_213_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31920 G__memfunc_setup("clusterId",943,G__RootEventData_rootcint_213_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31921 G__memfunc_setup("vecHits",726,G__RootEventData_rootcint_213_0_3, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31922 G__memfunc_setup("vecSeeds",818,G__RootEventData_rootcint_213_0_4, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31923 G__memfunc_setup("vecShowers",1065,G__RootEventData_rootcint_213_0_5, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31924 G__memfunc_setup("setClusterId",1243,G__RootEventData_rootcint_213_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
31925 G__memfunc_setup("setVecHits",1026,G__RootEventData_rootcint_213_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vecHits", (char*)NULL, (void*) NULL, 0);
31926 G__memfunc_setup("setVecSeeds",1118,G__RootEventData_rootcint_213_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vecSeeds", (char*)NULL, (void*) NULL, 0);
31927 G__memfunc_setup("setVecShowers",1365,G__RootEventData_rootcint_213_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vecShowers", (char*)NULL, (void*) NULL, 0);
31928 G__memfunc_setup("Class",502,G__RootEventData_rootcint_213_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEmcCluster::Class) ), 0);
31929 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_213_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcCluster::Class_Name) ), 0);
31930 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_213_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEmcCluster::Class_Version) ), 0);
31931 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_213_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEmcCluster::Dictionary) ), 0);
31932 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
31933 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
31934 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
31935 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_213_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
31936 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_213_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcCluster::DeclFileName) ), 0);
31937 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_213_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcCluster::ImplFileLine) ), 0);
31938 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_213_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcCluster::ImplFileName) ), 0);
31939 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_213_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcCluster::DeclFileLine) ), 0);
31940 // automatic copy constructor
31941 G__memfunc_setup("TRecEmcCluster", 1381, G__RootEventData_rootcint_213_0_22, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 0, 1, 1, 1, 0, "u 'TRecEmcCluster' - 11 - -", (char*) NULL, (void*) NULL, 0);
31942 // automatic destructor
31943 G__memfunc_setup("~TRecEmcCluster", 1507, G__RootEventData_rootcint_213_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
31944 // automatic assignment operator
31945 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_213_0_24, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 1, 1, 1, 1, 0, "u 'TRecEmcCluster' - 11 - -", (char*) NULL, (void*) NULL, 0);
31946 G__tag_memfunc_reset();
31947}
31948
31949static void G__setup_memfuncTRecEmcShower(void) {
31950 /* TRecEmcShower */
31951 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
31952 G__memfunc_setup("TRecEmcShower",1275,G__RootEventData_rootcint_449_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
31953 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_449_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31954 G__memfunc_setup("numHits",744,G__RootEventData_rootcint_449_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31955 G__memfunc_setup("status",676,G__RootEventData_rootcint_449_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31956 G__memfunc_setup("cellId",589,G__RootEventData_rootcint_449_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31957 G__memfunc_setup("module",646,G__RootEventData_rootcint_449_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31958 G__memfunc_setup("x",120,G__RootEventData_rootcint_449_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31959 G__memfunc_setup("y",121,G__RootEventData_rootcint_449_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31960 G__memfunc_setup("z",122,G__RootEventData_rootcint_449_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31961 G__memfunc_setup("theta",534,G__RootEventData_rootcint_449_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31962 G__memfunc_setup("dtheta",634,G__RootEventData_rootcint_449_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31963 G__memfunc_setup("phi",321,G__RootEventData_rootcint_449_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31964 G__memfunc_setup("dphi",421,G__RootEventData_rootcint_449_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31965 G__memfunc_setup("energy",650,G__RootEventData_rootcint_449_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31966 G__memfunc_setup("dE",169,G__RootEventData_rootcint_449_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31967 G__memfunc_setup("eSeed",486,G__RootEventData_rootcint_449_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31968 G__memfunc_setup("e3x3",323,G__RootEventData_rootcint_449_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31969 G__memfunc_setup("e5x5",327,G__RootEventData_rootcint_449_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31970 G__memfunc_setup("eAll",382,G__RootEventData_rootcint_449_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31971 G__memfunc_setup("eLepton",727,G__RootEventData_rootcint_449_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31972 G__memfunc_setup("time",431,G__RootEventData_rootcint_449_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31973 G__memfunc_setup("secondMoment",1260,G__RootEventData_rootcint_449_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31974 G__memfunc_setup("latMoment",945,G__RootEventData_rootcint_449_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31975 G__memfunc_setup("a20Moment",819,G__RootEventData_rootcint_449_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31976 G__memfunc_setup("a42Moment",823,G__RootEventData_rootcint_449_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31977 G__memfunc_setup("err",329,G__RootEventData_rootcint_449_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
31978 G__memfunc_setup("cellIdMap",875,G__RootEventData_rootcint_449_0_27, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR), G__defined_typename("map<Int_t,Double_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31979 G__memfunc_setup("cellId3x3",811,G__RootEventData_rootcint_449_0_28, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31980 G__memfunc_setup("cellId5x5",815,G__RootEventData_rootcint_449_0_29, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31981 G__memfunc_setup("clusterId",943,G__RootEventData_rootcint_449_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
31982 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_449_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
31983 G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_449_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - hit", (char*)NULL, (void*) NULL, 0);
31984 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_449_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - st", (char*)NULL, (void*) NULL, 0);
31985 G__memfunc_setup("setCellId",889,G__RootEventData_rootcint_449_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
31986 G__memfunc_setup("setModule",946,G__RootEventData_rootcint_449_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - mod", (char*)NULL, (void*) NULL, 0);
31987 G__memfunc_setup("setX",420,G__RootEventData_rootcint_449_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 0);
31988 G__memfunc_setup("setY",421,G__RootEventData_rootcint_449_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
31989 G__memfunc_setup("setZ",422,G__RootEventData_rootcint_449_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - z", (char*)NULL, (void*) NULL, 0);
31990 G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_449_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e", (char*)NULL, (void*) NULL, 0);
31991 G__memfunc_setup("setDE",469,G__RootEventData_rootcint_449_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - de", (char*)NULL, (void*) NULL, 0);
31992 G__memfunc_setup("setTheta",834,G__RootEventData_rootcint_449_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
31993 G__memfunc_setup("setDtheta",934,G__RootEventData_rootcint_449_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dt", (char*)NULL, (void*) NULL, 0);
31994 G__memfunc_setup("setPhi",621,G__RootEventData_rootcint_449_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - pi", (char*)NULL, (void*) NULL, 0);
31995 G__memfunc_setup("setDphi",721,G__RootEventData_rootcint_449_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dpi", (char*)NULL, (void*) NULL, 0);
31996 G__memfunc_setup("setESeed",786,G__RootEventData_rootcint_449_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - eSeed", (char*)NULL, (void*) NULL, 0);
31997 G__memfunc_setup("setE3x3",623,G__RootEventData_rootcint_449_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e3x3", (char*)NULL, (void*) NULL, 0);
31998 G__memfunc_setup("setE5x5",627,G__RootEventData_rootcint_449_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e5x5", (char*)NULL, (void*) NULL, 0);
31999 G__memfunc_setup("setEAll",682,G__RootEventData_rootcint_449_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - eall", (char*)NULL, (void*) NULL, 0);
32000 G__memfunc_setup("setELepton",1027,G__RootEventData_rootcint_449_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - elepton", (char*)NULL, (void*) NULL, 0);
32001 G__memfunc_setup("setTime",731,G__RootEventData_rootcint_449_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
32002 G__memfunc_setup("setSecondMoment",1560,G__RootEventData_rootcint_449_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - secondMoment", (char*)NULL, (void*) NULL, 0);
32003 G__memfunc_setup("setLatMoment",1245,G__RootEventData_rootcint_449_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - latMoment", (char*)NULL, (void*) NULL, 0);
32004 G__memfunc_setup("setA20Moment",1119,G__RootEventData_rootcint_449_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a20Moment", (char*)NULL, (void*) NULL, 0);
32005 G__memfunc_setup("setA42Moment",1123,G__RootEventData_rootcint_449_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a42Moment", (char*)NULL, (void*) NULL, 0);
32006 G__memfunc_setup("setErr",629,G__RootEventData_rootcint_449_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - err", (char*)NULL, (void*) NULL, 0);
32007 G__memfunc_setup("setCellIdMap",1175,G__RootEventData_rootcint_449_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<int,double,less<int>,allocator<pair<const int,double> > >' 'map<Int_t,Double_t>' 11 - cellIdMap", (char*)NULL, (void*) NULL, 0);
32008 G__memfunc_setup("setCellId3x3",1111,G__RootEventData_rootcint_449_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - cellId3x3", (char*)NULL, (void*) NULL, 0);
32009 G__memfunc_setup("setCellId5x5",1115,G__RootEventData_rootcint_449_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - cellId5x5", (char*)NULL, (void*) NULL, 0);
32010 G__memfunc_setup("setClusterId",1243,G__RootEventData_rootcint_449_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - clusterId", (char*)NULL, (void*) NULL, 0);
32011 G__memfunc_setup("setTRecEmcShower",1607,G__RootEventData_rootcint_449_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcShower' - 10 - emcshower", (char*)NULL, (void*) NULL, 0);
32012 G__memfunc_setup("Class",502,G__RootEventData_rootcint_449_0_61, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEmcShower::Class) ), 0);
32013 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_449_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcShower::Class_Name) ), 0);
32014 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_449_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEmcShower::Class_Version) ), 0);
32015 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_449_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEmcShower::Dictionary) ), 0);
32016 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32017 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32018 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32019 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_449_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32020 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_449_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcShower::DeclFileName) ), 0);
32021 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_449_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcShower::ImplFileLine) ), 0);
32022 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_449_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcShower::ImplFileName) ), 0);
32023 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_449_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcShower::DeclFileLine) ), 0);
32024 // automatic copy constructor
32025 G__memfunc_setup("TRecEmcShower", 1275, G__RootEventData_rootcint_449_0_73, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 1, 1, 1, 0, "u 'TRecEmcShower' - 11 - -", (char*) NULL, (void*) NULL, 0);
32026 // automatic destructor
32027 G__memfunc_setup("~TRecEmcShower", 1401, G__RootEventData_rootcint_449_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32028 // automatic assignment operator
32029 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_449_0_75, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 1, 1, 1, 1, 0, "u 'TRecEmcShower' - 11 - -", (char*) NULL, (void*) NULL, 0);
32030 G__tag_memfunc_reset();
32031}
32032
32033static void G__setup_memfuncTRecMucTrack(void) {
32034 /* TRecMucTrack */
32035 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
32036 G__memfunc_setup("TRecMucTrack",1160,G__RootEventData_rootcint_457_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32037 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_457_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32038 G__memfunc_setup("id",205,G__RootEventData_rootcint_457_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32039 G__memfunc_setup("status",676,G__RootEventData_rootcint_457_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32040 G__memfunc_setup("type",450,G__RootEventData_rootcint_457_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32041 G__memfunc_setup("startPart",965,G__RootEventData_rootcint_457_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "start position of track locates in which part", (void*) NULL, 0);
32042 G__memfunc_setup("endPart",718,G__RootEventData_rootcint_457_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "end position of track locates in which part", (void*) NULL, 0);
32043 G__memfunc_setup("brLastLayer",1125,G__RootEventData_rootcint_457_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in barrel ", (void*) NULL, 0);
32044 G__memfunc_setup("ecLastLayer",1113,G__RootEventData_rootcint_457_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in end cap", (void*) NULL, 0);
32045 G__memfunc_setup("numHits",744,G__RootEventData_rootcint_457_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "total hits on the track ", (void*) NULL, 0);
32046 G__memfunc_setup("numLayers",960,G__RootEventData_rootcint_457_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "number of layers with hits ", (void*) NULL, 0);
32047 G__memfunc_setup("maxHitsInLayer",1426,G__RootEventData_rootcint_457_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32048 G__memfunc_setup("depth",533,G__RootEventData_rootcint_457_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "depth of the track transport in iron", (void*) NULL, 0);
32049 G__memfunc_setup("chi2",358,G__RootEventData_rootcint_457_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32050 G__memfunc_setup("dof",313,G__RootEventData_rootcint_457_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32051 G__memfunc_setup("rms",338,G__RootEventData_rootcint_457_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32052 G__memfunc_setup("distance",843,G__RootEventData_rootcint_457_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32053 G__memfunc_setup("deltaPhi",811,G__RootEventData_rootcint_457_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32054 G__memfunc_setup("xPos",426,G__RootEventData_rootcint_457_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "position on the start of track in muc (vertex) ", (void*) NULL, 0);
32055 G__memfunc_setup("yPos",427,G__RootEventData_rootcint_457_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32056 G__memfunc_setup("zPos",428,G__RootEventData_rootcint_457_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32057 G__memfunc_setup("xPosSigma",923,G__RootEventData_rootcint_457_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "position on the start of track in muc (vertex) ", (void*) NULL, 0);
32058 G__memfunc_setup("yPosSigma",924,G__RootEventData_rootcint_457_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32059 G__memfunc_setup("zPosSigma",925,G__RootEventData_rootcint_457_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32060 G__memfunc_setup("px",232,G__RootEventData_rootcint_457_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "momentum on the start of track in muc", (void*) NULL, 0);
32061 G__memfunc_setup("py",233,G__RootEventData_rootcint_457_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32062 G__memfunc_setup("pz",234,G__RootEventData_rootcint_457_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32063 G__memfunc_setup("vecHits",726,G__RootEventData_rootcint_457_0_28, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32064 G__memfunc_setup("expHits",741,G__RootEventData_rootcint_457_0_29, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32065 G__memfunc_setup("distHits",844,G__RootEventData_rootcint_457_0_30, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32066 G__memfunc_setup("kalRechi2",853,G__RootEventData_rootcint_457_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32067 G__memfunc_setup("kaldof",625,G__RootEventData_rootcint_457_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32068 G__memfunc_setup("kaldepth",845,G__RootEventData_rootcint_457_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32069 G__memfunc_setup("kalbrLastLayer",1437,G__RootEventData_rootcint_457_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32070 G__memfunc_setup("kalecLastLayer",1425,G__RootEventData_rootcint_457_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32071 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_457_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackId", (char*)NULL, (void*) NULL, 0);
32072 G__memfunc_setup("setId",505,G__RootEventData_rootcint_457_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
32073 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_457_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
32074 G__memfunc_setup("setType",750,G__RootEventData_rootcint_457_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
32075 G__memfunc_setup("setStartPart",1265,G__RootEventData_rootcint_457_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
32076 G__memfunc_setup("setEndPart",1018,G__RootEventData_rootcint_457_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
32077 G__memfunc_setup("setBrLastLayer",1425,G__RootEventData_rootcint_457_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
32078 G__memfunc_setup("setEcLastLayer",1413,G__RootEventData_rootcint_457_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
32079 G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_457_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numHits", (char*)NULL, (void*) NULL, 0);
32080 G__memfunc_setup("setNumLayers",1260,G__RootEventData_rootcint_457_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numLayers", (char*)NULL, (void*) NULL, 0);
32081 G__memfunc_setup("setMaxHitsInLayer",1726,G__RootEventData_rootcint_457_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxHits", (char*)NULL, (void*) NULL, 0);
32082 G__memfunc_setup("setDepth",833,G__RootEventData_rootcint_457_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
32083 G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_457_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
32084 G__memfunc_setup("setDof",613,G__RootEventData_rootcint_457_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dof", (char*)NULL, (void*) NULL, 0);
32085 G__memfunc_setup("setRms",638,G__RootEventData_rootcint_457_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rms", (char*)NULL, (void*) NULL, 0);
32086 G__memfunc_setup("setDistance",1143,G__RootEventData_rootcint_457_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dist", (char*)NULL, (void*) NULL, 0);
32087 G__memfunc_setup("setDeltaPhi",1111,G__RootEventData_rootcint_457_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dphi", (char*)NULL, (void*) NULL, 0);
32088 G__memfunc_setup("setXPos",726,G__RootEventData_rootcint_457_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
32089 G__memfunc_setup("setYPos",727,G__RootEventData_rootcint_457_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
32090 G__memfunc_setup("setZPos",728,G__RootEventData_rootcint_457_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
32091 G__memfunc_setup("setXPosSigma",1223,G__RootEventData_rootcint_457_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
32092 G__memfunc_setup("setYPosSigma",1224,G__RootEventData_rootcint_457_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
32093 G__memfunc_setup("setZPosSigma",1225,G__RootEventData_rootcint_457_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
32094 G__memfunc_setup("setPx",532,G__RootEventData_rootcint_457_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
32095 G__memfunc_setup("setPy",533,G__RootEventData_rootcint_457_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
32096 G__memfunc_setup("setPz",534,G__RootEventData_rootcint_457_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
32097 G__memfunc_setup("setVecHits",1026,G__RootEventData_rootcint_457_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - vecHits", (char*)NULL, (void*) NULL, 0);
32098 G__memfunc_setup("setExpHits",1041,G__RootEventData_rootcint_457_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - expHits", (char*)NULL, (void*) NULL, 0);
32099 G__memfunc_setup("setDistHits",1144,G__RootEventData_rootcint_457_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - distHits", (char*)NULL, (void*) NULL, 0);
32100 G__memfunc_setup("setkalRechi2",1185,G__RootEventData_rootcint_457_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ch", (char*)NULL, (void*) NULL, 0);
32101 G__memfunc_setup("setkalDof",925,G__RootEventData_rootcint_457_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - f", (char*)NULL, (void*) NULL, 0);
32102 G__memfunc_setup("setkalDepth",1145,G__RootEventData_rootcint_457_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
32103 G__memfunc_setup("setkalbrLastLayer",1769,G__RootEventData_rootcint_457_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - br", (char*)NULL, (void*) NULL, 0);
32104 G__memfunc_setup("setkalecLastLayer",1757,G__RootEventData_rootcint_457_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ec", (char*)NULL, (void*) NULL, 0);
32105 G__memfunc_setup("setTRecMucTrack",1492,G__RootEventData_rootcint_457_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMucTrack' - 10 - muctrk", (char*)NULL, (void*) NULL, 0);
32106 G__memfunc_setup("Class",502,G__RootEventData_rootcint_457_0_71, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMucTrack::Class) ), 0);
32107 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_457_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMucTrack::Class_Name) ), 0);
32108 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_457_0_73, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMucTrack::Class_Version) ), 0);
32109 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_457_0_74, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMucTrack::Dictionary) ), 0);
32110 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32111 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32112 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32113 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_457_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32114 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_457_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMucTrack::DeclFileName) ), 0);
32115 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_457_0_80, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMucTrack::ImplFileLine) ), 0);
32116 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_457_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMucTrack::ImplFileName) ), 0);
32117 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_457_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMucTrack::DeclFileLine) ), 0);
32118 // automatic copy constructor
32119 G__memfunc_setup("TRecMucTrack", 1160, G__RootEventData_rootcint_457_0_83, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 1, 1, 1, 0, "u 'TRecMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32120 // automatic destructor
32121 G__memfunc_setup("~TRecMucTrack", 1286, G__RootEventData_rootcint_457_0_84, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32122 // automatic assignment operator
32123 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_457_0_85, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 1, 1, 1, 1, 0, "u 'TRecMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32124 G__tag_memfunc_reset();
32125}
32126
32127static void G__setup_memfuncTRecMdcDedx(void) {
32128 /* TRecMdcDedx */
32129 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
32130 G__memfunc_setup("TRecMdcDedx",1031,G__RootEventData_rootcint_458_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32131 G__memfunc_setup("mdcTrackId",982,G__RootEventData_rootcint_458_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32132 G__memfunc_setup("mdcKalTrackId",1262,G__RootEventData_rootcint_458_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32133 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_458_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32134 G__memfunc_setup("particleId",1025,G__RootEventData_rootcint_458_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32135 G__memfunc_setup("status",676,G__RootEventData_rootcint_458_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32136 G__memfunc_setup("truncAlg",832,G__RootEventData_rootcint_458_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32137 G__memfunc_setup("chi",308,G__RootEventData_rootcint_458_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
32138 G__memfunc_setup("chiE",377,G__RootEventData_rootcint_458_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32139 G__memfunc_setup("chiMu",502,G__RootEventData_rootcint_458_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32140 G__memfunc_setup("chiPi",493,G__RootEventData_rootcint_458_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32141 G__memfunc_setup("chiK",383,G__RootEventData_rootcint_458_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32142 G__memfunc_setup("chiP",388,G__RootEventData_rootcint_458_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32143 G__memfunc_setup("numGoodHits",1137,G__RootEventData_rootcint_458_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32144 G__memfunc_setup("numTotalHits",1260,G__RootEventData_rootcint_458_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32145 G__memfunc_setup("probPH",587,G__RootEventData_rootcint_458_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32146 G__memfunc_setup("normPH",596,G__RootEventData_rootcint_458_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32147 G__memfunc_setup("errorPH",706,G__RootEventData_rootcint_458_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32148 G__memfunc_setup("twentyPH",835,G__RootEventData_rootcint_458_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32149 G__memfunc_setup("dedxExpect",1038,G__RootEventData_rootcint_458_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - pid", (char*)NULL, (void*) NULL, 0);
32150 G__memfunc_setup("sigmaDedx",918,G__RootEventData_rootcint_458_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - pid", (char*)NULL, (void*) NULL, 0);
32151 G__memfunc_setup("pidProb",720,G__RootEventData_rootcint_458_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - pid", (char*)NULL, (void*) NULL, 0);
32152 G__memfunc_setup("dedxHit",714,G__RootEventData_rootcint_458_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32153 G__memfunc_setup("dedxEsat",818,G__RootEventData_rootcint_458_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32154 G__memfunc_setup("dedxNoRun",919,G__RootEventData_rootcint_458_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32155 G__memfunc_setup("dedxMoment",1045,G__RootEventData_rootcint_458_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32156 G__memfunc_setup("setDedxHit",1014,G__RootEventData_rootcint_458_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_hit", (char*)NULL, (void*) NULL, 0);
32157 G__memfunc_setup("setDedxEsat",1118,G__RootEventData_rootcint_458_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_esat", (char*)NULL, (void*) NULL, 0);
32158 G__memfunc_setup("setDedxNoRun",1219,G__RootEventData_rootcint_458_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_norun", (char*)NULL, (void*) NULL, 0);
32159 G__memfunc_setup("setDedxMoment",1345,G__RootEventData_rootcint_458_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_momentum", (char*)NULL, (void*) NULL, 0);
32160 G__memfunc_setup("setMdcTrackId",1282,G__RootEventData_rootcint_458_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcTrackId", (char*)NULL, (void*) NULL, 0);
32161 G__memfunc_setup("setMdcKalTrackId",1562,G__RootEventData_rootcint_458_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcKalTrackId", (char*)NULL, (void*) NULL, 0);
32162 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_458_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
32163 G__memfunc_setup("setParticleId",1325,G__RootEventData_rootcint_458_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - particleId", (char*)NULL, (void*) NULL, 0);
32164 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_458_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - status", (char*)NULL, (void*) NULL, 0);
32165 G__memfunc_setup("setTruncAlg",1132,G__RootEventData_rootcint_458_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trunc_alg", (char*)NULL, (void*) NULL, 0);
32166 G__memfunc_setup("setChiE",677,G__RootEventData_rootcint_458_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiE", (char*)NULL, (void*) NULL, 0);
32167 G__memfunc_setup("setChiMu",802,G__RootEventData_rootcint_458_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiMu", (char*)NULL, (void*) NULL, 0);
32168 G__memfunc_setup("setChiPi",793,G__RootEventData_rootcint_458_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiPi", (char*)NULL, (void*) NULL, 0);
32169 G__memfunc_setup("setChiK",683,G__RootEventData_rootcint_458_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiK", (char*)NULL, (void*) NULL, 0);
32170 G__memfunc_setup("setChiP",688,G__RootEventData_rootcint_458_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiP", (char*)NULL, (void*) NULL, 0);
32171 G__memfunc_setup("setNumGoodHits",1437,G__RootEventData_rootcint_458_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numGoodHits", (char*)NULL, (void*) NULL, 0);
32172 G__memfunc_setup("setNumTotalHits",1560,G__RootEventData_rootcint_458_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numTotalHits", (char*)NULL, (void*) NULL, 0);
32173 G__memfunc_setup("setProbPH",887,G__RootEventData_rootcint_458_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - probPH", (char*)NULL, (void*) NULL, 0);
32174 G__memfunc_setup("setNormPH",896,G__RootEventData_rootcint_458_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - normPH", (char*)NULL, (void*) NULL, 0);
32175 G__memfunc_setup("setErrorPH",1006,G__RootEventData_rootcint_458_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - errorPH", (char*)NULL, (void*) NULL, 0);
32176 G__memfunc_setup("setTwentyPH",1135,G__RootEventData_rootcint_458_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - twentyPH", (char*)NULL, (void*) NULL, 0);
32177 G__memfunc_setup("setChi",608,G__RootEventData_rootcint_458_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - chi", (char*)NULL, (void*) NULL, 0);
32178 G__memfunc_setup("setDedxExpect",1338,G__RootEventData_rootcint_458_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - dedx_exp", (char*)NULL, (void*) NULL, 0);
32179 G__memfunc_setup("setSigmaDedx",1218,G__RootEventData_rootcint_458_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - sigma_dedx", (char*)NULL, (void*) NULL, 0);
32180 G__memfunc_setup("setPidProb",1020,G__RootEventData_rootcint_458_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - pid_prob", (char*)NULL, (void*) NULL, 0);
32181 G__memfunc_setup("Class",502,G__RootEventData_rootcint_458_0_52, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcDedx::Class) ), 0);
32182 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_458_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedx::Class_Name) ), 0);
32183 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_458_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcDedx::Class_Version) ), 0);
32184 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_458_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcDedx::Dictionary) ), 0);
32185 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32186 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32187 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32188 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_458_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32189 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_458_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedx::DeclFileName) ), 0);
32190 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_458_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedx::ImplFileLine) ), 0);
32191 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_458_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedx::ImplFileName) ), 0);
32192 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_458_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedx::DeclFileLine) ), 0);
32193 // automatic copy constructor
32194 G__memfunc_setup("TRecMdcDedx", 1031, G__RootEventData_rootcint_458_0_64, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 0, 1, 1, 1, 0, "u 'TRecMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
32195 // automatic destructor
32196 G__memfunc_setup("~TRecMdcDedx", 1157, G__RootEventData_rootcint_458_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32197 // automatic assignment operator
32198 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_458_0_66, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 1, 1, 1, 1, 0, "u 'TRecMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
32199 G__tag_memfunc_reset();
32200}
32201
32202static void G__setup_memfuncTRecMdcDedxHit(void) {
32203 /* TRecMdcDedxHit */
32204 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
32205 G__memfunc_setup("TRecMdcDedxHit",1324,G__RootEventData_rootcint_459_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32206 G__memfunc_setup("isGrouped",946,G__RootEventData_rootcint_459_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32207 G__memfunc_setup("mdcHitId",774,G__RootEventData_rootcint_459_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
32208 G__memfunc_setup("mdcKalHelixSegId",1554,G__RootEventData_rootcint_459_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
32209 G__memfunc_setup("trkId",510,G__RootEventData_rootcint_459_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32210 G__memfunc_setup("flagLR",568,G__RootEventData_rootcint_459_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32211 G__memfunc_setup("mdcId",481,G__RootEventData_rootcint_459_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32212 G__memfunc_setup("pathLength",1039,G__RootEventData_rootcint_459_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32213 G__memfunc_setup("getDedx",709,G__RootEventData_rootcint_459_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32214 G__memfunc_setup("setMdcHitId",1074,G__RootEventData_rootcint_459_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcHitId", (char*)NULL, (void*) NULL, 0);
32215 G__memfunc_setup("setMdcKalHelixSegId",1854,G__RootEventData_rootcint_459_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcKalHelixSegId", (char*)NULL, (void*) NULL, 0);
32216 G__memfunc_setup("setDedx",721,G__RootEventData_rootcint_459_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - dedx", (char*)NULL, (void*) NULL, 0);
32217 G__memfunc_setup("setIsGrouped",1246,G__RootEventData_rootcint_459_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isGrouped", (char*)NULL, (void*) NULL, 0);
32218 G__memfunc_setup("setTrkId",810,G__RootEventData_rootcint_459_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trkid", (char*)NULL, (void*) NULL, 0);
32219 G__memfunc_setup("setFlagLR",868,G__RootEventData_rootcint_459_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lr", (char*)NULL, (void*) NULL, 0);
32220 G__memfunc_setup("setMdcId",781,G__RootEventData_rootcint_459_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mdcid", (char*)NULL, (void*) NULL, 0);
32221 G__memfunc_setup("setPathLength",1339,G__RootEventData_rootcint_459_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - pathlength", (char*)NULL, (void*) NULL, 0);
32222 G__memfunc_setup("Class",502,G__RootEventData_rootcint_459_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcDedxHit::Class) ), 0);
32223 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_459_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedxHit::Class_Name) ), 0);
32224 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_459_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcDedxHit::Class_Version) ), 0);
32225 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_459_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcDedxHit::Dictionary) ), 0);
32226 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32227 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32228 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32229 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_459_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32230 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_459_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedxHit::DeclFileName) ), 0);
32231 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_459_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedxHit::ImplFileLine) ), 0);
32232 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_459_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedxHit::ImplFileName) ), 0);
32233 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_459_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedxHit::DeclFileLine) ), 0);
32234 // automatic copy constructor
32235 G__memfunc_setup("TRecMdcDedxHit", 1324, G__RootEventData_rootcint_459_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 0, 1, 1, 1, 0, "u 'TRecMdcDedxHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
32236 // automatic destructor
32237 G__memfunc_setup("~TRecMdcDedxHit", 1450, G__RootEventData_rootcint_459_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32238 // automatic assignment operator
32239 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_459_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 1, 1, 1, 1, 0, "u 'TRecMdcDedxHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
32240 G__tag_memfunc_reset();
32241}
32242
32243static void G__setup_memfuncTRecExtTrack(void) {
32244 /* TRecExtTrack */
32245 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
32246 G__memfunc_setup("TRecExtTrack",1172,G__RootEventData_rootcint_460_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32247 G__memfunc_setup("SetTrackId",974,G__RootEventData_rootcint_460_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
32248 G__memfunc_setup("SetTof1PositionX",1587,G__RootEventData_rootcint_460_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
32249"d - 'Double_t' 10 - Tof1PositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32250 G__memfunc_setup("SetTof1PositionY",1588,G__RootEventData_rootcint_460_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
32251"d - 'Double_t' 10 - Tof1PositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32252 G__memfunc_setup("SetTof1PositionZ",1589,G__RootEventData_rootcint_460_0_5, 121, -1, -1, 0, 2, 1, 1, 0,
32253"d - 'Double_t' 10 - Tof1PositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32254 G__memfunc_setup("SetTof1MomentumX",1584,G__RootEventData_rootcint_460_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
32255"d - 'Double_t' 10 - Tof1MomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32256 G__memfunc_setup("SetTof1MomentumY",1585,G__RootEventData_rootcint_460_0_7, 121, -1, -1, 0, 2, 1, 1, 0,
32257"d - 'Double_t' 10 - Tof1MomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32258 G__memfunc_setup("SetTof1MomentumZ",1586,G__RootEventData_rootcint_460_0_8, 121, -1, -1, 0, 2, 1, 1, 0,
32259"d - 'Double_t' 10 - Tof1MomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32260 G__memfunc_setup("SetTof1VolumeName",1663,G__RootEventData_rootcint_460_0_9, 121, -1, -1, 0, 2, 1, 1, 0,
32261"u 'TString' - 10 - Tof1VolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32262 G__memfunc_setup("SetTof1VolumeNumber",1895,G__RootEventData_rootcint_460_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
32263"i - 'Int_t' 10 - Tof1VolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32264 G__memfunc_setup("SetTof1",646,G__RootEventData_rootcint_460_0_11, 121, -1, -1, 0, 2, 1, 1, 0,
32265"d - 'Double_t' 10 - Tof1 i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32266 G__memfunc_setup("SetTof1Path",1043,G__RootEventData_rootcint_460_0_12, 121, -1, -1, 0, 2, 1, 1, 0,
32267"d - 'Double_t' 10 - Tof1Path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32268 G__memfunc_setup("SetTof1PosSigmaAlongZ",2036,G__RootEventData_rootcint_460_0_13, 121, -1, -1, 0, 2, 1, 1, 0,
32269"d - 'Double_t' 10 - Tof1PosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32270 G__memfunc_setup("SetTof1PosSigmaAlongT",2030,G__RootEventData_rootcint_460_0_14, 121, -1, -1, 0, 2, 1, 1, 0,
32271"d - 'Double_t' 10 - Tof1PosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32272 G__memfunc_setup("SetTof1PosSigmaAlongX",2034,G__RootEventData_rootcint_460_0_15, 121, -1, -1, 0, 2, 1, 1, 0,
32273"d - 'Double_t' 10 - Tof1PosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32274 G__memfunc_setup("SetTof1PosSigmaAlongY",2035,G__RootEventData_rootcint_460_0_16, 121, -1, -1, 0, 2, 1, 1, 0,
32275"d - 'Double_t' 10 - Tof1PosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32276 G__memfunc_setup("SetTof1ErrorMatrix",1797,G__RootEventData_rootcint_460_0_17, 121, -1, -1, 0, 2, 1, 1, 0,
32277"D - 'Double_t' 12 - Tof1ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32278 G__memfunc_setup("SetTof2PositionX",1588,G__RootEventData_rootcint_460_0_18, 121, -1, -1, 0, 2, 1, 1, 0,
32279"d - 'Double_t' 10 - Tof2PositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32280 G__memfunc_setup("SetTof2PositionY",1589,G__RootEventData_rootcint_460_0_19, 121, -1, -1, 0, 2, 1, 1, 0,
32281"d - 'Double_t' 10 - Tof2PositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32282 G__memfunc_setup("SetTof2PositionZ",1590,G__RootEventData_rootcint_460_0_20, 121, -1, -1, 0, 2, 1, 1, 0,
32283"d - 'Double_t' 10 - Tof2PositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32284 G__memfunc_setup("SetTof2MomentumX",1585,G__RootEventData_rootcint_460_0_21, 121, -1, -1, 0, 2, 1, 1, 0,
32285"d - 'Double_t' 10 - Tof2MomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32286 G__memfunc_setup("SetTof2MomentumY",1586,G__RootEventData_rootcint_460_0_22, 121, -1, -1, 0, 2, 1, 1, 0,
32287"d - 'Double_t' 10 - Tof2MomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32288 G__memfunc_setup("SetTof2MomentumZ",1587,G__RootEventData_rootcint_460_0_23, 121, -1, -1, 0, 2, 1, 1, 0,
32289"d - 'Double_t' 10 - Tof2MomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32290 G__memfunc_setup("SetTof2VolumeName",1664,G__RootEventData_rootcint_460_0_24, 121, -1, -1, 0, 2, 1, 1, 0,
32291"u 'TString' - 10 - Tof2VolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32292 G__memfunc_setup("SetTof2VolumeNumber",1896,G__RootEventData_rootcint_460_0_25, 121, -1, -1, 0, 2, 1, 1, 0,
32293"i - 'Int_t' 10 - Tof2VolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32294 G__memfunc_setup("SetTof2",647,G__RootEventData_rootcint_460_0_26, 121, -1, -1, 0, 2, 1, 1, 0,
32295"d - 'Double_t' 10 - Tof2 i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32296 G__memfunc_setup("SetTof2Path",1044,G__RootEventData_rootcint_460_0_27, 121, -1, -1, 0, 2, 1, 1, 0,
32297"d - 'Double_t' 10 - Tof2Path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32298 G__memfunc_setup("SetTof2PosSigmaAlongZ",2037,G__RootEventData_rootcint_460_0_28, 121, -1, -1, 0, 2, 1, 1, 0,
32299"d - 'Double_t' 10 - Tof2PosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32300 G__memfunc_setup("SetTof2PosSigmaAlongT",2031,G__RootEventData_rootcint_460_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
32301"d - 'Double_t' 10 - Tof2PosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32302 G__memfunc_setup("SetTof2PosSigmaAlongX",2035,G__RootEventData_rootcint_460_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
32303"d - 'Double_t' 10 - Tof2PosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32304 G__memfunc_setup("SetTof2PosSigmaAlongY",2036,G__RootEventData_rootcint_460_0_31, 121, -1, -1, 0, 2, 1, 1, 0,
32305"d - 'Double_t' 10 - Tof2PosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32306 G__memfunc_setup("SetTof2ErrorMatrix",1798,G__RootEventData_rootcint_460_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
32307"D - 'Double_t' 12 - Tof2ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32308 G__memfunc_setup("SetEmcPositionX",1518,G__RootEventData_rootcint_460_0_33, 121, -1, -1, 0, 2, 1, 1, 0,
32309"d - 'Double_t' 10 - EmcPositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32310 G__memfunc_setup("SetEmcPositionY",1519,G__RootEventData_rootcint_460_0_34, 121, -1, -1, 0, 2, 1, 1, 0,
32311"d - 'Double_t' 10 - EmcPositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32312 G__memfunc_setup("SetEmcPositionZ",1520,G__RootEventData_rootcint_460_0_35, 121, -1, -1, 0, 2, 1, 1, 0,
32313"d - 'Double_t' 10 - EmcPositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32314 G__memfunc_setup("SetEmcMomentumX",1515,G__RootEventData_rootcint_460_0_36, 121, -1, -1, 0, 2, 1, 1, 0,
32315"d - 'Double_t' 10 - EmcMomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32316 G__memfunc_setup("SetEmcMomentumY",1516,G__RootEventData_rootcint_460_0_37, 121, -1, -1, 0, 2, 1, 1, 0,
32317"d - 'Double_t' 10 - EmcMomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32318 G__memfunc_setup("SetEmcMomentumZ",1517,G__RootEventData_rootcint_460_0_38, 121, -1, -1, 0, 2, 1, 1, 0,
32319"d - 'Double_t' 10 - EmcMomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32320 G__memfunc_setup("SetEmcVolumeName",1594,G__RootEventData_rootcint_460_0_39, 121, -1, -1, 0, 2, 1, 1, 0,
32321"u 'TString' - 10 - EmcVolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32322 G__memfunc_setup("SetEmcVolumeNumber",1826,G__RootEventData_rootcint_460_0_40, 121, -1, -1, 0, 2, 1, 1, 0,
32323"i - 'Int_t' 10 - EmcVolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32324 G__memfunc_setup("SetEmcPosSigmaAlongTheta",2379,G__RootEventData_rootcint_460_0_41, 121, -1, -1, 0, 2, 1, 1, 0,
32325"d - 'Double_t' 10 - EmcPosSigmaAlongTheta i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32326 G__memfunc_setup("SetEmcPosSigmaAlongPhi",2166,G__RootEventData_rootcint_460_0_42, 121, -1, -1, 0, 2, 1, 1, 0,
32327"d - 'Double_t' 10 - EmcPosSigmaAlongPhi i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32328 G__memfunc_setup("SetEmcErrorMatrix",1728,G__RootEventData_rootcint_460_0_43, 121, -1, -1, 0, 2, 1, 1, 0,
32329"D - 'Double_t' 12 - EmcErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32330 G__memfunc_setup("SetEmcPath",974,G__RootEventData_rootcint_460_0_44, 121, -1, -1, 0, 2, 1, 1, 0,
32331"d - 'Double_t' 0 - path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32332 G__memfunc_setup("SetMucPositionX",1534,G__RootEventData_rootcint_460_0_45, 121, -1, -1, 0, 2, 1, 1, 0,
32333"d - 'Double_t' 10 - MucPositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32334 G__memfunc_setup("SetMucPositionY",1535,G__RootEventData_rootcint_460_0_46, 121, -1, -1, 0, 2, 1, 1, 0,
32335"d - 'Double_t' 10 - MucPositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32336 G__memfunc_setup("SetMucPositionZ",1536,G__RootEventData_rootcint_460_0_47, 121, -1, -1, 0, 2, 1, 1, 0,
32337"d - 'Double_t' 10 - MucPositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32338 G__memfunc_setup("SetMucMomentumX",1531,G__RootEventData_rootcint_460_0_48, 121, -1, -1, 0, 2, 1, 1, 0,
32339"d - 'Double_t' 10 - MucMomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32340 G__memfunc_setup("SetMucMomentumY",1532,G__RootEventData_rootcint_460_0_49, 121, -1, -1, 0, 2, 1, 1, 0,
32341"d - 'Double_t' 10 - MucMomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32342 G__memfunc_setup("SetMucMomentumZ",1533,G__RootEventData_rootcint_460_0_50, 121, -1, -1, 0, 2, 1, 1, 0,
32343"d - 'Double_t' 10 - MucMomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32344 G__memfunc_setup("SetMucVolumeName",1610,G__RootEventData_rootcint_460_0_51, 121, -1, -1, 0, 2, 1, 1, 0,
32345"u 'TString' - 10 - MucVolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32346 G__memfunc_setup("SetMucVolumeNumber",1842,G__RootEventData_rootcint_460_0_52, 121, -1, -1, 0, 2, 1, 1, 0,
32347"i - 'Int_t' 10 - MucVolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32348 G__memfunc_setup("SetMucPosSigmaAlongZ",1983,G__RootEventData_rootcint_460_0_53, 121, -1, -1, 0, 2, 1, 1, 0,
32349"d - 'Double_t' 10 - MucPosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32350 G__memfunc_setup("SetMucPosSigmaAlongT",1977,G__RootEventData_rootcint_460_0_54, 121, -1, -1, 0, 2, 1, 1, 0,
32351"d - 'Double_t' 10 - MucPosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32352 G__memfunc_setup("SetMucPosSigmaAlongX",1981,G__RootEventData_rootcint_460_0_55, 121, -1, -1, 0, 2, 1, 1, 0,
32353"d - 'Double_t' 10 - MucPosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32354 G__memfunc_setup("SetMucPosSigmaAlongY",1982,G__RootEventData_rootcint_460_0_56, 121, -1, -1, 0, 2, 1, 1, 0,
32355"d - 'Double_t' 10 - MucPosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32356 G__memfunc_setup("SetMucErrorMatrix",1744,G__RootEventData_rootcint_460_0_57, 121, -1, -1, 0, 2, 1, 1, 0,
32357"D - 'Double_t' 12 - MucErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32358 G__memfunc_setup("SetSize",711,G__RootEventData_rootcint_460_0_58, 121, -1, -1, 0, 2, 1, 1, 0,
32359"i - 'Int_t' 0 - size i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32360 G__memfunc_setup("SetExtMucHit",1191,G__RootEventData_rootcint_460_0_59, 121, -1, -1, 0, 14, 1, 1, 0,
32361"d - 'Double_t' 0 - PositionX d - 'Double_t' 0 - PositionY "
32362"d - 'Double_t' 0 - PositionZ d - 'Double_t' 0 - MomentumX "
32363"d - 'Double_t' 0 - MomentumY d - 'Double_t' 0 - MomentumZ "
32364"u 'TString' - 0 - VolumeName i - 'Int_t' 0 - VolumeNumber "
32365"d - 'Double_t' 0 - PosSigmaAlongZ d - 'Double_t' 0 - PosSigmaAlongT "
32366"d - 'Double_t' 0 - PosSigmaAlongX d - 'Double_t' 0 - PosSigmaAlongY "
32367"D - 'Double_t' 2 - ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32368 G__memfunc_setup("GetTrackId",962,G__RootEventData_rootcint_460_0_60, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32369 G__memfunc_setup("GetTof1PositionX",1575,G__RootEventData_rootcint_460_0_61, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32370 G__memfunc_setup("GetTof1PositionY",1576,G__RootEventData_rootcint_460_0_62, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32371 G__memfunc_setup("GetTof1PositionZ",1577,G__RootEventData_rootcint_460_0_63, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32372 G__memfunc_setup("GetTof1MomentumX",1572,G__RootEventData_rootcint_460_0_64, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32373 G__memfunc_setup("GetTof1MomentumY",1573,G__RootEventData_rootcint_460_0_65, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32374 G__memfunc_setup("GetTof1MomentumZ",1574,G__RootEventData_rootcint_460_0_66, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32375 G__memfunc_setup("GetTof1VolumeName",1651,G__RootEventData_rootcint_460_0_67, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32376 G__memfunc_setup("GetTof1VolumeNumber",1883,G__RootEventData_rootcint_460_0_68, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32377 G__memfunc_setup("GetTof1",634,G__RootEventData_rootcint_460_0_69, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32378 G__memfunc_setup("GetTof1Path",1031,G__RootEventData_rootcint_460_0_70, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32379 G__memfunc_setup("GetTof1PosSigmaAlongZ",2024,G__RootEventData_rootcint_460_0_71, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32380 G__memfunc_setup("GetTof1PosSigmaAlongT",2018,G__RootEventData_rootcint_460_0_72, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32381 G__memfunc_setup("GetTof1PosSigmaAlongX",2022,G__RootEventData_rootcint_460_0_73, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32382 G__memfunc_setup("GetTof1PosSigmaAlongY",2023,G__RootEventData_rootcint_460_0_74, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32383 G__memfunc_setup("GetTof1ErrorMatrix",1785,G__RootEventData_rootcint_460_0_75, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32384"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32385"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32386 G__memfunc_setup("GetTof2PositionX",1576,G__RootEventData_rootcint_460_0_76, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32387 G__memfunc_setup("GetTof2PositionY",1577,G__RootEventData_rootcint_460_0_77, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32388 G__memfunc_setup("GetTof2PositionZ",1578,G__RootEventData_rootcint_460_0_78, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32389 G__memfunc_setup("GetTof2MomentumX",1573,G__RootEventData_rootcint_460_0_79, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32390 G__memfunc_setup("GetTof2MomentumY",1574,G__RootEventData_rootcint_460_0_80, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32391 G__memfunc_setup("GetTof2MomentumZ",1575,G__RootEventData_rootcint_460_0_81, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32392 G__memfunc_setup("GetTof2VolumeName",1652,G__RootEventData_rootcint_460_0_82, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32393 G__memfunc_setup("GetTof2VolumeNumber",1884,G__RootEventData_rootcint_460_0_83, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32394 G__memfunc_setup("GetTof2",635,G__RootEventData_rootcint_460_0_84, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32395 G__memfunc_setup("GetTof2Path",1032,G__RootEventData_rootcint_460_0_85, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32396 G__memfunc_setup("GetTof2PosSigmaAlongZ",2025,G__RootEventData_rootcint_460_0_86, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32397 G__memfunc_setup("GetTof2PosSigmaAlongT",2019,G__RootEventData_rootcint_460_0_87, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32398 G__memfunc_setup("GetTof2PosSigmaAlongX",2023,G__RootEventData_rootcint_460_0_88, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32399 G__memfunc_setup("GetTof2PosSigmaAlongY",2024,G__RootEventData_rootcint_460_0_89, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32400 G__memfunc_setup("GetTof2ErrorMatrix",1786,G__RootEventData_rootcint_460_0_90, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32401"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32402"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32403 G__memfunc_setup("GetEmcPositionX",1506,G__RootEventData_rootcint_460_0_91, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32404 G__memfunc_setup("GetEmcPositionY",1507,G__RootEventData_rootcint_460_0_92, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32405 G__memfunc_setup("GetEmcPositionZ",1508,G__RootEventData_rootcint_460_0_93, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32406 G__memfunc_setup("GetEmcMomentumX",1503,G__RootEventData_rootcint_460_0_94, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32407 G__memfunc_setup("GetEmcMomentumY",1504,G__RootEventData_rootcint_460_0_95, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32408 G__memfunc_setup("GetEmcMomentumZ",1505,G__RootEventData_rootcint_460_0_96, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32409 G__memfunc_setup("GetEmcVolumeName",1582,G__RootEventData_rootcint_460_0_97, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32410 G__memfunc_setup("GetEmcVolumeNumber",1814,G__RootEventData_rootcint_460_0_98, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32411 G__memfunc_setup("GetEmcPosSigmaAlongTheta",2367,G__RootEventData_rootcint_460_0_99, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32412 G__memfunc_setup("GetEmcPosSigmaAlongPhi",2154,G__RootEventData_rootcint_460_0_100, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32413 G__memfunc_setup("GetEmcErrorMatrix",1716,G__RootEventData_rootcint_460_0_101, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32414"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32415"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32416 G__memfunc_setup("emcPath",706,G__RootEventData_rootcint_460_0_102, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32417 G__memfunc_setup("GetMucPositionX",1522,G__RootEventData_rootcint_460_0_103, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32418 G__memfunc_setup("GetMucPositionY",1523,G__RootEventData_rootcint_460_0_104, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32419 G__memfunc_setup("GetMucPositionZ",1524,G__RootEventData_rootcint_460_0_105, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32420 G__memfunc_setup("GetMucMomentumX",1519,G__RootEventData_rootcint_460_0_106, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32421 G__memfunc_setup("GetMucMomentumY",1520,G__RootEventData_rootcint_460_0_107, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32422 G__memfunc_setup("GetMucMomentumZ",1521,G__RootEventData_rootcint_460_0_108, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32423 G__memfunc_setup("GetMucVolumeName",1598,G__RootEventData_rootcint_460_0_109, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32424 G__memfunc_setup("GetMucVolumeNumber",1830,G__RootEventData_rootcint_460_0_110, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32425 G__memfunc_setup("GetMucPosSigmaAlongZ",1971,G__RootEventData_rootcint_460_0_111, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32426 G__memfunc_setup("GetMucPosSigmaAlongT",1965,G__RootEventData_rootcint_460_0_112, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32427 G__memfunc_setup("GetMucPosSigmaAlongX",1969,G__RootEventData_rootcint_460_0_113, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32428 G__memfunc_setup("GetMucPosSigmaAlongY",1970,G__RootEventData_rootcint_460_0_114, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32429 G__memfunc_setup("GetMucErrorMatrix",1732,G__RootEventData_rootcint_460_0_115, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8,
32430"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
32431"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32432 G__memfunc_setup("GetSize",699,G__RootEventData_rootcint_460_0_116, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
32433 G__memfunc_setup("GetPositionX",1229,G__RootEventData_rootcint_460_0_117, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32434"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32435 G__memfunc_setup("GetPositionY",1230,G__RootEventData_rootcint_460_0_118, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32436"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32437 G__memfunc_setup("GetPositionZ",1231,G__RootEventData_rootcint_460_0_119, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32438"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32439 G__memfunc_setup("GetMomentumX",1226,G__RootEventData_rootcint_460_0_120, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32440"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32441 G__memfunc_setup("GetMomentumY",1227,G__RootEventData_rootcint_460_0_121, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32442"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32443 G__memfunc_setup("GetMomentumZ",1228,G__RootEventData_rootcint_460_0_122, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32444"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32445 G__memfunc_setup("GetVolumeName",1305,G__RootEventData_rootcint_460_0_123, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 2, 1, 1, 8,
32446"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32447 G__memfunc_setup("GetVolumeNumber",1537,G__RootEventData_rootcint_460_0_124, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8,
32448"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32449 G__memfunc_setup("GetPosSigmaAlongZ",1678,G__RootEventData_rootcint_460_0_125, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32450"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32451 G__memfunc_setup("GetPosSigmaAlongT",1672,G__RootEventData_rootcint_460_0_126, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32452"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32453 G__memfunc_setup("GetPosSigmaAlongX",1676,G__RootEventData_rootcint_460_0_127, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32454"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32455 G__memfunc_setup("GetPosSigmaAlongY",1677,G__RootEventData_rootcint_460_0_128, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
32456"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32457 G__memfunc_setup("GetErrorMatrix",1439,G__RootEventData_rootcint_460_0_129, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 2, 1, 1, 8,
32458"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
32459 G__memfunc_setup("Class",502,G__RootEventData_rootcint_460_0_130, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecExtTrack::Class) ), 0);
32460 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_460_0_131, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecExtTrack::Class_Name) ), 0);
32461 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_460_0_132, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecExtTrack::Class_Version) ), 0);
32462 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_460_0_133, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecExtTrack::Dictionary) ), 0);
32463 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32464 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32465 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32466 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_460_0_137, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32467 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_460_0_138, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecExtTrack::DeclFileName) ), 0);
32468 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_460_0_139, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecExtTrack::ImplFileLine) ), 0);
32469 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_460_0_140, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecExtTrack::ImplFileName) ), 0);
32470 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_460_0_141, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecExtTrack::DeclFileLine) ), 0);
32471 // automatic copy constructor
32472 G__memfunc_setup("TRecExtTrack", 1172, G__RootEventData_rootcint_460_0_142, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 0, 1, 1, 1, 0, "u 'TRecExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32473 // automatic destructor
32474 G__memfunc_setup("~TRecExtTrack", 1298, G__RootEventData_rootcint_460_0_143, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32475 // automatic assignment operator
32476 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_460_0_144, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 1, 1, 1, 1, 0, "u 'TRecExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32477 G__tag_memfunc_reset();
32478}
32479
32480static void G__setup_memfuncTRecEvTime(void) {
32481 /* TRecEvTime */
32482 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
32483 G__memfunc_setup("TRecEvTime",952,G__RootEventData_rootcint_469_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32484 G__memfunc_setup("status",676,G__RootEventData_rootcint_469_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32485 G__memfunc_setup("estime",647,G__RootEventData_rootcint_469_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32486 G__memfunc_setup("quality",777,G__RootEventData_rootcint_469_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32487 G__memfunc_setup("setTest",748,G__RootEventData_rootcint_469_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - estime", (char*)NULL, (void*) NULL, 0);
32488 G__memfunc_setup("setStats",859,G__RootEventData_rootcint_469_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 0);
32489 G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_469_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - quality", (char*)NULL, (void*) NULL, 0);
32490 G__memfunc_setup("Class",502,G__RootEventData_rootcint_469_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEvTime::Class) ), 0);
32491 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_469_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEvTime::Class_Name) ), 0);
32492 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_469_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEvTime::Class_Version) ), 0);
32493 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_469_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEvTime::Dictionary) ), 0);
32494 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32495 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32496 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32497 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_469_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32498 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_469_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEvTime::DeclFileName) ), 0);
32499 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_469_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEvTime::ImplFileLine) ), 0);
32500 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_469_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEvTime::ImplFileName) ), 0);
32501 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_469_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEvTime::DeclFileLine) ), 0);
32502 // automatic copy constructor
32503 G__memfunc_setup("TRecEvTime", 952, G__RootEventData_rootcint_469_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 0, 1, 1, 1, 0, "u 'TRecEvTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
32504 // automatic destructor
32505 G__memfunc_setup("~TRecEvTime", 1078, G__RootEventData_rootcint_469_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32506 // automatic assignment operator
32507 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_469_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 1, 1, 1, 1, 0, "u 'TRecEvTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
32508 G__tag_memfunc_reset();
32509}
32510
32511static void G__setup_memfuncTRecMdcKalHelixSeg(void) {
32512 /* TRecMdcKalHelixSeg */
32513 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
32514 G__memfunc_setup("TRecMdcKalHelixSeg",1715,G__RootEventData_rootcint_470_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32515 G__memfunc_setup("getTrackId",994,G__RootEventData_rootcint_470_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32516 G__memfunc_setup("getFlagLR",856,G__RootEventData_rootcint_470_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32517 G__memfunc_setup("getMdcId",769,G__RootEventData_rootcint_470_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32518 G__memfunc_setup("getTdc",603,G__RootEventData_rootcint_470_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32519 G__memfunc_setup("getAdc",584,G__RootEventData_rootcint_470_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32520 G__memfunc_setup("getZhit",735,G__RootEventData_rootcint_470_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32521 G__memfunc_setup("getTof",617,G__RootEventData_rootcint_470_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32522 G__memfunc_setup("getDocaIncl",1085,G__RootEventData_rootcint_470_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32523 G__memfunc_setup("getDocaExcl",1091,G__RootEventData_rootcint_470_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32524 G__memfunc_setup("getDD",456,G__RootEventData_rootcint_470_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32525 G__memfunc_setup("getEntra",826,G__RootEventData_rootcint_470_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32526 G__memfunc_setup("getDT",472,G__RootEventData_rootcint_470_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32527 G__memfunc_setup("getHelixIncl",1216,G__RootEventData_rootcint_470_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32528 G__memfunc_setup("getHelixExcl",1222,G__RootEventData_rootcint_470_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32529 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_470_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trkid", (char*)NULL, (void*) NULL, 0);
32530 G__memfunc_setup("setFlagLR",868,G__RootEventData_rootcint_470_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lr", (char*)NULL, (void*) NULL, 0);
32531 G__memfunc_setup("setMdcId",781,G__RootEventData_rootcint_470_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mdcid", (char*)NULL, (void*) NULL, 0);
32532 G__memfunc_setup("setTdc",615,G__RootEventData_rootcint_470_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tdc", (char*)NULL, (void*) NULL, 0);
32533 G__memfunc_setup("setAdc",596,G__RootEventData_rootcint_470_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - adc", (char*)NULL, (void*) NULL, 0);
32534 G__memfunc_setup("setZhit",747,G__RootEventData_rootcint_470_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zhit", (char*)NULL, (void*) NULL, 0);
32535 G__memfunc_setup("setTof",629,G__RootEventData_rootcint_470_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
32536 G__memfunc_setup("setDocaIncl",1097,G__RootEventData_rootcint_470_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - docaincl", (char*)NULL, (void*) NULL, 0);
32537 G__memfunc_setup("setDocaExcl",1103,G__RootEventData_rootcint_470_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - docaexcl", (char*)NULL, (void*) NULL, 0);
32538 G__memfunc_setup("setDD",468,G__RootEventData_rootcint_470_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dd", (char*)NULL, (void*) NULL, 0);
32539 G__memfunc_setup("setEntra",838,G__RootEventData_rootcint_470_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - entra", (char*)NULL, (void*) NULL, 0);
32540 G__memfunc_setup("setDT",484,G__RootEventData_rootcint_470_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - driftT", (char*)NULL, (void*) NULL, 0);
32541 G__memfunc_setup("setHelixIncl",1228,G__RootEventData_rootcint_470_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
32542 G__memfunc_setup("setHelixExcl",1234,G__RootEventData_rootcint_470_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
32543 G__memfunc_setup("Class",502,G__RootEventData_rootcint_470_0_30, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcKalHelixSeg::Class) ), 0);
32544 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_470_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalHelixSeg::Class_Name) ), 0);
32545 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_470_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcKalHelixSeg::Class_Version) ), 0);
32546 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_470_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcKalHelixSeg::Dictionary) ), 0);
32547 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32548 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32549 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32550 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_470_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32551 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_470_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalHelixSeg::DeclFileName) ), 0);
32552 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_470_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalHelixSeg::ImplFileLine) ), 0);
32553 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_470_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalHelixSeg::ImplFileName) ), 0);
32554 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_470_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalHelixSeg::DeclFileLine) ), 0);
32555 // automatic copy constructor
32556 G__memfunc_setup("TRecMdcKalHelixSeg", 1715, G__RootEventData_rootcint_470_0_42, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 0, 1, 1, 1, 0, "u 'TRecMdcKalHelixSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
32557 // automatic destructor
32558 G__memfunc_setup("~TRecMdcKalHelixSeg", 1841, G__RootEventData_rootcint_470_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32559 // automatic assignment operator
32560 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_470_0_44, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 1, 1, 1, 1, 0, "u 'TRecMdcKalHelixSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
32561 G__tag_memfunc_reset();
32562}
32563
32564static void G__setup_memfuncTRecZddChannel(void) {
32565 /* TRecZddChannel */
32566 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
32567 G__memfunc_setup("TRecZddChannel",1353,G__RootEventData_rootcint_471_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32568 G__memfunc_setup("channelId",902,G__RootEventData_rootcint_471_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32569 G__memfunc_setup("scanCode",800,G__RootEventData_rootcint_471_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32570 G__memfunc_setup("baseLine",803,G__RootEventData_rootcint_471_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32571 G__memfunc_setup("phase",529,G__RootEventData_rootcint_471_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32572 G__memfunc_setup("fragments",967,G__RootEventData_rootcint_471_0_6, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR), G__defined_typename("TRecZddChannel::Fragments"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32573 G__memfunc_setup("setChannelId",1202,G__RootEventData_rootcint_471_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - chId", (char*)NULL, (void*) NULL, 0);
32574 G__memfunc_setup("setScanCode",1100,G__RootEventData_rootcint_471_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - scanCode", (char*)NULL, (void*) NULL, 0);
32575 G__memfunc_setup("setBaseLine",1103,G__RootEventData_rootcint_471_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - baseLine", (char*)NULL, (void*) NULL, 0);
32576 G__memfunc_setup("setPhase",829,G__RootEventData_rootcint_471_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - phase", (char*)NULL, (void*) NULL, 0);
32577 G__memfunc_setup("setFragments",1267,G__RootEventData_rootcint_471_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<pair<int,float>,allocator<pair<int,float> > >' 'TRecZddChannel::Fragments' 11 - frags", (char*)NULL, (void*) NULL, 0);
32578 G__memfunc_setup("Class",502,G__RootEventData_rootcint_471_0_12, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecZddChannel::Class) ), 0);
32579 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_471_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecZddChannel::Class_Name) ), 0);
32580 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_471_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecZddChannel::Class_Version) ), 0);
32581 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_471_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecZddChannel::Dictionary) ), 0);
32582 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32583 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32584 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32585 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_471_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32586 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_471_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecZddChannel::DeclFileName) ), 0);
32587 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_471_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecZddChannel::ImplFileLine) ), 0);
32588 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_471_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecZddChannel::ImplFileName) ), 0);
32589 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_471_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecZddChannel::DeclFileLine) ), 0);
32590 // automatic copy constructor
32591 G__memfunc_setup("TRecZddChannel", 1353, G__RootEventData_rootcint_471_0_24, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 0, 1, 1, 1, 0, "u 'TRecZddChannel' - 11 - -", (char*) NULL, (void*) NULL, 0);
32592 // automatic destructor
32593 G__memfunc_setup("~TRecZddChannel", 1479, G__RootEventData_rootcint_471_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32594 // automatic assignment operator
32595 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_471_0_26, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 1, 1, 1, 1, 0, "u 'TRecZddChannel' - 11 - -", (char*) NULL, (void*) NULL, 0);
32596 G__tag_memfunc_reset();
32597}
32598
32599static void G__setup_memfuncTRecTrackEvent(void) {
32600 /* TRecTrackEvent */
32601 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
32602 G__memfunc_setup("TRecTrackEvent",1381,G__RootEventData_rootcint_477_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32603 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_477_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32604 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
32605 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);
32606 G__memfunc_setup("getRecMdcTrackCol",1665,G__RootEventData_rootcint_477_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32607 G__memfunc_setup("addRecMdcTrack",1356,G__RootEventData_rootcint_477_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32608 G__memfunc_setup("getRecMdcTrack",1379,G__RootEventData_rootcint_477_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32609 G__memfunc_setup("clearRecMdcTrackCol",1864,G__RootEventData_rootcint_477_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32610 G__memfunc_setup("getRecMdcHitCol",1457,G__RootEventData_rootcint_477_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32611 G__memfunc_setup("addRecMdcHit",1148,G__RootEventData_rootcint_477_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcHit' - 0 - Hit", (char*)NULL, (void*) NULL, 0);
32612 G__memfunc_setup("getRecMdcHit",1171,G__RootEventData_rootcint_477_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32613 G__memfunc_setup("clearRecMdcHitCol",1656,G__RootEventData_rootcint_477_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32614 G__memfunc_setup("getTofTrackCol",1404,G__RootEventData_rootcint_477_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32615 G__memfunc_setup("addTofTrack",1095,G__RootEventData_rootcint_477_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTofTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32616 G__memfunc_setup("getTofTrack",1118,G__RootEventData_rootcint_477_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32617 G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_477_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32618 G__memfunc_setup("getEmcHitCol",1176,G__RootEventData_rootcint_477_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32619 G__memfunc_setup("addEmcHit",867,G__RootEventData_rootcint_477_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcHit' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32620 G__memfunc_setup("getEmcHit",890,G__RootEventData_rootcint_477_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32621 G__memfunc_setup("clearEmcHitCol",1375,G__RootEventData_rootcint_477_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32622 G__memfunc_setup("getEmcClusterCol",1621,G__RootEventData_rootcint_477_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32623 G__memfunc_setup("addEmcCluster",1312,G__RootEventData_rootcint_477_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcCluster' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32624 G__memfunc_setup("getEmcCluster",1335,G__RootEventData_rootcint_477_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32625 G__memfunc_setup("clearEmcClusterCol",1820,G__RootEventData_rootcint_477_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32626 G__memfunc_setup("getEmcShowerCol",1515,G__RootEventData_rootcint_477_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32627 G__memfunc_setup("addEmcShower",1206,G__RootEventData_rootcint_477_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcShower' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32628 G__memfunc_setup("getEmcShower",1229,G__RootEventData_rootcint_477_0_27, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32629 G__memfunc_setup("clearEmcShowerCol",1714,G__RootEventData_rootcint_477_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32630 G__memfunc_setup("getMucTrackCol",1400,G__RootEventData_rootcint_477_0_29, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32631 G__memfunc_setup("addMucTrack",1091,G__RootEventData_rootcint_477_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMucTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32632 G__memfunc_setup("getMucTrack",1114,G__RootEventData_rootcint_477_0_31, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32633 G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_477_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32634 G__memfunc_setup("getRecMdcDedxCol",1553,G__RootEventData_rootcint_477_0_33, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32635 G__memfunc_setup("addRecMdcDedx",1244,G__RootEventData_rootcint_477_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcDedx' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32636 G__memfunc_setup("getRecMdcDedx",1267,G__RootEventData_rootcint_477_0_35, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32637 G__memfunc_setup("clearRecMdcDedxCol",1752,G__RootEventData_rootcint_477_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32638 G__memfunc_setup("getRecMdcDedxHitCol",1846,G__RootEventData_rootcint_477_0_37, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32639 G__memfunc_setup("addRecMdcDedxHit",1537,G__RootEventData_rootcint_477_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcDedxHit' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32640 G__memfunc_setup("getRecMdcDedxHit",1560,G__RootEventData_rootcint_477_0_39, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32641 G__memfunc_setup("clearRecMdcDedxHitCol",2045,G__RootEventData_rootcint_477_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32642 G__memfunc_setup("getExtTrackCol",1412,G__RootEventData_rootcint_477_0_41, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32643 G__memfunc_setup("addExtTrack",1103,G__RootEventData_rootcint_477_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecExtTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32644 G__memfunc_setup("getExtTrack",1126,G__RootEventData_rootcint_477_0_43, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32645 G__memfunc_setup("clearExtTrackCol",1611,G__RootEventData_rootcint_477_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32646 G__memfunc_setup("getRecMdcKalTrackCol",1945,G__RootEventData_rootcint_477_0_45, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32647 G__memfunc_setup("addRecMdcKalTrack",1636,G__RootEventData_rootcint_477_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcKalTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32648 G__memfunc_setup("getRecMdcKalTrack",1659,G__RootEventData_rootcint_477_0_47, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32649 G__memfunc_setup("clearRecMdcKalTrackCol",2144,G__RootEventData_rootcint_477_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32650 G__memfunc_setup("getRecMdcKalHelixSegCol",2237,G__RootEventData_rootcint_477_0_49, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32651 G__memfunc_setup("addRecMdcKalHelixSeg",1928,G__RootEventData_rootcint_477_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcKalHelixSeg' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32652 G__memfunc_setup("getRecMdcKalHelixSeg",1951,G__RootEventData_rootcint_477_0_51, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32653 G__memfunc_setup("clearRecMdcKalHelixSegCol",2436,G__RootEventData_rootcint_477_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32654 G__memfunc_setup("getEvTimeCol",1192,G__RootEventData_rootcint_477_0_53, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32655 G__memfunc_setup("addEvTime",883,G__RootEventData_rootcint_477_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEvTime' - 0 - Track", (char*)NULL, (void*) NULL, 0);
32656 G__memfunc_setup("getEvTime",906,G__RootEventData_rootcint_477_0_55, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32657 G__memfunc_setup("clearEvTimeCol",1391,G__RootEventData_rootcint_477_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32658 G__memfunc_setup("getRecZddChannelCol",1875,G__RootEventData_rootcint_477_0_57, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32659 G__memfunc_setup("addRecZddChannel",1566,G__RootEventData_rootcint_477_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecZddChannel' - 0 - dtag", (char*)NULL, (void*) NULL, 0);
32660 G__memfunc_setup("getRecZddChannel",1589,G__RootEventData_rootcint_477_0_59, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32661 G__memfunc_setup("clearRecZddChannelCol",2074,G__RootEventData_rootcint_477_0_60, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32662 G__memfunc_setup("Class",502,G__RootEventData_rootcint_477_0_61, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecTrackEvent::Class) ), 0);
32663 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_477_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTrackEvent::Class_Name) ), 0);
32664 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_477_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecTrackEvent::Class_Version) ), 0);
32665 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_477_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecTrackEvent::Dictionary) ), 0);
32666 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32667 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32668 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32669 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_477_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32670 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_477_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTrackEvent::DeclFileName) ), 0);
32671 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_477_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTrackEvent::ImplFileLine) ), 0);
32672 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_477_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTrackEvent::ImplFileName) ), 0);
32673 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_477_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTrackEvent::DeclFileLine) ), 0);
32674 // automatic copy constructor
32675 G__memfunc_setup("TRecTrackEvent", 1381, G__RootEventData_rootcint_477_0_73, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 0, 1, 1, 1, 0, "u 'TRecTrackEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
32676 // automatic destructor
32677 G__memfunc_setup("~TRecTrackEvent", 1507, G__RootEventData_rootcint_477_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32678 // automatic assignment operator
32679 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_477_0_75, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 1, 1, 1, 1, 0, "u 'TRecTrackEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
32680 G__tag_memfunc_reset();
32681}
32682
32683static void G__setup_memfuncTMdcTrack(void) {
32684 /* TMdcTrack */
32685 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
32686 G__memfunc_setup("TMdcTrack",861,G__RootEventData_rootcint_478_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32687 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_478_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32688 G__memfunc_setup("helix",538,G__RootEventData_rootcint_478_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32689 G__memfunc_setup("stat",444,G__RootEventData_rootcint_478_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32690 G__memfunc_setup("chi2",358,G__RootEventData_rootcint_478_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32691 G__memfunc_setup("ndof",423,G__RootEventData_rootcint_478_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32692 G__memfunc_setup("err",329,G__RootEventData_rootcint_478_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32693 G__memfunc_setup("nster",556,G__RootEventData_rootcint_478_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32694 G__memfunc_setup("nlayer",651,G__RootEventData_rootcint_478_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32695 G__memfunc_setup("firstLayer",1061,G__RootEventData_rootcint_478_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32696 G__memfunc_setup("lastLayer",945,G__RootEventData_rootcint_478_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32697 G__memfunc_setup("x",120,G__RootEventData_rootcint_478_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32698 G__memfunc_setup("y",121,G__RootEventData_rootcint_478_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32699 G__memfunc_setup("z",122,G__RootEventData_rootcint_478_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32700 G__memfunc_setup("r",114,G__RootEventData_rootcint_478_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32701 G__memfunc_setup("charge",618,G__RootEventData_rootcint_478_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32702 G__memfunc_setup("pxy",353,G__RootEventData_rootcint_478_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32703 G__memfunc_setup("px",232,G__RootEventData_rootcint_478_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32704 G__memfunc_setup("py",233,G__RootEventData_rootcint_478_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32705 G__memfunc_setup("pz",234,G__RootEventData_rootcint_478_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32706 G__memfunc_setup("p",112,G__RootEventData_rootcint_478_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32707 G__memfunc_setup("theta",534,G__RootEventData_rootcint_478_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32708 G__memfunc_setup("phi",321,G__RootEventData_rootcint_478_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
32709 G__memfunc_setup("setHelix",838,G__RootEventData_rootcint_478_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
32710 G__memfunc_setup("setErr",629,G__RootEventData_rootcint_478_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - err", (char*)NULL, (void*) NULL, 0);
32711 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_478_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
32712 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_478_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - stat", (char*)NULL, (void*) NULL, 0);
32713 G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_478_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chi", (char*)NULL, (void*) NULL, 0);
32714 G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_478_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ndof", (char*)NULL, (void*) NULL, 0);
32715 G__memfunc_setup("setNster",856,G__RootEventData_rootcint_478_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ns", (char*)NULL, (void*) NULL, 0);
32716 G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_478_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nlayer", (char*)NULL, (void*) NULL, 0);
32717 G__memfunc_setup("setFirstLayer",1361,G__RootEventData_rootcint_478_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - fL", (char*)NULL, (void*) NULL, 0);
32718 G__memfunc_setup("setLastLayer",1245,G__RootEventData_rootcint_478_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - lL", (char*)NULL, (void*) NULL, 0);
32719 G__memfunc_setup("Class",502,G__RootEventData_rootcint_478_0_34, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcTrack::Class) ), 0);
32720 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_478_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcTrack::Class_Name) ), 0);
32721 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_478_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcTrack::Class_Version) ), 0);
32722 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_478_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcTrack::Dictionary) ), 0);
32723 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32724 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32725 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32726 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_478_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32727 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_478_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcTrack::DeclFileName) ), 0);
32728 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_478_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcTrack::ImplFileLine) ), 0);
32729 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_478_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcTrack::ImplFileName) ), 0);
32730 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_478_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcTrack::DeclFileLine) ), 0);
32731 // automatic copy constructor
32732 G__memfunc_setup("TMdcTrack", 861, G__RootEventData_rootcint_478_0_46, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 0, 1, 1, 1, 0, "u 'TMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32733 // automatic destructor
32734 G__memfunc_setup("~TMdcTrack", 987, G__RootEventData_rootcint_478_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32735 // automatic assignment operator
32736 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_478_0_48, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 1, 1, 1, 1, 0, "u 'TMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32737 G__tag_memfunc_reset();
32738}
32739
32740static void G__setup_memfuncTEmcTrack(void) {
32741 /* TEmcTrack */
32742 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
32743 G__memfunc_setup("TEmcTrack",862,G__RootEventData_rootcint_479_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32744 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_479_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32745 G__memfunc_setup("numHits",744,G__RootEventData_rootcint_479_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32746 G__memfunc_setup("status",676,G__RootEventData_rootcint_479_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32747 G__memfunc_setup("cellId",589,G__RootEventData_rootcint_479_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32748 G__memfunc_setup("module",646,G__RootEventData_rootcint_479_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32749 G__memfunc_setup("x",120,G__RootEventData_rootcint_479_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32750 G__memfunc_setup("y",121,G__RootEventData_rootcint_479_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32751 G__memfunc_setup("z",122,G__RootEventData_rootcint_479_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32752 G__memfunc_setup("theta",534,G__RootEventData_rootcint_479_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32753 G__memfunc_setup("phi",321,G__RootEventData_rootcint_479_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32754 G__memfunc_setup("dx",220,G__RootEventData_rootcint_479_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32755 G__memfunc_setup("dy",221,G__RootEventData_rootcint_479_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32756 G__memfunc_setup("dz",222,G__RootEventData_rootcint_479_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32757 G__memfunc_setup("dtheta",634,G__RootEventData_rootcint_479_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32758 G__memfunc_setup("dphi",421,G__RootEventData_rootcint_479_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32759 G__memfunc_setup("energy",650,G__RootEventData_rootcint_479_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32760 G__memfunc_setup("dE",169,G__RootEventData_rootcint_479_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32761 G__memfunc_setup("eSeed",486,G__RootEventData_rootcint_479_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32762 G__memfunc_setup("e3x3",323,G__RootEventData_rootcint_479_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32763 G__memfunc_setup("e5x5",327,G__RootEventData_rootcint_479_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32764 G__memfunc_setup("time",431,G__RootEventData_rootcint_479_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32765 G__memfunc_setup("secondMoment",1260,G__RootEventData_rootcint_479_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32766 G__memfunc_setup("latMoment",945,G__RootEventData_rootcint_479_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32767 G__memfunc_setup("a20Moment",819,G__RootEventData_rootcint_479_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32768 G__memfunc_setup("a42Moment",823,G__RootEventData_rootcint_479_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32769 G__memfunc_setup("err",329,G__RootEventData_rootcint_479_0_27, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
32770 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_479_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
32771 G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_479_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - hit", (char*)NULL, (void*) NULL, 0);
32772 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_479_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - st", (char*)NULL, (void*) NULL, 0);
32773 G__memfunc_setup("setCellId",889,G__RootEventData_rootcint_479_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
32774 G__memfunc_setup("setModule",946,G__RootEventData_rootcint_479_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - mod", (char*)NULL, (void*) NULL, 0);
32775 G__memfunc_setup("setX",420,G__RootEventData_rootcint_479_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 0);
32776 G__memfunc_setup("setY",421,G__RootEventData_rootcint_479_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
32777 G__memfunc_setup("setZ",422,G__RootEventData_rootcint_479_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - z", (char*)NULL, (void*) NULL, 0);
32778 G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_479_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e", (char*)NULL, (void*) NULL, 0);
32779 G__memfunc_setup("setDE",469,G__RootEventData_rootcint_479_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - de", (char*)NULL, (void*) NULL, 0);
32780 G__memfunc_setup("setDtheta",934,G__RootEventData_rootcint_479_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dt", (char*)NULL, (void*) NULL, 0);
32781 G__memfunc_setup("setDphi",721,G__RootEventData_rootcint_479_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dpi", (char*)NULL, (void*) NULL, 0);
32782 G__memfunc_setup("setESeed",786,G__RootEventData_rootcint_479_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - eSeed", (char*)NULL, (void*) NULL, 0);
32783 G__memfunc_setup("setE3x3",623,G__RootEventData_rootcint_479_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e3x3", (char*)NULL, (void*) NULL, 0);
32784 G__memfunc_setup("setE5x5",627,G__RootEventData_rootcint_479_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e5x5", (char*)NULL, (void*) NULL, 0);
32785 G__memfunc_setup("setTime",731,G__RootEventData_rootcint_479_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
32786 G__memfunc_setup("setSecondMoment",1560,G__RootEventData_rootcint_479_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - secondMoment", (char*)NULL, (void*) NULL, 0);
32787 G__memfunc_setup("setLatMoment",1245,G__RootEventData_rootcint_479_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - latMoment", (char*)NULL, (void*) NULL, 0);
32788 G__memfunc_setup("setA20Moment",1119,G__RootEventData_rootcint_479_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a20Moment", (char*)NULL, (void*) NULL, 0);
32789 G__memfunc_setup("setA42Moment",1123,G__RootEventData_rootcint_479_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a42Moment", (char*)NULL, (void*) NULL, 0);
32790 G__memfunc_setup("setErr",629,G__RootEventData_rootcint_479_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - err", (char*)NULL, (void*) NULL, 0);
32791 G__memfunc_setup("Class",502,G__RootEventData_rootcint_479_0_49, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEmcTrack::Class) ), 0);
32792 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_479_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcTrack::Class_Name) ), 0);
32793 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_479_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEmcTrack::Class_Version) ), 0);
32794 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_479_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEmcTrack::Dictionary) ), 0);
32795 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32796 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32797 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32798 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_479_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32799 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_479_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcTrack::DeclFileName) ), 0);
32800 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_479_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcTrack::ImplFileLine) ), 0);
32801 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_479_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcTrack::ImplFileName) ), 0);
32802 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_479_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcTrack::DeclFileLine) ), 0);
32803 // automatic copy constructor
32804 G__memfunc_setup("TEmcTrack", 862, G__RootEventData_rootcint_479_0_61, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 0, 1, 1, 1, 0, "u 'TEmcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32805 // automatic destructor
32806 G__memfunc_setup("~TEmcTrack", 988, G__RootEventData_rootcint_479_0_62, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32807 // automatic assignment operator
32808 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_479_0_63, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 1, 1, 1, 1, 0, "u 'TEmcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32809 G__tag_memfunc_reset();
32810}
32811
32812static void G__setup_memfuncTMucTrack(void) {
32813 /* TMucTrack */
32814 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
32815 G__memfunc_setup("TMucTrack",878,G__RootEventData_rootcint_480_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32816 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_480_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32817 G__memfunc_setup("id",205,G__RootEventData_rootcint_480_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32818 G__memfunc_setup("status",676,G__RootEventData_rootcint_480_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32819 G__memfunc_setup("type",450,G__RootEventData_rootcint_480_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32820 G__memfunc_setup("startPart",965,G__RootEventData_rootcint_480_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "start position of track locates in which part", (void*) NULL, 0);
32821 G__memfunc_setup("endPart",718,G__RootEventData_rootcint_480_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "end position of track locates in which part", (void*) NULL, 0);
32822 G__memfunc_setup("brLastLayer",1125,G__RootEventData_rootcint_480_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in barrel ", (void*) NULL, 0);
32823 G__memfunc_setup("ecLastLayer",1113,G__RootEventData_rootcint_480_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in end cap", (void*) NULL, 0);
32824 G__memfunc_setup("numHits",744,G__RootEventData_rootcint_480_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "total hits on the track ", (void*) NULL, 0);
32825 G__memfunc_setup("numLayers",960,G__RootEventData_rootcint_480_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "number of layers with hits ", (void*) NULL, 0);
32826 G__memfunc_setup("maxHitsInLayer",1426,G__RootEventData_rootcint_480_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32827 G__memfunc_setup("depth",533,G__RootEventData_rootcint_480_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "depth of the track transport in iron", (void*) NULL, 0);
32828 G__memfunc_setup("chi2",358,G__RootEventData_rootcint_480_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32829 G__memfunc_setup("dof",313,G__RootEventData_rootcint_480_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32830 G__memfunc_setup("rms",338,G__RootEventData_rootcint_480_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32831 G__memfunc_setup("xPos",426,G__RootEventData_rootcint_480_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "position on the start of track in muc (vertex) ", (void*) NULL, 0);
32832 G__memfunc_setup("yPos",427,G__RootEventData_rootcint_480_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32833 G__memfunc_setup("zPos",428,G__RootEventData_rootcint_480_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32834 G__memfunc_setup("xPosSigma",923,G__RootEventData_rootcint_480_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32835 G__memfunc_setup("yPosSigma",924,G__RootEventData_rootcint_480_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32836 G__memfunc_setup("zPosSigma",925,G__RootEventData_rootcint_480_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32837 G__memfunc_setup("px",232,G__RootEventData_rootcint_480_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "momentum on the start of track in muc", (void*) NULL, 0);
32838 G__memfunc_setup("py",233,G__RootEventData_rootcint_480_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32839 G__memfunc_setup("pz",234,G__RootEventData_rootcint_480_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32840 G__memfunc_setup("distance",843,G__RootEventData_rootcint_480_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32841 G__memfunc_setup("deltaPhi",811,G__RootEventData_rootcint_480_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32842 G__memfunc_setup("kalRechi2",853,G__RootEventData_rootcint_480_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32843 G__memfunc_setup("kaldof",625,G__RootEventData_rootcint_480_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32844 G__memfunc_setup("kaldepth",845,G__RootEventData_rootcint_480_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32845 G__memfunc_setup("kalbrLastLayer",1437,G__RootEventData_rootcint_480_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32846 G__memfunc_setup("kalecLastLayer",1425,G__RootEventData_rootcint_480_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32847 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_480_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackId", (char*)NULL, (void*) NULL, 0);
32848 G__memfunc_setup("setId",505,G__RootEventData_rootcint_480_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
32849 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_480_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
32850 G__memfunc_setup("setType",750,G__RootEventData_rootcint_480_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
32851 G__memfunc_setup("setStartPart",1265,G__RootEventData_rootcint_480_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
32852 G__memfunc_setup("setEndPart",1018,G__RootEventData_rootcint_480_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
32853 G__memfunc_setup("setBrLastLayer",1425,G__RootEventData_rootcint_480_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
32854 G__memfunc_setup("setEcLastLayer",1413,G__RootEventData_rootcint_480_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
32855 G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_480_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numHits", (char*)NULL, (void*) NULL, 0);
32856 G__memfunc_setup("setNumLayers",1260,G__RootEventData_rootcint_480_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numLayers", (char*)NULL, (void*) NULL, 0);
32857 G__memfunc_setup("setMaxHitsInLayer",1726,G__RootEventData_rootcint_480_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxHits", (char*)NULL, (void*) NULL, 0);
32858 G__memfunc_setup("setDepth",833,G__RootEventData_rootcint_480_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
32859 G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_480_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
32860 G__memfunc_setup("setDof",613,G__RootEventData_rootcint_480_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dof", (char*)NULL, (void*) NULL, 0);
32861 G__memfunc_setup("setRms",638,G__RootEventData_rootcint_480_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rms", (char*)NULL, (void*) NULL, 0);
32862 G__memfunc_setup("setXPos",726,G__RootEventData_rootcint_480_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
32863 G__memfunc_setup("setYPos",727,G__RootEventData_rootcint_480_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
32864 G__memfunc_setup("setZPos",728,G__RootEventData_rootcint_480_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
32865 G__memfunc_setup("setXPosSigma",1223,G__RootEventData_rootcint_480_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
32866 G__memfunc_setup("setYPosSigma",1224,G__RootEventData_rootcint_480_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
32867 G__memfunc_setup("setZPosSigma",1225,G__RootEventData_rootcint_480_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
32868 G__memfunc_setup("setPx",532,G__RootEventData_rootcint_480_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
32869 G__memfunc_setup("setPy",533,G__RootEventData_rootcint_480_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
32870 G__memfunc_setup("setPz",534,G__RootEventData_rootcint_480_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
32871 G__memfunc_setup("setDistance",1143,G__RootEventData_rootcint_480_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - dist", (char*)NULL, (void*) NULL, 0);
32872 G__memfunc_setup("setDeltaPhi",1111,G__RootEventData_rootcint_480_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - dphi", (char*)NULL, (void*) NULL, 0);
32873 G__memfunc_setup("setkalRechi2",1185,G__RootEventData_rootcint_480_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ch", (char*)NULL, (void*) NULL, 0);
32874 G__memfunc_setup("setkalDof",925,G__RootEventData_rootcint_480_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - f", (char*)NULL, (void*) NULL, 0);
32875 G__memfunc_setup("setkalDepth",1145,G__RootEventData_rootcint_480_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
32876 G__memfunc_setup("setkalbrLastLayer",1769,G__RootEventData_rootcint_480_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - br", (char*)NULL, (void*) NULL, 0);
32877 G__memfunc_setup("setkalecLastLayer",1757,G__RootEventData_rootcint_480_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ec", (char*)NULL, (void*) NULL, 0);
32878 G__memfunc_setup("Class",502,G__RootEventData_rootcint_480_0_64, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMucTrack::Class) ), 0);
32879 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_480_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucTrack::Class_Name) ), 0);
32880 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_480_0_66, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMucTrack::Class_Version) ), 0);
32881 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_480_0_67, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMucTrack::Dictionary) ), 0);
32882 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32883 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32884 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32885 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_480_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32886 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_480_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucTrack::DeclFileName) ), 0);
32887 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_480_0_73, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucTrack::ImplFileLine) ), 0);
32888 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_480_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucTrack::ImplFileName) ), 0);
32889 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_480_0_75, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucTrack::DeclFileLine) ), 0);
32890 // automatic copy constructor
32891 G__memfunc_setup("TMucTrack", 878, G__RootEventData_rootcint_480_0_76, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 0, 1, 1, 1, 0, "u 'TMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32892 // automatic destructor
32893 G__memfunc_setup("~TMucTrack", 1004, G__RootEventData_rootcint_480_0_77, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32894 // automatic assignment operator
32895 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_480_0_78, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 1, 1, 1, 1, 0, "u 'TMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
32896 G__tag_memfunc_reset();
32897}
32898
32899static void G__setup_memfuncTMdcDedx(void) {
32900 /* TMdcDedx */
32901 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
32902 G__memfunc_setup("TMdcDedx",749,G__RootEventData_rootcint_481_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32903 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_481_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32904 G__memfunc_setup("particleId",1025,G__RootEventData_rootcint_481_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32905 G__memfunc_setup("status",676,G__RootEventData_rootcint_481_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32906 G__memfunc_setup("truncAlg",832,G__RootEventData_rootcint_481_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32907 G__memfunc_setup("chi",308,G__RootEventData_rootcint_481_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
32908 G__memfunc_setup("chiE",377,G__RootEventData_rootcint_481_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32909 G__memfunc_setup("chiMu",502,G__RootEventData_rootcint_481_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32910 G__memfunc_setup("chiPi",493,G__RootEventData_rootcint_481_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32911 G__memfunc_setup("chiK",383,G__RootEventData_rootcint_481_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32912 G__memfunc_setup("chiP",388,G__RootEventData_rootcint_481_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32913 G__memfunc_setup("numGoodHits",1137,G__RootEventData_rootcint_481_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32914 G__memfunc_setup("numTotalHits",1260,G__RootEventData_rootcint_481_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32915 G__memfunc_setup("probPH",587,G__RootEventData_rootcint_481_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32916 G__memfunc_setup("normPH",596,G__RootEventData_rootcint_481_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32917 G__memfunc_setup("errorPH",706,G__RootEventData_rootcint_481_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32918 G__memfunc_setup("twentyPH",835,G__RootEventData_rootcint_481_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
32919 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_481_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
32920 G__memfunc_setup("setParticleId",1325,G__RootEventData_rootcint_481_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - particleId", (char*)NULL, (void*) NULL, 0);
32921 G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_481_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - status", (char*)NULL, (void*) NULL, 0);
32922 G__memfunc_setup("setTruncAlg",1132,G__RootEventData_rootcint_481_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trunc_alg", (char*)NULL, (void*) NULL, 0);
32923 G__memfunc_setup("setChiE",677,G__RootEventData_rootcint_481_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiE", (char*)NULL, (void*) NULL, 0);
32924 G__memfunc_setup("setChiMu",802,G__RootEventData_rootcint_481_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiMu", (char*)NULL, (void*) NULL, 0);
32925 G__memfunc_setup("setChiPi",793,G__RootEventData_rootcint_481_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiPi", (char*)NULL, (void*) NULL, 0);
32926 G__memfunc_setup("setChiK",683,G__RootEventData_rootcint_481_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiK", (char*)NULL, (void*) NULL, 0);
32927 G__memfunc_setup("setChiP",688,G__RootEventData_rootcint_481_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiP", (char*)NULL, (void*) NULL, 0);
32928 G__memfunc_setup("setNumGoodHits",1437,G__RootEventData_rootcint_481_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numGoodHits", (char*)NULL, (void*) NULL, 0);
32929 G__memfunc_setup("setNumTotalHits",1560,G__RootEventData_rootcint_481_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numTotalHits", (char*)NULL, (void*) NULL, 0);
32930 G__memfunc_setup("setProbPH",887,G__RootEventData_rootcint_481_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - probPH", (char*)NULL, (void*) NULL, 0);
32931 G__memfunc_setup("setNormPH",896,G__RootEventData_rootcint_481_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - normPH", (char*)NULL, (void*) NULL, 0);
32932 G__memfunc_setup("setErrorPH",1006,G__RootEventData_rootcint_481_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - errorPH", (char*)NULL, (void*) NULL, 0);
32933 G__memfunc_setup("setTwentyPH",1135,G__RootEventData_rootcint_481_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - twentyPH", (char*)NULL, (void*) NULL, 0);
32934 G__memfunc_setup("Class",502,G__RootEventData_rootcint_481_0_33, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcDedx::Class) ), 0);
32935 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_481_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDedx::Class_Name) ), 0);
32936 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_481_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcDedx::Class_Version) ), 0);
32937 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_481_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcDedx::Dictionary) ), 0);
32938 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
32939 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
32940 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
32941 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_481_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
32942 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_481_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDedx::DeclFileName) ), 0);
32943 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_481_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDedx::ImplFileLine) ), 0);
32944 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_481_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDedx::ImplFileName) ), 0);
32945 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_481_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDedx::DeclFileLine) ), 0);
32946 // automatic copy constructor
32947 G__memfunc_setup("TMdcDedx", 749, G__RootEventData_rootcint_481_0_45, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 0, 1, 1, 1, 0, "u 'TMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
32948 // automatic destructor
32949 G__memfunc_setup("~TMdcDedx", 875, G__RootEventData_rootcint_481_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
32950 // automatic assignment operator
32951 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_481_0_47, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 1, 1, 1, 1, 0, "u 'TMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
32952 G__tag_memfunc_reset();
32953}
32954
32955static void G__setup_memfuncTExtTrack(void) {
32956 /* TExtTrack */
32957 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
32958 G__memfunc_setup("TExtTrack",890,G__RootEventData_rootcint_483_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
32959 G__memfunc_setup("SetTrackId",974,G__RootEventData_rootcint_483_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
32960 G__memfunc_setup("SetTof1PositionX",1587,G__RootEventData_rootcint_483_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PositionX", (char*)NULL, (void*) NULL, 0);
32961 G__memfunc_setup("SetTof1PositionY",1588,G__RootEventData_rootcint_483_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PositionY", (char*)NULL, (void*) NULL, 0);
32962 G__memfunc_setup("SetTof1PositionZ",1589,G__RootEventData_rootcint_483_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PositionZ", (char*)NULL, (void*) NULL, 0);
32963 G__memfunc_setup("SetTof1MomentumX",1584,G__RootEventData_rootcint_483_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1MomentumX", (char*)NULL, (void*) NULL, 0);
32964 G__memfunc_setup("SetTof1MomentumY",1585,G__RootEventData_rootcint_483_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1MomentumY", (char*)NULL, (void*) NULL, 0);
32965 G__memfunc_setup("SetTof1MomentumZ",1586,G__RootEventData_rootcint_483_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1MomentumZ", (char*)NULL, (void*) NULL, 0);
32966 G__memfunc_setup("SetTof1VolumeName",1663,G__RootEventData_rootcint_483_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - Tof1VolumeName", (char*)NULL, (void*) NULL, 0);
32967 G__memfunc_setup("SetTof1VolumeNumber",1895,G__RootEventData_rootcint_483_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - Tof1VolumeNumber", (char*)NULL, (void*) NULL, 0);
32968 G__memfunc_setup("SetTof1",646,G__RootEventData_rootcint_483_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1", (char*)NULL, (void*) NULL, 0);
32969 G__memfunc_setup("SetTof1Path",1043,G__RootEventData_rootcint_483_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1Path", (char*)NULL, (void*) NULL, 0);
32970 G__memfunc_setup("SetTof1PosSigmaAlongZ",2036,G__RootEventData_rootcint_483_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongZ", (char*)NULL, (void*) NULL, 0);
32971 G__memfunc_setup("SetTof1PosSigmaAlongT",2030,G__RootEventData_rootcint_483_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongT", (char*)NULL, (void*) NULL, 0);
32972 G__memfunc_setup("SetTof1PosSigmaAlongX",2034,G__RootEventData_rootcint_483_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongX", (char*)NULL, (void*) NULL, 0);
32973 G__memfunc_setup("SetTof1PosSigmaAlongY",2035,G__RootEventData_rootcint_483_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongY", (char*)NULL, (void*) NULL, 0);
32974 G__memfunc_setup("SetTof1ErrorMatrix",1797,G__RootEventData_rootcint_483_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - Tof1ErrorMatrix", (char*)NULL, (void*) NULL, 0);
32975 G__memfunc_setup("SetTof2PositionX",1588,G__RootEventData_rootcint_483_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PositionX", (char*)NULL, (void*) NULL, 0);
32976 G__memfunc_setup("SetTof2PositionY",1589,G__RootEventData_rootcint_483_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PositionY", (char*)NULL, (void*) NULL, 0);
32977 G__memfunc_setup("SetTof2PositionZ",1590,G__RootEventData_rootcint_483_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PositionZ", (char*)NULL, (void*) NULL, 0);
32978 G__memfunc_setup("SetTof2MomentumX",1585,G__RootEventData_rootcint_483_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2MomentumX", (char*)NULL, (void*) NULL, 0);
32979 G__memfunc_setup("SetTof2MomentumY",1586,G__RootEventData_rootcint_483_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2MomentumY", (char*)NULL, (void*) NULL, 0);
32980 G__memfunc_setup("SetTof2MomentumZ",1587,G__RootEventData_rootcint_483_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2MomentumZ", (char*)NULL, (void*) NULL, 0);
32981 G__memfunc_setup("SetTof2VolumeName",1664,G__RootEventData_rootcint_483_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - Tof2VolumeName", (char*)NULL, (void*) NULL, 0);
32982 G__memfunc_setup("SetTof2VolumeNumber",1896,G__RootEventData_rootcint_483_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - Tof2VolumeNumber", (char*)NULL, (void*) NULL, 0);
32983 G__memfunc_setup("SetTof2",647,G__RootEventData_rootcint_483_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2", (char*)NULL, (void*) NULL, 0);
32984 G__memfunc_setup("SetTof2Path",1044,G__RootEventData_rootcint_483_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2Path", (char*)NULL, (void*) NULL, 0);
32985 G__memfunc_setup("SetTof2PosSigmaAlongZ",2037,G__RootEventData_rootcint_483_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongZ", (char*)NULL, (void*) NULL, 0);
32986 G__memfunc_setup("SetTof2PosSigmaAlongT",2031,G__RootEventData_rootcint_483_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongT", (char*)NULL, (void*) NULL, 0);
32987 G__memfunc_setup("SetTof2PosSigmaAlongX",2035,G__RootEventData_rootcint_483_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongX", (char*)NULL, (void*) NULL, 0);
32988 G__memfunc_setup("SetTof2PosSigmaAlongY",2036,G__RootEventData_rootcint_483_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongY", (char*)NULL, (void*) NULL, 0);
32989 G__memfunc_setup("SetTof2ErrorMatrix",1798,G__RootEventData_rootcint_483_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - Tof2ErrorMatrix", (char*)NULL, (void*) NULL, 0);
32990 G__memfunc_setup("SetEmcPositionX",1518,G__RootEventData_rootcint_483_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPositionX", (char*)NULL, (void*) NULL, 0);
32991 G__memfunc_setup("SetEmcPositionY",1519,G__RootEventData_rootcint_483_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPositionY", (char*)NULL, (void*) NULL, 0);
32992 G__memfunc_setup("SetEmcPositionZ",1520,G__RootEventData_rootcint_483_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPositionZ", (char*)NULL, (void*) NULL, 0);
32993 G__memfunc_setup("SetEmcMomentumX",1515,G__RootEventData_rootcint_483_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcMomentumX", (char*)NULL, (void*) NULL, 0);
32994 G__memfunc_setup("SetEmcMomentumY",1516,G__RootEventData_rootcint_483_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcMomentumY", (char*)NULL, (void*) NULL, 0);
32995 G__memfunc_setup("SetEmcMomentumZ",1517,G__RootEventData_rootcint_483_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcMomentumZ", (char*)NULL, (void*) NULL, 0);
32996 G__memfunc_setup("SetEmcVolumeName",1594,G__RootEventData_rootcint_483_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - EmcVolumeName", (char*)NULL, (void*) NULL, 0);
32997 G__memfunc_setup("SetEmcVolumeNumber",1826,G__RootEventData_rootcint_483_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - EmcVolumeNumber", (char*)NULL, (void*) NULL, 0);
32998 G__memfunc_setup("SetEmcPosSigmaAlongTheta",2379,G__RootEventData_rootcint_483_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPosSigmaAlongTheta", (char*)NULL, (void*) NULL, 0);
32999 G__memfunc_setup("SetEmcPosSigmaAlongPhi",2166,G__RootEventData_rootcint_483_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPosSigmaAlongPhi", (char*)NULL, (void*) NULL, 0);
33000 G__memfunc_setup("SetEmcErrorMatrix",1728,G__RootEventData_rootcint_483_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - EmcErrorMatrix", (char*)NULL, (void*) NULL, 0);
33001 G__memfunc_setup("SetEmcPath",974,G__RootEventData_rootcint_483_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - path", (char*)NULL, (void*) NULL, 0);
33002 G__memfunc_setup("SetMucPositionX",1534,G__RootEventData_rootcint_483_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPositionX", (char*)NULL, (void*) NULL, 0);
33003 G__memfunc_setup("SetMucPositionY",1535,G__RootEventData_rootcint_483_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPositionY", (char*)NULL, (void*) NULL, 0);
33004 G__memfunc_setup("SetMucPositionZ",1536,G__RootEventData_rootcint_483_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPositionZ", (char*)NULL, (void*) NULL, 0);
33005 G__memfunc_setup("SetMucMomentumX",1531,G__RootEventData_rootcint_483_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucMomentumX", (char*)NULL, (void*) NULL, 0);
33006 G__memfunc_setup("SetMucMomentumY",1532,G__RootEventData_rootcint_483_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucMomentumY", (char*)NULL, (void*) NULL, 0);
33007 G__memfunc_setup("SetMucMomentumZ",1533,G__RootEventData_rootcint_483_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucMomentumZ", (char*)NULL, (void*) NULL, 0);
33008 G__memfunc_setup("SetMucVolumeName",1610,G__RootEventData_rootcint_483_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - MucVolumeName", (char*)NULL, (void*) NULL, 0);
33009 G__memfunc_setup("SetMucVolumeNumber",1842,G__RootEventData_rootcint_483_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - MucVolumeNumber", (char*)NULL, (void*) NULL, 0);
33010 G__memfunc_setup("SetMucPosSigmaAlongZ",1983,G__RootEventData_rootcint_483_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongZ", (char*)NULL, (void*) NULL, 0);
33011 G__memfunc_setup("SetMucPosSigmaAlongT",1977,G__RootEventData_rootcint_483_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongT", (char*)NULL, (void*) NULL, 0);
33012 G__memfunc_setup("SetMucPosSigmaAlongX",1981,G__RootEventData_rootcint_483_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongX", (char*)NULL, (void*) NULL, 0);
33013 G__memfunc_setup("SetMucPosSigmaAlongY",1982,G__RootEventData_rootcint_483_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongY", (char*)NULL, (void*) NULL, 0);
33014 G__memfunc_setup("SetMucErrorMatrix",1744,G__RootEventData_rootcint_483_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - MucErrorMatrix", (char*)NULL, (void*) NULL, 0);
33015 G__memfunc_setup("GetTrackId",962,G__RootEventData_rootcint_483_0_58, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33016 G__memfunc_setup("GetTof1PositionX",1575,G__RootEventData_rootcint_483_0_59, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33017 G__memfunc_setup("GetTof1PositionY",1576,G__RootEventData_rootcint_483_0_60, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33018 G__memfunc_setup("GetTof1PositionZ",1577,G__RootEventData_rootcint_483_0_61, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33019 G__memfunc_setup("GetTof1MomentumX",1572,G__RootEventData_rootcint_483_0_62, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33020 G__memfunc_setup("GetTof1MomentumY",1573,G__RootEventData_rootcint_483_0_63, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33021 G__memfunc_setup("GetTof1MomentumZ",1574,G__RootEventData_rootcint_483_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33022 G__memfunc_setup("GetTof1VolumeName",1651,G__RootEventData_rootcint_483_0_65, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33023 G__memfunc_setup("GetTof1VolumeNumber",1883,G__RootEventData_rootcint_483_0_66, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33024 G__memfunc_setup("GetTof1",634,G__RootEventData_rootcint_483_0_67, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33025 G__memfunc_setup("GetTof1Path",1031,G__RootEventData_rootcint_483_0_68, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33026 G__memfunc_setup("GetTof1PosSigmaAlongZ",2024,G__RootEventData_rootcint_483_0_69, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33027 G__memfunc_setup("GetTof1PosSigmaAlongT",2018,G__RootEventData_rootcint_483_0_70, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33028 G__memfunc_setup("GetTof1PosSigmaAlongX",2022,G__RootEventData_rootcint_483_0_71, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33029 G__memfunc_setup("GetTof1PosSigmaAlongY",2023,G__RootEventData_rootcint_483_0_72, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33030 G__memfunc_setup("GetTof1ErrorMatrix",1785,G__RootEventData_rootcint_483_0_73, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33031"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33032 G__memfunc_setup("GetTof2PositionX",1576,G__RootEventData_rootcint_483_0_74, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33033 G__memfunc_setup("GetTof2PositionY",1577,G__RootEventData_rootcint_483_0_75, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33034 G__memfunc_setup("GetTof2PositionZ",1578,G__RootEventData_rootcint_483_0_76, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33035 G__memfunc_setup("GetTof2MomentumX",1573,G__RootEventData_rootcint_483_0_77, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33036 G__memfunc_setup("GetTof2MomentumY",1574,G__RootEventData_rootcint_483_0_78, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33037 G__memfunc_setup("GetTof2MomentumZ",1575,G__RootEventData_rootcint_483_0_79, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33038 G__memfunc_setup("GetTof2VolumeName",1652,G__RootEventData_rootcint_483_0_80, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33039 G__memfunc_setup("GetTof2VolumeNumber",1884,G__RootEventData_rootcint_483_0_81, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33040 G__memfunc_setup("GetTof2",635,G__RootEventData_rootcint_483_0_82, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33041 G__memfunc_setup("GetTof2Path",1032,G__RootEventData_rootcint_483_0_83, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33042 G__memfunc_setup("GetTof2PosSigmaAlongZ",2025,G__RootEventData_rootcint_483_0_84, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33043 G__memfunc_setup("GetTof2PosSigmaAlongT",2019,G__RootEventData_rootcint_483_0_85, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33044 G__memfunc_setup("GetTof2PosSigmaAlongX",2023,G__RootEventData_rootcint_483_0_86, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33045 G__memfunc_setup("GetTof2PosSigmaAlongY",2024,G__RootEventData_rootcint_483_0_87, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33046 G__memfunc_setup("GetTof2ErrorMatrix",1786,G__RootEventData_rootcint_483_0_88, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33047"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33048 G__memfunc_setup("GetEmcPositionX",1506,G__RootEventData_rootcint_483_0_89, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33049 G__memfunc_setup("GetEmcPositionY",1507,G__RootEventData_rootcint_483_0_90, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33050 G__memfunc_setup("GetEmcPositionZ",1508,G__RootEventData_rootcint_483_0_91, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33051 G__memfunc_setup("GetEmcMomentumX",1503,G__RootEventData_rootcint_483_0_92, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33052 G__memfunc_setup("GetEmcMomentumY",1504,G__RootEventData_rootcint_483_0_93, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33053 G__memfunc_setup("GetEmcMomentumZ",1505,G__RootEventData_rootcint_483_0_94, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33054 G__memfunc_setup("GetEmcVolumeName",1582,G__RootEventData_rootcint_483_0_95, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33055 G__memfunc_setup("GetEmcVolumeNumber",1814,G__RootEventData_rootcint_483_0_96, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33056 G__memfunc_setup("GetEmcPosSigmaAlongTheta",2367,G__RootEventData_rootcint_483_0_97, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33057 G__memfunc_setup("GetEmcPosSigmaAlongPhi",2154,G__RootEventData_rootcint_483_0_98, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33058 G__memfunc_setup("GetEmcErrorMatrix",1716,G__RootEventData_rootcint_483_0_99, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33059"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33060 G__memfunc_setup("emcPath",706,G__RootEventData_rootcint_483_0_100, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33061 G__memfunc_setup("GetMucPositionX",1522,G__RootEventData_rootcint_483_0_101, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33062 G__memfunc_setup("GetMucPositionY",1523,G__RootEventData_rootcint_483_0_102, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33063 G__memfunc_setup("GetMucPositionZ",1524,G__RootEventData_rootcint_483_0_103, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33064 G__memfunc_setup("GetMucMomentumX",1519,G__RootEventData_rootcint_483_0_104, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33065 G__memfunc_setup("GetMucMomentumY",1520,G__RootEventData_rootcint_483_0_105, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33066 G__memfunc_setup("GetMucMomentumZ",1521,G__RootEventData_rootcint_483_0_106, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33067 G__memfunc_setup("GetMucVolumeName",1598,G__RootEventData_rootcint_483_0_107, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33068 G__memfunc_setup("GetMucVolumeNumber",1830,G__RootEventData_rootcint_483_0_108, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33069 G__memfunc_setup("GetMucPosSigmaAlongZ",1971,G__RootEventData_rootcint_483_0_109, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33070 G__memfunc_setup("GetMucPosSigmaAlongT",1965,G__RootEventData_rootcint_483_0_110, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33071 G__memfunc_setup("GetMucPosSigmaAlongX",1969,G__RootEventData_rootcint_483_0_111, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33072 G__memfunc_setup("GetMucPosSigmaAlongY",1970,G__RootEventData_rootcint_483_0_112, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33073 G__memfunc_setup("GetMucErrorMatrix",1732,G__RootEventData_rootcint_483_0_113, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33074"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33075 G__memfunc_setup("Class",502,G__RootEventData_rootcint_483_0_114, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TExtTrack::Class) ), 0);
33076 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_483_0_115, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExtTrack::Class_Name) ), 0);
33077 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_483_0_116, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TExtTrack::Class_Version) ), 0);
33078 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_483_0_117, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TExtTrack::Dictionary) ), 0);
33079 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33080 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33081 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33082 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_483_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33083 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_483_0_122, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExtTrack::DeclFileName) ), 0);
33084 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_483_0_123, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExtTrack::ImplFileLine) ), 0);
33085 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_483_0_124, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExtTrack::ImplFileName) ), 0);
33086 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_483_0_125, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExtTrack::DeclFileLine) ), 0);
33087 // automatic copy constructor
33088 G__memfunc_setup("TExtTrack", 890, G__RootEventData_rootcint_483_0_126, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 0, 1, 1, 1, 0, "u 'TExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33089 // automatic destructor
33090 G__memfunc_setup("~TExtTrack", 1016, G__RootEventData_rootcint_483_0_127, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33091 // automatic assignment operator
33092 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_483_0_128, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 1, 1, 1, 1, 0, "u 'TExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33093 G__tag_memfunc_reset();
33094}
33095
33096static void G__setup_memfuncTMdcKalTrack(void) {
33097 /* TMdcKalTrack */
33098 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
33099 G__memfunc_setup("TMdcKalTrack",1141,G__RootEventData_rootcint_484_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33100 G__memfunc_setup("getTrackId",994,G__RootEventData_rootcint_484_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33101 G__memfunc_setup("getStat",732,G__RootEventData_rootcint_484_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33102 G__memfunc_setup("getStat2",782,G__RootEventData_rootcint_484_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33103 G__memfunc_setup("getChisq",824,G__RootEventData_rootcint_484_0_5, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33104 G__memfunc_setup("getNdf",600,G__RootEventData_rootcint_484_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33105 G__memfunc_setup("getNlayer",939,G__RootEventData_rootcint_484_0_7, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33106 G__memfunc_setup("getZHelix",916,G__RootEventData_rootcint_484_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33107 G__memfunc_setup("getZError",932,G__RootEventData_rootcint_484_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33108"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33109 G__memfunc_setup("getZHelixE",985,G__RootEventData_rootcint_484_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33110 G__memfunc_setup("getZErrorE",1001,G__RootEventData_rootcint_484_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33111"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33112 G__memfunc_setup("getZHelixMu",1110,G__RootEventData_rootcint_484_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33113 G__memfunc_setup("getZErrorMu",1126,G__RootEventData_rootcint_484_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33114"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33115 G__memfunc_setup("getZHelixK",991,G__RootEventData_rootcint_484_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33116 G__memfunc_setup("getZErrorK",1007,G__RootEventData_rootcint_484_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33117"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33118 G__memfunc_setup("getZHelixP",996,G__RootEventData_rootcint_484_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33119 G__memfunc_setup("getZErrorP",1012,G__RootEventData_rootcint_484_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33120"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33121 G__memfunc_setup("getFHelix",896,G__RootEventData_rootcint_484_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33122 G__memfunc_setup("getFError",912,G__RootEventData_rootcint_484_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33123"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33124 G__memfunc_setup("getFHelixE",965,G__RootEventData_rootcint_484_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33125 G__memfunc_setup("getFErrorE",981,G__RootEventData_rootcint_484_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33126"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33127 G__memfunc_setup("getFHelixMu",1090,G__RootEventData_rootcint_484_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33128 G__memfunc_setup("getFErrorMu",1106,G__RootEventData_rootcint_484_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33129"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33130 G__memfunc_setup("getFHelixK",971,G__RootEventData_rootcint_484_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33131 G__memfunc_setup("getFErrorK",987,G__RootEventData_rootcint_484_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33132"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33133 G__memfunc_setup("getFHelixP",976,G__RootEventData_rootcint_484_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33134 G__memfunc_setup("getFErrorP",992,G__RootEventData_rootcint_484_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8,
33135"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
33136 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_484_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
33137 G__memfunc_setup("setStat",744,G__RootEventData_rootcint_484_0_29, 121, -1, -1, 0, 2, 1, 1, 0,
33138"i - 'Int_t' 10 - stat i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33139 G__memfunc_setup("setStat2",794,G__RootEventData_rootcint_484_0_30, 121, -1, -1, 0, 2, 1, 1, 0,
33140"i - 'Int_t' 10 - stat i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33141 G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_484_0_31, 121, -1, -1, 0, 2, 1, 1, 0,
33142"d - 'Double_t' 10 - chisq i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33143 G__memfunc_setup("setNdf",612,G__RootEventData_rootcint_484_0_32, 121, -1, -1, 0, 2, 1, 1, 0,
33144"i - 'Int_t' 10 - ndf i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33145 G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_484_0_33, 121, -1, -1, 0, 2, 1, 1, 0,
33146"i - 'Int_t' 10 - nlayer i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
33147 G__memfunc_setup("setZHelix",928,G__RootEventData_rootcint_484_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix", (char*)NULL, (void*) NULL, 0);
33148 G__memfunc_setup("setZError",944,G__RootEventData_rootcint_484_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror", (char*)NULL, (void*) NULL, 0);
33149 G__memfunc_setup("setZHelixE",997,G__RootEventData_rootcint_484_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_e", (char*)NULL, (void*) NULL, 0);
33150 G__memfunc_setup("setZErrorE",1013,G__RootEventData_rootcint_484_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_e", (char*)NULL, (void*) NULL, 0);
33151 G__memfunc_setup("setZHelixMu",1122,G__RootEventData_rootcint_484_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_mu", (char*)NULL, (void*) NULL, 0);
33152 G__memfunc_setup("setZErrorMu",1138,G__RootEventData_rootcint_484_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_mu", (char*)NULL, (void*) NULL, 0);
33153 G__memfunc_setup("setZHelixK",1003,G__RootEventData_rootcint_484_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_k", (char*)NULL, (void*) NULL, 0);
33154 G__memfunc_setup("setZErrorK",1019,G__RootEventData_rootcint_484_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_k", (char*)NULL, (void*) NULL, 0);
33155 G__memfunc_setup("setZHelixP",1008,G__RootEventData_rootcint_484_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_p", (char*)NULL, (void*) NULL, 0);
33156 G__memfunc_setup("setZErrorP",1024,G__RootEventData_rootcint_484_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_p", (char*)NULL, (void*) NULL, 0);
33157 G__memfunc_setup("setFHelix",908,G__RootEventData_rootcint_484_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix", (char*)NULL, (void*) NULL, 0);
33158 G__memfunc_setup("setFError",924,G__RootEventData_rootcint_484_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror", (char*)NULL, (void*) NULL, 0);
33159 G__memfunc_setup("setFHelixE",977,G__RootEventData_rootcint_484_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_e", (char*)NULL, (void*) NULL, 0);
33160 G__memfunc_setup("setFErrorE",993,G__RootEventData_rootcint_484_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_e", (char*)NULL, (void*) NULL, 0);
33161 G__memfunc_setup("setFHelixMu",1102,G__RootEventData_rootcint_484_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_mu", (char*)NULL, (void*) NULL, 0);
33162 G__memfunc_setup("setFErrorMu",1118,G__RootEventData_rootcint_484_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_mu", (char*)NULL, (void*) NULL, 0);
33163 G__memfunc_setup("setFHelixK",983,G__RootEventData_rootcint_484_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_k", (char*)NULL, (void*) NULL, 0);
33164 G__memfunc_setup("setFErrorK",999,G__RootEventData_rootcint_484_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_k", (char*)NULL, (void*) NULL, 0);
33165 G__memfunc_setup("setFHelixP",988,G__RootEventData_rootcint_484_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_p", (char*)NULL, (void*) NULL, 0);
33166 G__memfunc_setup("setFErrorP",1004,G__RootEventData_rootcint_484_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_p", (char*)NULL, (void*) NULL, 0);
33167 G__memfunc_setup("Class",502,G__RootEventData_rootcint_484_0_54, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcKalTrack::Class) ), 0);
33168 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_484_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcKalTrack::Class_Name) ), 0);
33169 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_484_0_56, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcKalTrack::Class_Version) ), 0);
33170 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_484_0_57, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcKalTrack::Dictionary) ), 0);
33171 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33172 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33173 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33174 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_484_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33175 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_484_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcKalTrack::DeclFileName) ), 0);
33176 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_484_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcKalTrack::ImplFileLine) ), 0);
33177 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_484_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcKalTrack::ImplFileName) ), 0);
33178 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_484_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcKalTrack::DeclFileLine) ), 0);
33179 // automatic copy constructor
33180 G__memfunc_setup("TMdcKalTrack", 1141, G__RootEventData_rootcint_484_0_66, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 0, 1, 1, 1, 0, "u 'TMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33181 // automatic destructor
33182 G__memfunc_setup("~TMdcKalTrack", 1267, G__RootEventData_rootcint_484_0_67, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33183 // automatic assignment operator
33184 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_484_0_68, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 1, 1, 1, 1, 0, "u 'TMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33185 G__tag_memfunc_reset();
33186}
33187
33188static void G__setup_memfuncTDstEvent(void) {
33189 /* TDstEvent */
33190 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
33191 G__memfunc_setup("TDstEvent",897,G__RootEventData_rootcint_485_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33192 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_485_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33193 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33194 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);
33195 G__memfunc_setup("getMdcTrackCol",1383,G__RootEventData_rootcint_485_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33196 G__memfunc_setup("addMdcTrack",1074,G__RootEventData_rootcint_485_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33197 G__memfunc_setup("getMdcTrack",1097,G__RootEventData_rootcint_485_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33198 G__memfunc_setup("clearMdcTrackCol",1582,G__RootEventData_rootcint_485_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33199 G__memfunc_setup("getEmcTrackCol",1384,G__RootEventData_rootcint_485_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33200 G__memfunc_setup("addEmcTrack",1075,G__RootEventData_rootcint_485_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEmcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33201 G__memfunc_setup("getEmcTrack",1098,G__RootEventData_rootcint_485_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33202 G__memfunc_setup("clearEmcTrackCol",1583,G__RootEventData_rootcint_485_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33203 G__memfunc_setup("getTofTrackCol",1404,G__RootEventData_rootcint_485_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33204 G__memfunc_setup("addTofTrack",1095,G__RootEventData_rootcint_485_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTofTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33205 G__memfunc_setup("getTofTrack",1118,G__RootEventData_rootcint_485_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33206 G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_485_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33207 G__memfunc_setup("getMucTrackCol",1400,G__RootEventData_rootcint_485_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33208 G__memfunc_setup("addMucTrack",1091,G__RootEventData_rootcint_485_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMucTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33209 G__memfunc_setup("getMucTrack",1114,G__RootEventData_rootcint_485_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33210 G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_485_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33211 G__memfunc_setup("getMdcDedxCol",1271,G__RootEventData_rootcint_485_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33212 G__memfunc_setup("addMdcDedx",962,G__RootEventData_rootcint_485_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcDedx' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33213 G__memfunc_setup("getMdcDedx",985,G__RootEventData_rootcint_485_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33214 G__memfunc_setup("clearMdcDedxCol",1470,G__RootEventData_rootcint_485_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33215 G__memfunc_setup("getExtTrackCol",1412,G__RootEventData_rootcint_485_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33216 G__memfunc_setup("addExtTrack",1103,G__RootEventData_rootcint_485_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TExtTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33217 G__memfunc_setup("getExtTrack",1126,G__RootEventData_rootcint_485_0_27, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33218 G__memfunc_setup("clearExtTrackCol",1611,G__RootEventData_rootcint_485_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33219 G__memfunc_setup("getMdcKalTrackCol",1663,G__RootEventData_rootcint_485_0_29, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33220 G__memfunc_setup("addMdcKalTrack",1354,G__RootEventData_rootcint_485_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcKalTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33221 G__memfunc_setup("getMdcKalTrack",1377,G__RootEventData_rootcint_485_0_31, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33222 G__memfunc_setup("clearMdcKalTrackCol",1862,G__RootEventData_rootcint_485_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33223 G__memfunc_setup("Class",502,G__RootEventData_rootcint_485_0_33, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDstEvent::Class) ), 0);
33224 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_485_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstEvent::Class_Name) ), 0);
33225 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_485_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDstEvent::Class_Version) ), 0);
33226 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_485_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDstEvent::Dictionary) ), 0);
33227 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33228 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33229 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33230 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_485_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33231 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_485_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstEvent::DeclFileName) ), 0);
33232 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_485_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstEvent::ImplFileLine) ), 0);
33233 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_485_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstEvent::ImplFileName) ), 0);
33234 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_485_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstEvent::DeclFileLine) ), 0);
33235 // automatic copy constructor
33236 G__memfunc_setup("TDstEvent", 897, G__RootEventData_rootcint_485_0_45, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 0, 1, 1, 1, 0, "u 'TDstEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33237 // automatic destructor
33238 G__memfunc_setup("~TDstEvent", 1023, G__RootEventData_rootcint_485_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33239 // automatic assignment operator
33240 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_485_0_47, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 1, 1, 1, 1, 0, "u 'TDstEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33241 G__tag_memfunc_reset();
33242}
33243
33244static void G__setup_memfuncTMdcMc(void) {
33245 /* TMdcMc */
33246 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
33247 G__memfunc_setup("TMdcMc",536,G__RootEventData_rootcint_486_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33248 G__memfunc_setup("getId",493,G__RootEventData_rootcint_486_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33249 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_486_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33250 G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_486_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33251 G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_486_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33252 G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_486_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33253 G__memfunc_setup("getDriftDistance",1636,G__RootEventData_rootcint_486_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33254 G__memfunc_setup("getDepositEnergy",1666,G__RootEventData_rootcint_486_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33255 G__memfunc_setup("getPositionFlag",1551,G__RootEventData_rootcint_486_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33256 G__memfunc_setup("setId",505,G__RootEventData_rootcint_486_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
33257 G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_486_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
33258 G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_486_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
33259 G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_486_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
33260 G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_486_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
33261 G__memfunc_setup("setDriftDistance",1648,G__RootEventData_rootcint_486_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - driftDistance", (char*)NULL, (void*) NULL, 0);
33262 G__memfunc_setup("setDepositEnergy",1678,G__RootEventData_rootcint_486_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depositEnergy", (char*)NULL, (void*) NULL, 0);
33263 G__memfunc_setup("setPositionFlag",1563,G__RootEventData_rootcint_486_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - posFlag", (char*)NULL, (void*) NULL, 0);
33264 G__memfunc_setup("Class",502,G__RootEventData_rootcint_486_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcMc::Class) ), 0);
33265 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_486_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcMc::Class_Name) ), 0);
33266 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_486_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcMc::Class_Version) ), 0);
33267 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_486_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcMc::Dictionary) ), 0);
33268 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33269 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33270 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33271 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_486_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33272 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_486_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcMc::DeclFileName) ), 0);
33273 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_486_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcMc::ImplFileLine) ), 0);
33274 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_486_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcMc::ImplFileName) ), 0);
33275 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_486_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcMc::DeclFileLine) ), 0);
33276 // automatic copy constructor
33277 G__memfunc_setup("TMdcMc", 536, G__RootEventData_rootcint_486_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 0, 1, 1, 1, 0, "u 'TMdcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33278 // automatic destructor
33279 G__memfunc_setup("~TMdcMc", 662, G__RootEventData_rootcint_486_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33280 // automatic assignment operator
33281 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_486_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 1, 1, 1, 1, 0, "u 'TMdcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33282 G__tag_memfunc_reset();
33283}
33284
33285static void G__setup_memfuncTEmcMc(void) {
33286 /* TEmcMc */
33287 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
33288 G__memfunc_setup("TEmcMc",537,G__RootEventData_rootcint_487_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33289 G__memfunc_setup("getHitMap",899,G__RootEventData_rootcint_487_0_2, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR), G__defined_typename("map<Int_t,Double_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33290 G__memfunc_setup("getHitEmc",890,G__RootEventData_rootcint_487_0_3, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33291 G__memfunc_setup("getPDGCode",918,G__RootEventData_rootcint_487_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33292 G__memfunc_setup("getPDGCharge",1125,G__RootEventData_rootcint_487_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33293 G__memfunc_setup("getTime",719,G__RootEventData_rootcint_487_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33294 G__memfunc_setup("getId",493,G__RootEventData_rootcint_487_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33295 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_487_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33296 G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_487_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33297 G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_487_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33298 G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_487_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33299 G__memfunc_setup("getPx",520,G__RootEventData_rootcint_487_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33300 G__memfunc_setup("getPy",521,G__RootEventData_rootcint_487_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33301 G__memfunc_setup("getPz",522,G__RootEventData_rootcint_487_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33302 G__memfunc_setup("getDepositEnergy",1666,G__RootEventData_rootcint_487_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33303 G__memfunc_setup("setHitMap",911,G__RootEventData_rootcint_487_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<int,double,less<int>,allocator<pair<const int,double> > >' 'map<Int_t,Double_t>' 0 - hitMap", (char*)NULL, (void*) NULL, 0);
33304 G__memfunc_setup("setHitEmc",902,G__RootEventData_rootcint_487_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - hitEmc", (char*)NULL, (void*) NULL, 0);
33305 G__memfunc_setup("setPDGCode",930,G__RootEventData_rootcint_487_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - PDGCode", (char*)NULL, (void*) NULL, 0);
33306 G__memfunc_setup("setPDGCharge",1137,G__RootEventData_rootcint_487_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - PDGCharge", (char*)NULL, (void*) NULL, 0);
33307 G__memfunc_setup("setTime",731,G__RootEventData_rootcint_487_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - time", (char*)NULL, (void*) NULL, 0);
33308 G__memfunc_setup("setId",505,G__RootEventData_rootcint_487_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
33309 G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_487_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
33310 G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_487_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
33311 G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_487_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
33312 G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_487_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
33313 G__memfunc_setup("setPx",532,G__RootEventData_rootcint_487_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
33314 G__memfunc_setup("setPy",533,G__RootEventData_rootcint_487_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
33315 G__memfunc_setup("setPz",534,G__RootEventData_rootcint_487_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
33316 G__memfunc_setup("setDepositEnergy",1678,G__RootEventData_rootcint_487_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depositEnergy", (char*)NULL, (void*) NULL, 0);
33317 G__memfunc_setup("Class",502,G__RootEventData_rootcint_487_0_30, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEmcMc::Class) ), 0);
33318 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_487_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcMc::Class_Name) ), 0);
33319 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_487_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEmcMc::Class_Version) ), 0);
33320 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_487_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEmcMc::Dictionary) ), 0);
33321 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33322 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33323 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33324 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_487_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33325 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_487_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcMc::DeclFileName) ), 0);
33326 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_487_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcMc::ImplFileLine) ), 0);
33327 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_487_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcMc::ImplFileName) ), 0);
33328 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_487_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcMc::DeclFileLine) ), 0);
33329 // automatic copy constructor
33330 G__memfunc_setup("TEmcMc", 537, G__RootEventData_rootcint_487_0_42, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 0, 1, 1, 1, 0, "u 'TEmcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33331 // automatic destructor
33332 G__memfunc_setup("~TEmcMc", 663, G__RootEventData_rootcint_487_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33333 // automatic assignment operator
33334 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_487_0_44, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 1, 1, 1, 1, 0, "u 'TEmcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33335 G__tag_memfunc_reset();
33336}
33337
33338static void G__setup_memfuncTTofMc(void) {
33339 /* TTofMc */
33340 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
33341 G__memfunc_setup("TTofMc",557,G__RootEventData_rootcint_488_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33342 G__memfunc_setup("getId",493,G__RootEventData_rootcint_488_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33343 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_488_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33344 G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_488_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33345 G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_488_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33346 G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_488_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33347 G__memfunc_setup("getPx",520,G__RootEventData_rootcint_488_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33348 G__memfunc_setup("getPy",521,G__RootEventData_rootcint_488_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33349 G__memfunc_setup("getPz",522,G__RootEventData_rootcint_488_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33350 G__memfunc_setup("getTrackLength",1431,G__RootEventData_rootcint_488_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33351 G__memfunc_setup("getFlightTime",1325,G__RootEventData_rootcint_488_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33352 G__memfunc_setup("setId",505,G__RootEventData_rootcint_488_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
33353 G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_488_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
33354 G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_488_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
33355 G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_488_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
33356 G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_488_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
33357 G__memfunc_setup("setPx",532,G__RootEventData_rootcint_488_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
33358 G__memfunc_setup("setPy",533,G__RootEventData_rootcint_488_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
33359 G__memfunc_setup("setPz",534,G__RootEventData_rootcint_488_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
33360 G__memfunc_setup("setTrackLength",1443,G__RootEventData_rootcint_488_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - trackLength", (char*)NULL, (void*) NULL, 0);
33361 G__memfunc_setup("setFlightTime",1337,G__RootEventData_rootcint_488_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - flightTime", (char*)NULL, (void*) NULL, 0);
33362 G__memfunc_setup("Class",502,G__RootEventData_rootcint_488_0_22, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTofMc::Class) ), 0);
33363 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_488_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofMc::Class_Name) ), 0);
33364 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_488_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTofMc::Class_Version) ), 0);
33365 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_488_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTofMc::Dictionary) ), 0);
33366 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33367 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33368 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33369 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_488_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33370 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_488_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofMc::DeclFileName) ), 0);
33371 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_488_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofMc::ImplFileLine) ), 0);
33372 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_488_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofMc::ImplFileName) ), 0);
33373 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_488_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofMc::DeclFileLine) ), 0);
33374 // automatic copy constructor
33375 G__memfunc_setup("TTofMc", 557, G__RootEventData_rootcint_488_0_34, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 0, 1, 1, 1, 0, "u 'TTofMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33376 // automatic destructor
33377 G__memfunc_setup("~TTofMc", 683, G__RootEventData_rootcint_488_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33378 // automatic assignment operator
33379 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_488_0_36, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 1, 1, 1, 1, 0, "u 'TTofMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33380 G__tag_memfunc_reset();
33381}
33382
33383static void G__setup_memfuncTMucMc(void) {
33384 /* TMucMc */
33385 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
33386 G__memfunc_setup("TMucMc",553,G__RootEventData_rootcint_489_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33387 G__memfunc_setup("getId",493,G__RootEventData_rootcint_489_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33388 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_489_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33389 G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_489_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33390 G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_489_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33391 G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_489_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33392 G__memfunc_setup("getPx",520,G__RootEventData_rootcint_489_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33393 G__memfunc_setup("getPy",521,G__RootEventData_rootcint_489_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33394 G__memfunc_setup("getPz",522,G__RootEventData_rootcint_489_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33395 G__memfunc_setup("setId",505,G__RootEventData_rootcint_489_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
33396 G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_489_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
33397 G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_489_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
33398 G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_489_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
33399 G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_489_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
33400 G__memfunc_setup("setPx",532,G__RootEventData_rootcint_489_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
33401 G__memfunc_setup("setPy",533,G__RootEventData_rootcint_489_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
33402 G__memfunc_setup("setPz",534,G__RootEventData_rootcint_489_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
33403 G__memfunc_setup("Class",502,G__RootEventData_rootcint_489_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMucMc::Class) ), 0);
33404 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_489_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucMc::Class_Name) ), 0);
33405 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_489_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMucMc::Class_Version) ), 0);
33406 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_489_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMucMc::Dictionary) ), 0);
33407 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33408 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33409 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33410 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_489_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33411 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_489_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucMc::DeclFileName) ), 0);
33412 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_489_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucMc::ImplFileLine) ), 0);
33413 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_489_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucMc::ImplFileName) ), 0);
33414 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_489_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucMc::DeclFileLine) ), 0);
33415 // automatic copy constructor
33416 G__memfunc_setup("TMucMc", 553, G__RootEventData_rootcint_489_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 0, 1, 1, 1, 0, "u 'TMucMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33417 // automatic destructor
33418 G__memfunc_setup("~TMucMc", 679, G__RootEventData_rootcint_489_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33419 // automatic assignment operator
33420 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_489_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 1, 1, 1, 1, 0, "u 'TMucMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
33421 G__tag_memfunc_reset();
33422}
33423
33424static void G__setup_memfuncTMcParticle(void) {
33425 /* TMcParticle */
33426 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
33427 G__memfunc_setup("TMcParticle",1080,G__RootEventData_rootcint_490_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33428 G__memfunc_setup("getParticleID",1281,G__RootEventData_rootcint_490_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33429 G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_490_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33430 G__memfunc_setup("getVertexIndex0",1510,G__RootEventData_rootcint_490_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33431 G__memfunc_setup("getVertexIndex1",1511,G__RootEventData_rootcint_490_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33432 G__memfunc_setup("getStatusFlags",1457,G__RootEventData_rootcint_490_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33433 G__memfunc_setup("getInitialPositionX",1975,G__RootEventData_rootcint_490_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33434 G__memfunc_setup("getInitialPositionY",1976,G__RootEventData_rootcint_490_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33435 G__memfunc_setup("getInitialPositionZ",1977,G__RootEventData_rootcint_490_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33436 G__memfunc_setup("getInitialPositionT",1971,G__RootEventData_rootcint_490_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33437 G__memfunc_setup("getFinalPositionX",1751,G__RootEventData_rootcint_490_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33438 G__memfunc_setup("getFinalPositionY",1752,G__RootEventData_rootcint_490_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33439 G__memfunc_setup("getFinalPositionZ",1753,G__RootEventData_rootcint_490_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33440 G__memfunc_setup("getFinalPositionT",1747,G__RootEventData_rootcint_490_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33441 G__memfunc_setup("getInitialMomentumX",1972,G__RootEventData_rootcint_490_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33442 G__memfunc_setup("getInitialMomentumY",1973,G__RootEventData_rootcint_490_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33443 G__memfunc_setup("getInitialMomentumZ",1974,G__RootEventData_rootcint_490_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33444 G__memfunc_setup("getInitialMomentumE",1953,G__RootEventData_rootcint_490_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33445 G__memfunc_setup("getMother",943,G__RootEventData_rootcint_490_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33446 G__memfunc_setup("getDaughters",1255,G__RootEventData_rootcint_490_0_20, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33447 G__memfunc_setup("primaryParticle",1592,G__RootEventData_rootcint_490_0_21, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33448 G__memfunc_setup("leafParticle",1228,G__RootEventData_rootcint_490_0_22, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33449 G__memfunc_setup("decayFromGenerator",1857,G__RootEventData_rootcint_490_0_23, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33450 G__memfunc_setup("decayInFlight",1307,G__RootEventData_rootcint_490_0_24, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33451 G__memfunc_setup("setParticleID",1293,G__RootEventData_rootcint_490_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - particleID", (char*)NULL, (void*) NULL, 0);
33452 G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_490_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
33453 G__memfunc_setup("setVertexIndex0",1522,G__RootEventData_rootcint_490_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vertexIndex0", (char*)NULL, (void*) NULL, 0);
33454 G__memfunc_setup("setVertexIndex1",1523,G__RootEventData_rootcint_490_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vertexIndex1", (char*)NULL, (void*) NULL, 0);
33455 G__memfunc_setup("setStatusFlags",1469,G__RootEventData_rootcint_490_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - statusFlags", (char*)NULL, (void*) NULL, 0);
33456 G__memfunc_setup("setInitialPositionX",1987,G__RootEventData_rootcint_490_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
33457 G__memfunc_setup("setInitialPositionY",1988,G__RootEventData_rootcint_490_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
33458 G__memfunc_setup("setInitialPositionZ",1989,G__RootEventData_rootcint_490_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
33459 G__memfunc_setup("setInitialPositionT",1983,G__RootEventData_rootcint_490_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionT", (char*)NULL, (void*) NULL, 0);
33460 G__memfunc_setup("setFinalPositionX",1763,G__RootEventData_rootcint_490_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
33461 G__memfunc_setup("setFinalPositionY",1764,G__RootEventData_rootcint_490_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
33462 G__memfunc_setup("setFinalPositionZ",1765,G__RootEventData_rootcint_490_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
33463 G__memfunc_setup("setFinalPositionT",1759,G__RootEventData_rootcint_490_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionT", (char*)NULL, (void*) NULL, 0);
33464 G__memfunc_setup("setInitialMomentumX",1984,G__RootEventData_rootcint_490_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumX", (char*)NULL, (void*) NULL, 0);
33465 G__memfunc_setup("setInitialMomentumY",1985,G__RootEventData_rootcint_490_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumY", (char*)NULL, (void*) NULL, 0);
33466 G__memfunc_setup("setInitialMomentumZ",1986,G__RootEventData_rootcint_490_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumZ", (char*)NULL, (void*) NULL, 0);
33467 G__memfunc_setup("setInitialMomentumE",1965,G__RootEventData_rootcint_490_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumE", (char*)NULL, (void*) NULL, 0);
33468 G__memfunc_setup("setMother",955,G__RootEventData_rootcint_490_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mother", (char*)NULL, (void*) NULL, 0);
33469 G__memfunc_setup("setDaughters",1267,G__RootEventData_rootcint_490_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - daughters", (char*)NULL, (void*) NULL, 0);
33470 G__memfunc_setup("Class",502,G__RootEventData_rootcint_490_0_44, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcParticle::Class) ), 0);
33471 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_490_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcParticle::Class_Name) ), 0);
33472 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_490_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcParticle::Class_Version) ), 0);
33473 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_490_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcParticle::Dictionary) ), 0);
33474 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33475 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33476 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33477 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_490_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33478 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_490_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcParticle::DeclFileName) ), 0);
33479 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_490_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcParticle::ImplFileLine) ), 0);
33480 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_490_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcParticle::ImplFileName) ), 0);
33481 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_490_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcParticle::DeclFileLine) ), 0);
33482 // automatic copy constructor
33483 G__memfunc_setup("TMcParticle", 1080, G__RootEventData_rootcint_490_0_56, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 0, 1, 1, 1, 0, "u 'TMcParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
33484 // automatic destructor
33485 G__memfunc_setup("~TMcParticle", 1206, G__RootEventData_rootcint_490_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33486 // automatic assignment operator
33487 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_490_0_58, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 1, 1, 1, 1, 0, "u 'TMcParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
33488 G__tag_memfunc_reset();
33489}
33490
33491static void G__setup_memfuncTMcEvent(void) {
33492 /* TMcEvent */
33493 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
33494 G__memfunc_setup("TMcEvent",774,G__RootEventData_rootcint_492_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33495 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_492_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33496 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33497 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);
33498 G__memfunc_setup("getMdcMcHitCol",1351,G__RootEventData_rootcint_492_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33499 G__memfunc_setup("addMdcMc",749,G__RootEventData_rootcint_492_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
33500 G__memfunc_setup("getMdcMc",772,G__RootEventData_rootcint_492_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33501 G__memfunc_setup("clearMdcMcHitCol",1550,G__RootEventData_rootcint_492_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33502 G__memfunc_setup("getEmcMcHitCol",1352,G__RootEventData_rootcint_492_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33503 G__memfunc_setup("addEmcMc",750,G__RootEventData_rootcint_492_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEmcMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
33504 G__memfunc_setup("getEmcMc",773,G__RootEventData_rootcint_492_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33505 G__memfunc_setup("clearEmcMcHitCol",1551,G__RootEventData_rootcint_492_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33506 G__memfunc_setup("getTofMcHitCol",1372,G__RootEventData_rootcint_492_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33507 G__memfunc_setup("addTofMc",770,G__RootEventData_rootcint_492_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTofMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
33508 G__memfunc_setup("getTofMc",793,G__RootEventData_rootcint_492_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33509 G__memfunc_setup("clearTofMcHitCol",1571,G__RootEventData_rootcint_492_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33510 G__memfunc_setup("getMucMcHitCol",1368,G__RootEventData_rootcint_492_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33511 G__memfunc_setup("addMucMc",766,G__RootEventData_rootcint_492_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMucMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
33512 G__memfunc_setup("getMucMc",789,G__RootEventData_rootcint_492_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33513 G__memfunc_setup("clearMucMcHitCol",1567,G__RootEventData_rootcint_492_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33514 G__memfunc_setup("getMcParticleCol",1602,G__RootEventData_rootcint_492_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33515 G__memfunc_setup("addMcParticle",1293,G__RootEventData_rootcint_492_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcParticle' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
33516 G__memfunc_setup("getMcParticle",1316,G__RootEventData_rootcint_492_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33517 G__memfunc_setup("clearMcParticleCol",1801,G__RootEventData_rootcint_492_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33518 G__memfunc_setup("Class",502,G__RootEventData_rootcint_492_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcEvent::Class) ), 0);
33519 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_492_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcEvent::Class_Name) ), 0);
33520 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_492_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcEvent::Class_Version) ), 0);
33521 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_492_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcEvent::Dictionary) ), 0);
33522 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33523 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33524 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33525 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_492_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33526 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_492_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcEvent::DeclFileName) ), 0);
33527 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_492_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcEvent::ImplFileLine) ), 0);
33528 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_492_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcEvent::ImplFileName) ), 0);
33529 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_492_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcEvent::DeclFileLine) ), 0);
33530 // automatic copy constructor
33531 G__memfunc_setup("TMcEvent", 774, G__RootEventData_rootcint_492_0_37, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 0, 1, 1, 1, 0, "u 'TMcEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33532 // automatic destructor
33533 G__memfunc_setup("~TMcEvent", 900, G__RootEventData_rootcint_492_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33534 // automatic assignment operator
33535 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_492_0_39, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 1, 1, 1, 1, 0, "u 'TMcEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33536 G__tag_memfunc_reset();
33537}
33538
33539static void G__setup_memfuncTEvtHeader(void) {
33540 /* TEvtHeader */
33541 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
33542 G__memfunc_setup("TEvtHeader",972,G__RootEventData_rootcint_493_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33543 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_493_0_2, 121, -1, -1, 0, 3, 1, 1, 0,
33544"i - 'Int_t' 0 - Id i - 'Int_t' 0 - runId "
33545"h - 'UInt_t' 0 - evenTag", (char*)NULL, (void*) NULL, 0);
33546 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33547 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);
33548 G__memfunc_setup("getEventId",1007,G__RootEventData_rootcint_493_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33549 G__memfunc_setup("getRunId",802,G__RootEventData_rootcint_493_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33550 G__memfunc_setup("time",431,G__RootEventData_rootcint_493_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33551 G__memfunc_setup("setTime",731,G__RootEventData_rootcint_493_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - value", (char*)NULL, (void*) NULL, 0);
33552 G__memfunc_setup("getEventTag",1118,G__RootEventData_rootcint_493_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33553 G__memfunc_setup("setFlag1",759,G__RootEventData_rootcint_493_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - value", (char*)NULL, (void*) NULL, 0);
33554 G__memfunc_setup("setFlag2",760,G__RootEventData_rootcint_493_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - value", (char*)NULL, (void*) NULL, 0);
33555 G__memfunc_setup("getFlag1",747,G__RootEventData_rootcint_493_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33556 G__memfunc_setup("getFlag2",748,G__RootEventData_rootcint_493_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33557 G__memfunc_setup("Class",502,G__RootEventData_rootcint_493_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtHeader::Class) ), 0);
33558 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_493_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::Class_Name) ), 0);
33559 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_493_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtHeader::Class_Version) ), 0);
33560 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_493_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtHeader::Dictionary) ), 0);
33561 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33562 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33563 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33564 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_493_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33565 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_493_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::DeclFileName) ), 0);
33566 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_493_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtHeader::ImplFileLine) ), 0);
33567 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_493_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::ImplFileName) ), 0);
33568 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_493_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtHeader::DeclFileLine) ), 0);
33569 // automatic copy constructor
33570 G__memfunc_setup("TEvtHeader", 972, G__RootEventData_rootcint_493_0_26, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 1, 1, 1, 0, "u 'TEvtHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
33571 // automatic destructor
33572 G__memfunc_setup("~TEvtHeader", 1098, G__RootEventData_rootcint_493_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33573 // automatic assignment operator
33574 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_493_0_28, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 1, 1, 1, 1, 0, "u 'TEvtHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
33575 G__tag_memfunc_reset();
33576}
33577
33578static void G__setup_memfuncTEvtNavigator(void) {
33579 /* TEvtNavigator */
33580 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
33581 G__memfunc_setup("TEvtNavigator",1326,G__RootEventData_rootcint_503_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33582 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33583 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);
33584 G__memfunc_setup("LoadMcMdcMcHits",1420,G__RootEventData_rootcint_503_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
33585 G__memfunc_setup("LoadMcMdcTracks",1452,G__RootEventData_rootcint_503_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
33586 G__memfunc_setup("LoadMcEmcMcHits",1421,G__RootEventData_rootcint_503_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
33587 G__memfunc_setup("LoadMcEmcRecShowers",1866,G__RootEventData_rootcint_503_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
33588 G__memfunc_setup("Class",502,G__RootEventData_rootcint_503_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtNavigator::Class) ), 0);
33589 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_503_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtNavigator::Class_Name) ), 0);
33590 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_503_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtNavigator::Class_Version) ), 0);
33591 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_503_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtNavigator::Dictionary) ), 0);
33592 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33593 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33594 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33595 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_503_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33596 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_503_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtNavigator::DeclFileName) ), 0);
33597 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_503_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtNavigator::ImplFileLine) ), 0);
33598 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_503_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtNavigator::ImplFileName) ), 0);
33599 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_503_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtNavigator::DeclFileLine) ), 0);
33600 // automatic copy constructor
33601 G__memfunc_setup("TEvtNavigator", 1326, G__RootEventData_rootcint_503_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator), -1, 0, 1, 1, 1, 0, "u 'TEvtNavigator' - 11 - -", (char*) NULL, (void*) NULL, 0);
33602 // automatic destructor
33603 G__memfunc_setup("~TEvtNavigator", 1452, G__RootEventData_rootcint_503_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33604 // automatic assignment operator
33605 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_503_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator), -1, 1, 1, 1, 1, 0, "u 'TEvtNavigator' - 11 - -", (char*) NULL, (void*) NULL, 0);
33606 G__tag_memfunc_reset();
33607}
33608
33609static void G__setup_memfuncTTrigData(void) {
33610 /* TTrigData */
33611 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
33612 G__memfunc_setup("TTrigData",868,G__RootEventData_rootcint_507_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33613 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33614 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);
33615 G__memfunc_setup("setTrigCondition",1673,G__RootEventData_rootcint_507_0_4, 121, -1, -1, 0, 2, 1, 1, 0,
33616"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
33617 G__memfunc_setup("setTrigCondition",1673,G__RootEventData_rootcint_507_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "I - - 10 - cond", (char*)NULL, (void*) NULL, 0);
33618 G__memfunc_setup("setTrigChannel",1435,G__RootEventData_rootcint_507_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
33619"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
33620 G__memfunc_setup("setTrigChannel",1435,G__RootEventData_rootcint_507_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "I - - 10 - chan", (char*)NULL, (void*) NULL, 0);
33621 G__memfunc_setup("setTimeWindow",1363,G__RootEventData_rootcint_507_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
33622 G__memfunc_setup("setTimingType",1366,G__RootEventData_rootcint_507_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
33623 G__memfunc_setup("setPreScale",1115,G__RootEventData_rootcint_507_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - i", (char*)NULL, (void*) NULL, 0);
33624 G__memfunc_setup("getTrigCondition",1661,G__RootEventData_rootcint_507_0_11, 105, -1, -1, 0, 1, 1, 1, 9, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
33625 G__memfunc_setup("getTrigCondition",1661,G__RootEventData_rootcint_507_0_12, 73, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33626 G__memfunc_setup("getTrigChannel",1423,G__RootEventData_rootcint_507_0_13, 105, -1, -1, 0, 1, 1, 1, 9, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
33627 G__memfunc_setup("getTrigChannel",1423,G__RootEventData_rootcint_507_0_14, 73, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33628 G__memfunc_setup("getTimeWindow",1351,G__RootEventData_rootcint_507_0_15, 105, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33629 G__memfunc_setup("getTimingType",1354,G__RootEventData_rootcint_507_0_16, 105, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33630 G__memfunc_setup("getPreScale",1103,G__RootEventData_rootcint_507_0_17, 103, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33631 G__memfunc_setup("Class",502,G__RootEventData_rootcint_507_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTrigData::Class) ), 0);
33632 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_507_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigData::Class_Name) ), 0);
33633 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_507_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTrigData::Class_Version) ), 0);
33634 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_507_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTrigData::Dictionary) ), 0);
33635 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33636 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33637 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33638 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_507_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33639 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_507_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigData::DeclFileName) ), 0);
33640 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_507_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigData::ImplFileLine) ), 0);
33641 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_507_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigData::ImplFileName) ), 0);
33642 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_507_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigData::DeclFileLine) ), 0);
33643 // automatic copy constructor
33644 G__memfunc_setup("TTrigData", 868, G__RootEventData_rootcint_507_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 0, 1, 1, 1, 0, "u 'TTrigData' - 11 - -", (char*) NULL, (void*) NULL, 0);
33645 // automatic destructor
33646 G__memfunc_setup("~TTrigData", 994, G__RootEventData_rootcint_507_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33647 // automatic assignment operator
33648 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_507_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 1, 1, 1, 1, 0, "u 'TTrigData' - 11 - -", (char*) NULL, (void*) NULL, 0);
33649 G__tag_memfunc_reset();
33650}
33651
33652static void G__setup_memfuncTTrigEvent(void) {
33653 /* TTrigEvent */
33654 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
33655 G__memfunc_setup("TTrigEvent",1004,G__RootEventData_rootcint_508_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33656 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_508_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33657 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33658 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);
33659 G__memfunc_setup("addTrigData",1081,G__RootEventData_rootcint_508_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTrigData' - 0 - trigData", (char*)NULL, (void*) NULL, 0);
33660 G__memfunc_setup("getTrigData",1104,G__RootEventData_rootcint_508_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33661 G__memfunc_setup("clearTrigData",1303,G__RootEventData_rootcint_508_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33662 G__memfunc_setup("Class",502,G__RootEventData_rootcint_508_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTrigEvent::Class) ), 0);
33663 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_508_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigEvent::Class_Name) ), 0);
33664 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_508_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTrigEvent::Class_Version) ), 0);
33665 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_508_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTrigEvent::Dictionary) ), 0);
33666 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33667 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33668 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33669 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_508_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33670 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_508_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigEvent::DeclFileName) ), 0);
33671 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_508_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigEvent::ImplFileLine) ), 0);
33672 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_508_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigEvent::ImplFileName) ), 0);
33673 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_508_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigEvent::DeclFileLine) ), 0);
33674 // automatic copy constructor
33675 G__memfunc_setup("TTrigEvent", 1004, G__RootEventData_rootcint_508_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 0, 1, 1, 1, 0, "u 'TTrigEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33676 // automatic destructor
33677 G__memfunc_setup("~TTrigEvent", 1130, G__RootEventData_rootcint_508_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33678 // automatic assignment operator
33679 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_508_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 1, 1, 1, 1, 0, "u 'TTrigEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33680 G__tag_memfunc_reset();
33681}
33682
33683static void G__setup_memfuncTHltRaw(void) {
33684 /* THltRaw */
33685 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
33686 G__memfunc_setup("THltRaw",678,G__RootEventData_rootcint_509_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33687 G__memfunc_setup("Class",502,G__RootEventData_rootcint_509_0_2, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THltRaw::Class) ), 0);
33688 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_509_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltRaw::Class_Name) ), 0);
33689 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_509_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THltRaw::Class_Version) ), 0);
33690 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_509_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THltRaw::Dictionary) ), 0);
33691 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33692 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33693 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33694 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_509_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33695 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_509_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltRaw::DeclFileName) ), 0);
33696 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_509_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltRaw::ImplFileLine) ), 0);
33697 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_509_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltRaw::ImplFileName) ), 0);
33698 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_509_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltRaw::DeclFileLine) ), 0);
33699 // automatic copy constructor
33700 G__memfunc_setup("THltRaw", 678, G__RootEventData_rootcint_509_0_14, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 0, 1, 1, 1, 0, "u 'THltRaw' - 11 - -", (char*) NULL, (void*) NULL, 0);
33701 // automatic destructor
33702 G__memfunc_setup("~THltRaw", 804, G__RootEventData_rootcint_509_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33703 // automatic assignment operator
33704 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_509_0_16, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 1, 1, 1, 1, 0, "u 'THltRaw' - 11 - -", (char*) NULL, (void*) NULL, 0);
33705 G__tag_memfunc_reset();
33706}
33707
33708static void G__setup_memfuncTHltInf(void) {
33709 /* THltInf */
33710 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
33711 G__memfunc_setup("THltInf",665,G__RootEventData_rootcint_510_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33712 G__memfunc_setup("setEventType",1264,G__RootEventData_rootcint_510_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33713 G__memfunc_setup("setAlgProcess",1343,G__RootEventData_rootcint_510_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33714 G__memfunc_setup("setCriteriaTable",1639,G__RootEventData_rootcint_510_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33715 G__memfunc_setup("setVersion",1074,G__RootEventData_rootcint_510_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33716 G__memfunc_setup("setTotalEnergy",1466,G__RootEventData_rootcint_510_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - etot", (char*)NULL, (void*) NULL, 0);
33717 G__memfunc_setup("setNumber",949,G__RootEventData_rootcint_510_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33718 G__memfunc_setup("setNCON",634,G__RootEventData_rootcint_510_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33719 G__memfunc_setup("setMdcData",986,G__RootEventData_rootcint_510_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
33720 G__memfunc_setup("setTofData",1007,G__RootEventData_rootcint_510_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
33721 G__memfunc_setup("setEmcData",987,G__RootEventData_rootcint_510_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
33722 G__memfunc_setup("setMucData",1003,G__RootEventData_rootcint_510_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
33723 G__memfunc_setup("setConData",998,G__RootEventData_rootcint_510_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
33724 G__memfunc_setup("getEventType",1252,G__RootEventData_rootcint_510_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33725 G__memfunc_setup("getAlgProcess",1331,G__RootEventData_rootcint_510_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33726 G__memfunc_setup("getCriteriaTable",1627,G__RootEventData_rootcint_510_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33727 G__memfunc_setup("getVersion",1062,G__RootEventData_rootcint_510_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33728 G__memfunc_setup("getTotalEnergy",1454,G__RootEventData_rootcint_510_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33729 G__memfunc_setup("getNumber",937,G__RootEventData_rootcint_510_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33730 G__memfunc_setup("getNCON",622,G__RootEventData_rootcint_510_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33731 G__memfunc_setup("getMdcData",974,G__RootEventData_rootcint_510_0_21, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33732 G__memfunc_setup("getTofData",995,G__RootEventData_rootcint_510_0_22, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33733 G__memfunc_setup("getEmcData",975,G__RootEventData_rootcint_510_0_23, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33734 G__memfunc_setup("getMucData",991,G__RootEventData_rootcint_510_0_24, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33735 G__memfunc_setup("getConData",986,G__RootEventData_rootcint_510_0_25, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33736 G__memfunc_setup("Class",502,G__RootEventData_rootcint_510_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THltInf::Class) ), 0);
33737 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_510_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltInf::Class_Name) ), 0);
33738 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_510_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THltInf::Class_Version) ), 0);
33739 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_510_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THltInf::Dictionary) ), 0);
33740 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33741 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33742 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33743 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_510_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33744 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_510_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltInf::DeclFileName) ), 0);
33745 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_510_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltInf::ImplFileLine) ), 0);
33746 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_510_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltInf::ImplFileName) ), 0);
33747 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_510_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltInf::DeclFileLine) ), 0);
33748 // automatic copy constructor
33749 G__memfunc_setup("THltInf", 665, G__RootEventData_rootcint_510_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 0, 1, 1, 1, 0, "u 'THltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
33750 // automatic destructor
33751 G__memfunc_setup("~THltInf", 791, G__RootEventData_rootcint_510_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33752 // automatic assignment operator
33753 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_510_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 1, 1, 1, 1, 0, "u 'THltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
33754 G__tag_memfunc_reset();
33755}
33756
33757static void G__setup_memfuncTDstHltInf(void) {
33758 /* TDstHltInf */
33759 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
33760 G__memfunc_setup("TDstHltInf",964,G__RootEventData_rootcint_511_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33761 G__memfunc_setup("setEventType",1264,G__RootEventData_rootcint_511_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33762 G__memfunc_setup("setAlgProcess",1343,G__RootEventData_rootcint_511_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33763 G__memfunc_setup("setCriteriaTable",1639,G__RootEventData_rootcint_511_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33764 G__memfunc_setup("setVersion",1074,G__RootEventData_rootcint_511_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33765 G__memfunc_setup("setTotalEnergy",1466,G__RootEventData_rootcint_511_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - etot", (char*)NULL, (void*) NULL, 0);
33766 G__memfunc_setup("setNumber",949,G__RootEventData_rootcint_511_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33767 G__memfunc_setup("setNCON",634,G__RootEventData_rootcint_511_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
33768 G__memfunc_setup("getEventType",1252,G__RootEventData_rootcint_511_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33769 G__memfunc_setup("getAlgProcess",1331,G__RootEventData_rootcint_511_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33770 G__memfunc_setup("getCriteriaTable",1627,G__RootEventData_rootcint_511_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33771 G__memfunc_setup("getVersion",1062,G__RootEventData_rootcint_511_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33772 G__memfunc_setup("getTotalEnergy",1454,G__RootEventData_rootcint_511_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33773 G__memfunc_setup("getNumber",937,G__RootEventData_rootcint_511_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33774 G__memfunc_setup("getNCON",622,G__RootEventData_rootcint_511_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33775 G__memfunc_setup("Class",502,G__RootEventData_rootcint_511_0_16, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDstHltInf::Class) ), 0);
33776 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_511_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstHltInf::Class_Name) ), 0);
33777 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_511_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDstHltInf::Class_Version) ), 0);
33778 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_511_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDstHltInf::Dictionary) ), 0);
33779 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33780 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33781 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33782 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_511_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33783 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_511_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstHltInf::DeclFileName) ), 0);
33784 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_511_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstHltInf::ImplFileLine) ), 0);
33785 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_511_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstHltInf::ImplFileName) ), 0);
33786 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_511_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstHltInf::DeclFileLine) ), 0);
33787 // automatic copy constructor
33788 G__memfunc_setup("TDstHltInf", 964, G__RootEventData_rootcint_511_0_28, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 0, 1, 1, 1, 0, "u 'TDstHltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
33789 // automatic destructor
33790 G__memfunc_setup("~TDstHltInf", 1090, G__RootEventData_rootcint_511_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33791 // automatic assignment operator
33792 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_511_0_30, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 1, 1, 1, 1, 0, "u 'TDstHltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
33793 G__tag_memfunc_reset();
33794}
33795
33796static void G__setup_memfuncTHltEvent(void) {
33797 /* THltEvent */
33798 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
33799 G__memfunc_setup("THltEvent",894,G__RootEventData_rootcint_512_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33800 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_512_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33801 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33802 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);
33803 G__memfunc_setup("addHltRaw",891,G__RootEventData_rootcint_512_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THltRaw' - 0 - hltRaw", (char*)NULL, (void*) NULL, 0);
33804 G__memfunc_setup("getHltRaw",914,G__RootEventData_rootcint_512_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 0, 1, 1, 1, 9, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
33805 G__memfunc_setup("getHltRawCol",1200,G__RootEventData_rootcint_512_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33806 G__memfunc_setup("clearHltRawCol",1399,G__RootEventData_rootcint_512_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33807 G__memfunc_setup("addHltInf",878,G__RootEventData_rootcint_512_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THltInf' - 0 - hltInf", (char*)NULL, (void*) NULL, 0);
33808 G__memfunc_setup("getHltInf",901,G__RootEventData_rootcint_512_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33809 G__memfunc_setup("clearHltInf",1100,G__RootEventData_rootcint_512_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33810 G__memfunc_setup("addDstHltInf",1177,G__RootEventData_rootcint_512_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDstHltInf' - 0 - dstHltInf", (char*)NULL, (void*) NULL, 0);
33811 G__memfunc_setup("getDstHltInf",1200,G__RootEventData_rootcint_512_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33812 G__memfunc_setup("clearDstHltInf",1399,G__RootEventData_rootcint_512_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33813 G__memfunc_setup("Class",502,G__RootEventData_rootcint_512_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THltEvent::Class) ), 0);
33814 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_512_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltEvent::Class_Name) ), 0);
33815 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_512_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THltEvent::Class_Version) ), 0);
33816 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_512_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THltEvent::Dictionary) ), 0);
33817 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33818 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33819 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33820 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_512_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33821 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_512_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltEvent::DeclFileName) ), 0);
33822 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_512_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltEvent::ImplFileLine) ), 0);
33823 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_512_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltEvent::ImplFileName) ), 0);
33824 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_512_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltEvent::DeclFileLine) ), 0);
33825 // automatic copy constructor
33826 G__memfunc_setup("THltEvent", 894, G__RootEventData_rootcint_512_0_27, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 0, 1, 1, 1, 0, "u 'THltEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33827 // automatic destructor
33828 G__memfunc_setup("~THltEvent", 1020, G__RootEventData_rootcint_512_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33829 // automatic assignment operator
33830 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_512_0_29, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 1, 1, 1, 1, 0, "u 'THltEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33831 G__tag_memfunc_reset();
33832}
33833
33834static void G__setup_memfuncTDisTrack(void) {
33835 /* TDisTrack */
33836 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
33837 G__memfunc_setup("TDisTrack",873,G__RootEventData_rootcint_513_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33838 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_513_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33839 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33840 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);
33841 G__memfunc_setup("getRecMdcTrackCol",1665,G__RootEventData_rootcint_513_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33842 G__memfunc_setup("addRecMdcTrack",1356,G__RootEventData_rootcint_513_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33843 G__memfunc_setup("getRecMdcTrack",1379,G__RootEventData_rootcint_513_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33844 G__memfunc_setup("clearRecMdcTrackCol",1864,G__RootEventData_rootcint_513_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33845 G__memfunc_setup("getRecMdcHitCol",1457,G__RootEventData_rootcint_513_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33846 G__memfunc_setup("addRecMdcHit",1148,G__RootEventData_rootcint_513_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcHit' - 0 - Hit", (char*)NULL, (void*) NULL, 0);
33847 G__memfunc_setup("getRecMdcHit",1171,G__RootEventData_rootcint_513_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33848 G__memfunc_setup("clearRecMdcHitCol",1656,G__RootEventData_rootcint_513_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33849 G__memfunc_setup("getTofTrackCol",1404,G__RootEventData_rootcint_513_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33850 G__memfunc_setup("addTofTrack",1095,G__RootEventData_rootcint_513_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTofTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33851 G__memfunc_setup("getTofTrack",1118,G__RootEventData_rootcint_513_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33852 G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_513_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33853 G__memfunc_setup("getMucTrackCol",1400,G__RootEventData_rootcint_513_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33854 G__memfunc_setup("addMucTrack",1091,G__RootEventData_rootcint_513_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMucTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33855 G__memfunc_setup("getMucTrack",1114,G__RootEventData_rootcint_513_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33856 G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_513_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33857 G__memfunc_setup("getMdcTrackNum",1401,G__RootEventData_rootcint_513_0_21, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33858 G__memfunc_setup("getTofTrackNum",1422,G__RootEventData_rootcint_513_0_22, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33859 G__memfunc_setup("getEmcShowerNum",1533,G__RootEventData_rootcint_513_0_23, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33860 G__memfunc_setup("getMucTrackNum",1418,G__RootEventData_rootcint_513_0_24, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33861 G__memfunc_setup("getMdcHitNum",1193,G__RootEventData_rootcint_513_0_25, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33862 G__memfunc_setup("getEmcShowerCol",1515,G__RootEventData_rootcint_513_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33863 G__memfunc_setup("addEmcShower",1206,G__RootEventData_rootcint_513_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcShower' - 0 - Track", (char*)NULL, (void*) NULL, 0);
33864 G__memfunc_setup("getEmcShower",1229,G__RootEventData_rootcint_513_0_28, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33865 G__memfunc_setup("clearEmcShowerCol",1714,G__RootEventData_rootcint_513_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33866 G__memfunc_setup("Class",502,G__RootEventData_rootcint_513_0_30, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDisTrack::Class) ), 0);
33867 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_513_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDisTrack::Class_Name) ), 0);
33868 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_513_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDisTrack::Class_Version) ), 0);
33869 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_513_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDisTrack::Dictionary) ), 0);
33870 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33871 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33872 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33873 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_513_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33874 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_513_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDisTrack::DeclFileName) ), 0);
33875 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_513_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDisTrack::ImplFileLine) ), 0);
33876 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_513_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDisTrack::ImplFileName) ), 0);
33877 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_513_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDisTrack::DeclFileLine) ), 0);
33878 // automatic copy constructor
33879 G__memfunc_setup("TDisTrack", 873, G__RootEventData_rootcint_513_0_42, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack), -1, 0, 1, 1, 1, 0, "u 'TDisTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33880 // automatic destructor
33881 G__memfunc_setup("~TDisTrack", 999, G__RootEventData_rootcint_513_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33882 // automatic assignment operator
33883 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_513_0_44, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack), -1, 1, 1, 1, 1, 0, "u 'TDisTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33884 G__tag_memfunc_reset();
33885}
33886
33887static void G__setup_memfuncTEvtRecEvent(void) {
33888 /* TEvtRecEvent */
33889 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
33890 G__memfunc_setup("TEvtRecEvent",1183,G__RootEventData_rootcint_514_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33891 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_514_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33892 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
33893 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);
33894 G__memfunc_setup("totalTracks",1164,G__RootEventData_rootcint_514_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33895 G__memfunc_setup("totalCharged",1234,G__RootEventData_rootcint_514_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33896 G__memfunc_setup("totalNeutral",1279,G__RootEventData_rootcint_514_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33897 G__memfunc_setup("numberOfVee",1118,G__RootEventData_rootcint_514_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33898 G__memfunc_setup("numberOfPi0",1063,G__RootEventData_rootcint_514_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33899 G__memfunc_setup("numberOfEtaToGG",1449,G__RootEventData_rootcint_514_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33900 G__memfunc_setup("numberOfDTag",1182,G__RootEventData_rootcint_514_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33901 G__memfunc_setup("setTotalTracks",1464,G__RootEventData_rootcint_514_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - tottks", (char*)NULL, (void*) NULL, 0);
33902 G__memfunc_setup("setTotalCharged",1534,G__RootEventData_rootcint_514_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - nchrg", (char*)NULL, (void*) NULL, 0);
33903 G__memfunc_setup("setTotalNeutral",1579,G__RootEventData_rootcint_514_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - nneu", (char*)NULL, (void*) NULL, 0);
33904 G__memfunc_setup("setNumberOfVee",1418,G__RootEventData_rootcint_514_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - nvee", (char*)NULL, (void*) NULL, 0);
33905 G__memfunc_setup("setNumberOfPi0",1363,G__RootEventData_rootcint_514_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - npi0", (char*)NULL, (void*) NULL, 0);
33906 G__memfunc_setup("setNumberOfEtaToGG",1749,G__RootEventData_rootcint_514_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - neta", (char*)NULL, (void*) NULL, 0);
33907 G__memfunc_setup("setNumberOfDTag",1482,G__RootEventData_rootcint_514_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - ndtag", (char*)NULL, (void*) NULL, 0);
33908 G__memfunc_setup("Class",502,G__RootEventData_rootcint_514_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecEvent::Class) ), 0);
33909 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_514_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEvent::Class_Name) ), 0);
33910 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_514_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecEvent::Class_Version) ), 0);
33911 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_514_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecEvent::Dictionary) ), 0);
33912 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33913 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33914 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33915 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_514_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33916 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_514_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEvent::DeclFileName) ), 0);
33917 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_514_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEvent::ImplFileLine) ), 0);
33918 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_514_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEvent::ImplFileName) ), 0);
33919 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_514_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEvent::DeclFileLine) ), 0);
33920 // automatic copy constructor
33921 G__memfunc_setup("TEvtRecEvent", 1183, G__RootEventData_rootcint_514_0_31, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 0, 1, 1, 1, 0, "u 'TEvtRecEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33922 // automatic destructor
33923 G__memfunc_setup("~TEvtRecEvent", 1309, G__RootEventData_rootcint_514_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33924 // automatic assignment operator
33925 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_514_0_33, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 1, 1, 1, 1, 0, "u 'TEvtRecEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
33926 G__tag_memfunc_reset();
33927}
33928
33929static void G__setup_memfuncTEvtRecTrack(void) {
33930 /* TEvtRecTrack */
33931 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
33932 G__memfunc_setup("TEvtRecTrack",1170,G__RootEventData_rootcint_515_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33933 G__memfunc_setup("trackId",706,G__RootEventData_rootcint_515_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33934 G__memfunc_setup("partId",612,G__RootEventData_rootcint_515_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33935 G__memfunc_setup("quality",777,G__RootEventData_rootcint_515_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33936 G__memfunc_setup("mdcTrackId",982,G__RootEventData_rootcint_515_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33937 G__memfunc_setup("mdcKalTrackId",1262,G__RootEventData_rootcint_515_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33938 G__memfunc_setup("mdcDedxId",870,G__RootEventData_rootcint_515_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33939 G__memfunc_setup("extTrackId",1011,G__RootEventData_rootcint_515_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33940 G__memfunc_setup("emcShowerId",1114,G__RootEventData_rootcint_515_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33941 G__memfunc_setup("mucTrackId",999,G__RootEventData_rootcint_515_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33942 G__memfunc_setup("tofTrackIds",1118,G__RootEventData_rootcint_515_0_11, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33943 G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_515_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - trackId", (char*)NULL, (void*) NULL, 0);
33944 G__memfunc_setup("setPartId",912,G__RootEventData_rootcint_515_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - partId", (char*)NULL, (void*) NULL, 0);
33945 G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_515_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - quality", (char*)NULL, (void*) NULL, 0);
33946 G__memfunc_setup("setMdcTrackId",1282,G__RootEventData_rootcint_515_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcTrackId", (char*)NULL, (void*) NULL, 0);
33947 G__memfunc_setup("setMdcKalTrackId",1562,G__RootEventData_rootcint_515_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcKalTrackId", (char*)NULL, (void*) NULL, 0);
33948 G__memfunc_setup("setMdcDedxId",1170,G__RootEventData_rootcint_515_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcDedxId", (char*)NULL, (void*) NULL, 0);
33949 G__memfunc_setup("setExtTrackId",1311,G__RootEventData_rootcint_515_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - extTrackId", (char*)NULL, (void*) NULL, 0);
33950 G__memfunc_setup("setEmcShowerId",1414,G__RootEventData_rootcint_515_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - emcShowerId", (char*)NULL, (void*) NULL, 0);
33951 G__memfunc_setup("setMucTrackId",1299,G__RootEventData_rootcint_515_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mucTrackId", (char*)NULL, (void*) NULL, 0);
33952 G__memfunc_setup("setTofTrackIds",1418,G__RootEventData_rootcint_515_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - tofTrackIds", (char*)NULL, (void*) NULL, 0);
33953 G__memfunc_setup("addTofTrackId",1268,G__RootEventData_rootcint_515_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - tofTrackId", (char*)NULL, (void*) NULL, 0);
33954 G__memfunc_setup("Class",502,G__RootEventData_rootcint_515_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecTrack::Class) ), 0);
33955 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_515_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecTrack::Class_Name) ), 0);
33956 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_515_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecTrack::Class_Version) ), 0);
33957 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_515_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecTrack::Dictionary) ), 0);
33958 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
33959 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
33960 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
33961 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_515_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
33962 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_515_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecTrack::DeclFileName) ), 0);
33963 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_515_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecTrack::ImplFileLine) ), 0);
33964 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_515_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecTrack::ImplFileName) ), 0);
33965 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_515_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecTrack::DeclFileLine) ), 0);
33966 // automatic copy constructor
33967 G__memfunc_setup("TEvtRecTrack", 1170, G__RootEventData_rootcint_515_0_35, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 0, 1, 1, 1, 0, "u 'TEvtRecTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33968 // automatic destructor
33969 G__memfunc_setup("~TEvtRecTrack", 1296, G__RootEventData_rootcint_515_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
33970 // automatic assignment operator
33971 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_515_0_37, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 1, 1, 1, 1, 0, "u 'TEvtRecTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
33972 G__tag_memfunc_reset();
33973}
33974
33975static void G__setup_memfuncTEvtRecPrimaryVertex(void) {
33976 /* TEvtRecPrimaryVertex */
33977 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
33978 G__memfunc_setup("TEvtRecPrimaryVertex",2047,G__RootEventData_rootcint_516_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
33979 G__memfunc_setup("isValid",716,G__RootEventData_rootcint_516_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33980 G__memfunc_setup("nTracks",726,G__RootEventData_rootcint_516_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33981 G__memfunc_setup("trackIdList",1118,G__RootEventData_rootcint_516_0_4, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
33982 G__memfunc_setup("chi2",358,G__RootEventData_rootcint_516_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33983 G__memfunc_setup("ndof",423,G__RootEventData_rootcint_516_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33984 G__memfunc_setup("fitMethod",932,G__RootEventData_rootcint_516_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
33985 G__memfunc_setup("vertex",670,G__RootEventData_rootcint_516_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33986 G__memfunc_setup("errorVertex",1192,G__RootEventData_rootcint_516_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
33987 G__memfunc_setup("setIsValid",1016,G__RootEventData_rootcint_516_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isValid", (char*)NULL, (void*) NULL, 0);
33988 G__memfunc_setup("setNTracks",1026,G__RootEventData_rootcint_516_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nTracks", (char*)NULL, (void*) NULL, 0);
33989 G__memfunc_setup("setTrackIdList",1418,G__RootEventData_rootcint_516_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - trackIdList", (char*)NULL, (void*) NULL, 0);
33990 G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_516_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
33991 G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_516_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndof", (char*)NULL, (void*) NULL, 0);
33992 G__memfunc_setup("setFitMethod",1232,G__RootEventData_rootcint_516_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - fitMethod", (char*)NULL, (void*) NULL, 0);
33993 G__memfunc_setup("setVertex",970,G__RootEventData_rootcint_516_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - vtx", (char*)NULL, (void*) NULL, 0);
33994 G__memfunc_setup("setErrorVertex",1492,G__RootEventData_rootcint_516_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - Evtx", (char*)NULL, (void*) NULL, 0);
33995 G__memfunc_setup("Class",502,G__RootEventData_rootcint_516_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecPrimaryVertex::Class) ), 0);
33996 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_516_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPrimaryVertex::Class_Name) ), 0);
33997 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_516_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecPrimaryVertex::Class_Version) ), 0);
33998 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_516_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecPrimaryVertex::Dictionary) ), 0);
33999 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34000 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34001 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34002 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_516_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34003 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_516_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPrimaryVertex::DeclFileName) ), 0);
34004 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_516_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPrimaryVertex::ImplFileLine) ), 0);
34005 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_516_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPrimaryVertex::ImplFileName) ), 0);
34006 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_516_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPrimaryVertex::DeclFileLine) ), 0);
34007 // automatic copy constructor
34008 G__memfunc_setup("TEvtRecPrimaryVertex", 2047, G__RootEventData_rootcint_516_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 0, 1, 1, 1, 0, "u 'TEvtRecPrimaryVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
34009 // automatic destructor
34010 G__memfunc_setup("~TEvtRecPrimaryVertex", 2173, G__RootEventData_rootcint_516_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34011 // automatic assignment operator
34012 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_516_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 1, 1, 1, 1, 0, "u 'TEvtRecPrimaryVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
34013 G__tag_memfunc_reset();
34014}
34015
34016static void G__setup_memfuncTEvtRecVeeVertex(void) {
34017 /* TEvtRecVeeVertex */
34018 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
34019 G__memfunc_setup("TEvtRecVeeVertex",1595,G__RootEventData_rootcint_517_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34020 G__memfunc_setup("vertexId",843,G__RootEventData_rootcint_517_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34021 G__memfunc_setup("vertexType",1088,G__RootEventData_rootcint_517_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34022 G__memfunc_setup("chi2",358,G__RootEventData_rootcint_517_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34023 G__memfunc_setup("ndof",423,G__RootEventData_rootcint_517_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34024 G__memfunc_setup("mass",436,G__RootEventData_rootcint_517_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34025 G__memfunc_setup("w",119,G__RootEventData_rootcint_517_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34026 G__memfunc_setup("Ew",188,G__RootEventData_rootcint_517_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34027 G__memfunc_setup("pair",428,G__RootEventData_rootcint_517_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34028 G__memfunc_setup("nCharge",696,G__RootEventData_rootcint_517_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34029 G__memfunc_setup("nTracks",726,G__RootEventData_rootcint_517_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34030 G__memfunc_setup("daughter",852,G__RootEventData_rootcint_517_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34031 G__memfunc_setup("setVertexId",1143,G__RootEventData_rootcint_517_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vtxId", (char*)NULL, (void*) NULL, 0);
34032 G__memfunc_setup("setVertexType",1388,G__RootEventData_rootcint_517_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vtxType", (char*)NULL, (void*) NULL, 0);
34033 G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_517_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
34034 G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_517_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndof", (char*)NULL, (void*) NULL, 0);
34035 G__memfunc_setup("setMass",736,G__RootEventData_rootcint_517_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mass", (char*)NULL, (void*) NULL, 0);
34036 G__memfunc_setup("setW",419,G__RootEventData_rootcint_517_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
34037 G__memfunc_setup("setEw",520,G__RootEventData_rootcint_517_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - Ew", (char*)NULL, (void*) NULL, 0);
34038 G__memfunc_setup("setPair",728,G__RootEventData_rootcint_517_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 0 - pair", (char*)NULL, (void*) NULL, 0);
34039 G__memfunc_setup("setNCharge",996,G__RootEventData_rootcint_517_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nCharge", (char*)NULL, (void*) NULL, 0);
34040 G__memfunc_setup("setNTracks",1026,G__RootEventData_rootcint_517_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nTracks", (char*)NULL, (void*) NULL, 0);
34041 G__memfunc_setup("setDaughter",1152,G__RootEventData_rootcint_517_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 0 - daughter", (char*)NULL, (void*) NULL, 0);
34042 G__memfunc_setup("Class",502,G__RootEventData_rootcint_517_0_24, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecVeeVertex::Class) ), 0);
34043 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_517_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecVeeVertex::Class_Name) ), 0);
34044 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_517_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecVeeVertex::Class_Version) ), 0);
34045 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_517_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecVeeVertex::Dictionary) ), 0);
34046 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34047 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34048 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34049 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_517_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34050 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_517_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecVeeVertex::DeclFileName) ), 0);
34051 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_517_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecVeeVertex::ImplFileLine) ), 0);
34052 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_517_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecVeeVertex::ImplFileName) ), 0);
34053 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_517_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecVeeVertex::DeclFileLine) ), 0);
34054 // automatic copy constructor
34055 G__memfunc_setup("TEvtRecVeeVertex", 1595, G__RootEventData_rootcint_517_0_36, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 0, 1, 1, 1, 0, "u 'TEvtRecVeeVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
34056 // automatic destructor
34057 G__memfunc_setup("~TEvtRecVeeVertex", 1721, G__RootEventData_rootcint_517_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34058 // automatic assignment operator
34059 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_517_0_38, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 1, 1, 1, 1, 0, "u 'TEvtRecVeeVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
34060 G__tag_memfunc_reset();
34061}
34062
34063static void G__setup_memfuncTEvtRecPi0(void) {
34064 /* TEvtRecPi0 */
34065 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
34066 G__memfunc_setup("TEvtRecPi0",902,G__RootEventData_rootcint_518_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34067 G__memfunc_setup("unconMass",951,G__RootEventData_rootcint_518_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34068 G__memfunc_setup("chisq",536,G__RootEventData_rootcint_518_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34069 G__memfunc_setup("hiPxfit",732,G__RootEventData_rootcint_518_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34070 G__memfunc_setup("hiPyfit",733,G__RootEventData_rootcint_518_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34071 G__memfunc_setup("hiPzfit",734,G__RootEventData_rootcint_518_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34072 G__memfunc_setup("hiPefit",713,G__RootEventData_rootcint_518_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34073 G__memfunc_setup("loPxfit",742,G__RootEventData_rootcint_518_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34074 G__memfunc_setup("loPyfit",743,G__RootEventData_rootcint_518_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34075 G__memfunc_setup("loPzfit",744,G__RootEventData_rootcint_518_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34076 G__memfunc_setup("loPefit",723,G__RootEventData_rootcint_518_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34077 G__memfunc_setup("hiEnGamma",871,G__RootEventData_rootcint_518_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34078 G__memfunc_setup("loEnGamma",881,G__RootEventData_rootcint_518_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34079 G__memfunc_setup("setUnconMass",1251,G__RootEventData_rootcint_518_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - unconMass", (char*)NULL, (void*) NULL, 0);
34080 G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_518_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chisq", (char*)NULL, (void*) NULL, 0);
34081 G__memfunc_setup("setHiPxfit",1032,G__RootEventData_rootcint_518_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPx", (char*)NULL, (void*) NULL, 0);
34082 G__memfunc_setup("setHiPyfit",1033,G__RootEventData_rootcint_518_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPy", (char*)NULL, (void*) NULL, 0);
34083 G__memfunc_setup("setHiPzfit",1034,G__RootEventData_rootcint_518_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPz", (char*)NULL, (void*) NULL, 0);
34084 G__memfunc_setup("setHiPefit",1013,G__RootEventData_rootcint_518_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPe", (char*)NULL, (void*) NULL, 0);
34085 G__memfunc_setup("setLoPxfit",1042,G__RootEventData_rootcint_518_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPx", (char*)NULL, (void*) NULL, 0);
34086 G__memfunc_setup("setLoPyfit",1043,G__RootEventData_rootcint_518_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPy", (char*)NULL, (void*) NULL, 0);
34087 G__memfunc_setup("setLoPzfit",1044,G__RootEventData_rootcint_518_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPz", (char*)NULL, (void*) NULL, 0);
34088 G__memfunc_setup("setLoPefit",1023,G__RootEventData_rootcint_518_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPe", (char*)NULL, (void*) NULL, 0);
34089 G__memfunc_setup("setHiEnGamma",1171,G__RootEventData_rootcint_518_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - hiEnGamma", (char*)NULL, (void*) NULL, 0);
34090 G__memfunc_setup("setLoEnGamma",1181,G__RootEventData_rootcint_518_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - loEnGamma", (char*)NULL, (void*) NULL, 0);
34091 G__memfunc_setup("Class",502,G__RootEventData_rootcint_518_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecPi0::Class) ), 0);
34092 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_518_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPi0::Class_Name) ), 0);
34093 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_518_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecPi0::Class_Version) ), 0);
34094 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_518_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecPi0::Dictionary) ), 0);
34095 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34096 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34097 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34098 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_518_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34099 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_518_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPi0::DeclFileName) ), 0);
34100 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_518_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPi0::ImplFileLine) ), 0);
34101 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_518_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPi0::ImplFileName) ), 0);
34102 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_518_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPi0::DeclFileLine) ), 0);
34103 // automatic copy constructor
34104 G__memfunc_setup("TEvtRecPi0", 902, G__RootEventData_rootcint_518_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 0, 1, 1, 1, 0, "u 'TEvtRecPi0' - 11 - -", (char*) NULL, (void*) NULL, 0);
34105 // automatic destructor
34106 G__memfunc_setup("~TEvtRecPi0", 1028, G__RootEventData_rootcint_518_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34107 // automatic assignment operator
34108 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_518_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 1, 1, 1, 1, 0, "u 'TEvtRecPi0' - 11 - -", (char*) NULL, (void*) NULL, 0);
34109 G__tag_memfunc_reset();
34110}
34111
34112static void G__setup_memfuncTEvtRecEtaToGG(void) {
34113 /* TEvtRecEtaToGG */
34114 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
34115 G__memfunc_setup("TEvtRecEtaToGG",1288,G__RootEventData_rootcint_519_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34116 G__memfunc_setup("unconMass",951,G__RootEventData_rootcint_519_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34117 G__memfunc_setup("chisq",536,G__RootEventData_rootcint_519_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34118 G__memfunc_setup("hiPxfit",732,G__RootEventData_rootcint_519_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34119 G__memfunc_setup("hiPyfit",733,G__RootEventData_rootcint_519_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34120 G__memfunc_setup("hiPzfit",734,G__RootEventData_rootcint_519_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34121 G__memfunc_setup("hiPefit",713,G__RootEventData_rootcint_519_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34122 G__memfunc_setup("loPxfit",742,G__RootEventData_rootcint_519_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34123 G__memfunc_setup("loPyfit",743,G__RootEventData_rootcint_519_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34124 G__memfunc_setup("loPzfit",744,G__RootEventData_rootcint_519_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34125 G__memfunc_setup("loPefit",723,G__RootEventData_rootcint_519_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34126 G__memfunc_setup("hiEnGamma",871,G__RootEventData_rootcint_519_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34127 G__memfunc_setup("loEnGamma",881,G__RootEventData_rootcint_519_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34128 G__memfunc_setup("setUnconMass",1251,G__RootEventData_rootcint_519_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - unconMass", (char*)NULL, (void*) NULL, 0);
34129 G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_519_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chisq", (char*)NULL, (void*) NULL, 0);
34130 G__memfunc_setup("setHiPxfit",1032,G__RootEventData_rootcint_519_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPx", (char*)NULL, (void*) NULL, 0);
34131 G__memfunc_setup("setHiPyfit",1033,G__RootEventData_rootcint_519_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPy", (char*)NULL, (void*) NULL, 0);
34132 G__memfunc_setup("setHiPzfit",1034,G__RootEventData_rootcint_519_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPz", (char*)NULL, (void*) NULL, 0);
34133 G__memfunc_setup("setHiPefit",1013,G__RootEventData_rootcint_519_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPe", (char*)NULL, (void*) NULL, 0);
34134 G__memfunc_setup("setLoPxfit",1042,G__RootEventData_rootcint_519_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPx", (char*)NULL, (void*) NULL, 0);
34135 G__memfunc_setup("setLoPyfit",1043,G__RootEventData_rootcint_519_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPy", (char*)NULL, (void*) NULL, 0);
34136 G__memfunc_setup("setLoPzfit",1044,G__RootEventData_rootcint_519_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPz", (char*)NULL, (void*) NULL, 0);
34137 G__memfunc_setup("setLoPefit",1023,G__RootEventData_rootcint_519_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPe", (char*)NULL, (void*) NULL, 0);
34138 G__memfunc_setup("setHiEnGamma",1171,G__RootEventData_rootcint_519_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - hiEnGamma", (char*)NULL, (void*) NULL, 0);
34139 G__memfunc_setup("setLoEnGamma",1181,G__RootEventData_rootcint_519_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - loEnGamma", (char*)NULL, (void*) NULL, 0);
34140 G__memfunc_setup("Class",502,G__RootEventData_rootcint_519_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecEtaToGG::Class) ), 0);
34141 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_519_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEtaToGG::Class_Name) ), 0);
34142 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_519_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecEtaToGG::Class_Version) ), 0);
34143 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_519_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecEtaToGG::Dictionary) ), 0);
34144 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34145 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34146 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34147 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_519_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34148 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_519_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEtaToGG::DeclFileName) ), 0);
34149 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_519_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEtaToGG::ImplFileLine) ), 0);
34150 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_519_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEtaToGG::ImplFileName) ), 0);
34151 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_519_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEtaToGG::DeclFileLine) ), 0);
34152 // automatic copy constructor
34153 G__memfunc_setup("TEvtRecEtaToGG", 1288, G__RootEventData_rootcint_519_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 0, 1, 1, 1, 0, "u 'TEvtRecEtaToGG' - 11 - -", (char*) NULL, (void*) NULL, 0);
34154 // automatic destructor
34155 G__memfunc_setup("~TEvtRecEtaToGG", 1414, G__RootEventData_rootcint_519_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34156 // automatic assignment operator
34157 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_519_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 1, 1, 1, 1, 0, "u 'TEvtRecEtaToGG' - 11 - -", (char*) NULL, (void*) NULL, 0);
34158 G__tag_memfunc_reset();
34159}
34160
34161static void G__setup_memfuncTEvtRecDTag(void) {
34162 /* TEvtRecDTag */
34163 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
34164 G__memfunc_setup("TEvtRecDTag",1021,G__RootEventData_rootcint_520_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34165 G__memfunc_setup("decayMode",907,G__RootEventData_rootcint_520_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34166 G__memfunc_setup("type",450,G__RootEventData_rootcint_520_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34167 G__memfunc_setup("beamE",474,G__RootEventData_rootcint_520_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34168 G__memfunc_setup("mass",436,G__RootEventData_rootcint_520_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34169 G__memfunc_setup("mBC",242,G__RootEventData_rootcint_520_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34170 G__memfunc_setup("deltaE",591,G__RootEventData_rootcint_520_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34171 G__memfunc_setup("charge",618,G__RootEventData_rootcint_520_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34172 G__memfunc_setup("charm",523,G__RootEventData_rootcint_520_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34173 G__memfunc_setup("numOfChildren",1326,G__RootEventData_rootcint_520_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34174 G__memfunc_setup("px",232,G__RootEventData_rootcint_520_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34175 G__memfunc_setup("py",233,G__RootEventData_rootcint_520_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34176 G__memfunc_setup("pz",234,G__RootEventData_rootcint_520_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34177 G__memfunc_setup("pe",213,G__RootEventData_rootcint_520_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34178 G__memfunc_setup("tracks",648,G__RootEventData_rootcint_520_0_15, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34179 G__memfunc_setup("showers",779,G__RootEventData_rootcint_520_0_16, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34180 G__memfunc_setup("otherTracks",1162,G__RootEventData_rootcint_520_0_17, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34181 G__memfunc_setup("otherShowers",1293,G__RootEventData_rootcint_520_0_18, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34182 G__memfunc_setup("pionId",611,G__RootEventData_rootcint_520_0_19, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34183 G__memfunc_setup("kaonId",598,G__RootEventData_rootcint_520_0_20, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34184 G__memfunc_setup("setdecayMode",1239,G__RootEventData_rootcint_520_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - decayMode", (char*)NULL, (void*) NULL, 0);
34185 G__memfunc_setup("settype",782,G__RootEventData_rootcint_520_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
34186 G__memfunc_setup("setbeamE",806,G__RootEventData_rootcint_520_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beamE", (char*)NULL, (void*) NULL, 0);
34187 G__memfunc_setup("setmass",768,G__RootEventData_rootcint_520_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mass", (char*)NULL, (void*) NULL, 0);
34188 G__memfunc_setup("setmBC",574,G__RootEventData_rootcint_520_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mBC", (char*)NULL, (void*) NULL, 0);
34189 G__memfunc_setup("setdeltaE",923,G__RootEventData_rootcint_520_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - deltaE", (char*)NULL, (void*) NULL, 0);
34190 G__memfunc_setup("setcharge",950,G__RootEventData_rootcint_520_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
34191 G__memfunc_setup("setcharm",855,G__RootEventData_rootcint_520_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charm", (char*)NULL, (void*) NULL, 0);
34192 G__memfunc_setup("setnumOfChildren",1658,G__RootEventData_rootcint_520_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numOfChildren", (char*)NULL, (void*) NULL, 0);
34193 G__memfunc_setup("setpx",564,G__RootEventData_rootcint_520_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
34194 G__memfunc_setup("setpy",565,G__RootEventData_rootcint_520_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
34195 G__memfunc_setup("setpz",566,G__RootEventData_rootcint_520_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
34196 G__memfunc_setup("setpe",545,G__RootEventData_rootcint_520_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pe", (char*)NULL, (void*) NULL, 0);
34197 G__memfunc_setup("setTracks",948,G__RootEventData_rootcint_520_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - tracks", (char*)NULL, (void*) NULL, 0);
34198 G__memfunc_setup("setShowers",1079,G__RootEventData_rootcint_520_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - showers", (char*)NULL, (void*) NULL, 0);
34199 G__memfunc_setup("setOtherTracks",1462,G__RootEventData_rootcint_520_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - tracks", (char*)NULL, (void*) NULL, 0);
34200 G__memfunc_setup("setOtherShowers",1593,G__RootEventData_rootcint_520_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - showers", (char*)NULL, (void*) NULL, 0);
34201 G__memfunc_setup("setPionId",911,G__RootEventData_rootcint_520_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - pionId", (char*)NULL, (void*) NULL, 0);
34202 G__memfunc_setup("setKaonId",898,G__RootEventData_rootcint_520_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - kaonId", (char*)NULL, (void*) NULL, 0);
34203 G__memfunc_setup("addTrack",798,G__RootEventData_rootcint_520_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 0);
34204 G__memfunc_setup("addShower",929,G__RootEventData_rootcint_520_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - shower", (char*)NULL, (void*) NULL, 0);
34205 G__memfunc_setup("addOtherTrack",1312,G__RootEventData_rootcint_520_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 0);
34206 G__memfunc_setup("addOtherShower",1443,G__RootEventData_rootcint_520_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - shower", (char*)NULL, (void*) NULL, 0);
34207 G__memfunc_setup("addPionId",876,G__RootEventData_rootcint_520_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pionId", (char*)NULL, (void*) NULL, 0);
34208 G__memfunc_setup("addKaonId",863,G__RootEventData_rootcint_520_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kaonId", (char*)NULL, (void*) NULL, 0);
34209 G__memfunc_setup("Class",502,G__RootEventData_rootcint_520_0_46, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecDTag::Class) ), 0);
34210 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_520_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecDTag::Class_Name) ), 0);
34211 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_520_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecDTag::Class_Version) ), 0);
34212 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_520_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecDTag::Dictionary) ), 0);
34213 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34214 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34215 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34216 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_520_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34217 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_520_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecDTag::DeclFileName) ), 0);
34218 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_520_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecDTag::ImplFileLine) ), 0);
34219 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_520_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecDTag::ImplFileName) ), 0);
34220 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_520_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecDTag::DeclFileLine) ), 0);
34221 // automatic copy constructor
34222 G__memfunc_setup("TEvtRecDTag", 1021, G__RootEventData_rootcint_520_0_58, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 0, 1, 1, 1, 0, "u 'TEvtRecDTag' - 11 - -", (char*) NULL, (void*) NULL, 0);
34223 // automatic destructor
34224 G__memfunc_setup("~TEvtRecDTag", 1147, G__RootEventData_rootcint_520_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34225 // automatic assignment operator
34226 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_520_0_60, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 1, 1, 1, 1, 0, "u 'TEvtRecDTag' - 11 - -", (char*) NULL, (void*) NULL, 0);
34227 G__tag_memfunc_reset();
34228}
34229
34230static void G__setup_memfuncTEvtRecObject(void) {
34231 /* TEvtRecObject */
34232 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
34233 G__memfunc_setup("TEvtRecObject",1268,G__RootEventData_rootcint_521_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34234 G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_521_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34235 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
34236 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);
34237 G__memfunc_setup("getEvtRecEvent",1419,G__RootEventData_rootcint_521_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34238 G__memfunc_setup("setEvtRecEvent",1431,G__RootEventData_rootcint_521_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecEvent' - 0 - evtRecEvent", (char*)NULL, (void*) NULL, 0);
34239 G__memfunc_setup("getEvtRecTrackCol",1692,G__RootEventData_rootcint_521_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34240 G__memfunc_setup("addEvtRecTrack",1383,G__RootEventData_rootcint_521_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecTrack' - 0 - track", (char*)NULL, (void*) NULL, 0);
34241 G__memfunc_setup("getEvtRecTrack",1406,G__RootEventData_rootcint_521_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34242 G__memfunc_setup("clearEvtRecTrackCol",1891,G__RootEventData_rootcint_521_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34243 G__memfunc_setup("getEvtRecPrimaryVertex",2283,G__RootEventData_rootcint_521_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34244 G__memfunc_setup("setEvtRecPrimaryVertex",2295,G__RootEventData_rootcint_521_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecPrimaryVertex' - 0 - evtRecPrimaryVertex", (char*)NULL, (void*) NULL, 0);
34245 G__memfunc_setup("getEvtRecVeeVertexCol",2117,G__RootEventData_rootcint_521_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34246 G__memfunc_setup("addEvtRecVeeVertex",1808,G__RootEventData_rootcint_521_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecVeeVertex' - 0 - veeVertex", (char*)NULL, (void*) NULL, 0);
34247 G__memfunc_setup("getEvtRecVeeVertex",1831,G__RootEventData_rootcint_521_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34248 G__memfunc_setup("clearEvtRecVeeVertexCol",2316,G__RootEventData_rootcint_521_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34249 G__memfunc_setup("getEvtRecPi0Col",1424,G__RootEventData_rootcint_521_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34250 G__memfunc_setup("addEvtRecPi0",1115,G__RootEventData_rootcint_521_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecPi0' - 0 - pi0", (char*)NULL, (void*) NULL, 0);
34251 G__memfunc_setup("getEvtRecPi0",1138,G__RootEventData_rootcint_521_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34252 G__memfunc_setup("clearEvtRecPi0Col",1623,G__RootEventData_rootcint_521_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34253 G__memfunc_setup("getEvtRecEtaToGGCol",1810,G__RootEventData_rootcint_521_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34254 G__memfunc_setup("addEvtRecEtaToGG",1501,G__RootEventData_rootcint_521_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecEtaToGG' - 0 - eta", (char*)NULL, (void*) NULL, 0);
34255 G__memfunc_setup("getEvtRecEtaToGG",1524,G__RootEventData_rootcint_521_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34256 G__memfunc_setup("clearEvtRecEtaToGGCol",2009,G__RootEventData_rootcint_521_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34257 G__memfunc_setup("getEvtRecDTagCol",1543,G__RootEventData_rootcint_521_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34258 G__memfunc_setup("addEvtRecDTag",1234,G__RootEventData_rootcint_521_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecDTag' - 0 - dtag", (char*)NULL, (void*) NULL, 0);
34259 G__memfunc_setup("getEvtRecDTag",1257,G__RootEventData_rootcint_521_0_27, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34260 G__memfunc_setup("clearEvtRecDTagCol",1742,G__RootEventData_rootcint_521_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34261 G__memfunc_setup("Class",502,G__RootEventData_rootcint_521_0_29, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecObject::Class) ), 0);
34262 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_521_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecObject::Class_Name) ), 0);
34263 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_521_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecObject::Class_Version) ), 0);
34264 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_521_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecObject::Dictionary) ), 0);
34265 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34266 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34267 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34268 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_521_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34269 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_521_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecObject::DeclFileName) ), 0);
34270 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_521_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecObject::ImplFileLine) ), 0);
34271 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_521_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecObject::ImplFileName) ), 0);
34272 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_521_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecObject::DeclFileLine) ), 0);
34273 // automatic copy constructor
34274 G__memfunc_setup("TEvtRecObject", 1268, G__RootEventData_rootcint_521_0_41, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 0, 1, 1, 1, 0, "u 'TEvtRecObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
34275 // automatic destructor
34276 G__memfunc_setup("~TEvtRecObject", 1394, G__RootEventData_rootcint_521_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34277 // automatic assignment operator
34278 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_521_0_43, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 1, 1, 1, 1, 0, "u 'TEvtRecObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
34279 G__tag_memfunc_reset();
34280}
34281
34282static void G__setup_memfuncTMcHitTof(void) {
34283 /* TMcHitTof */
34284 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
34285 G__memfunc_setup("TMcHitTof",850,G__RootEventData_rootcint_559_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34286 G__memfunc_setup("SetTrackIndex",1305,G__RootEventData_rootcint_559_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
34287 G__memfunc_setup("SetG4Index",927,G__RootEventData_rootcint_559_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
34288 G__memfunc_setup("SetPartId",880,G__RootEventData_rootcint_559_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - partId", (char*)NULL, (void*) NULL, 0);
34289 G__memfunc_setup("SetScinNb",873,G__RootEventData_rootcint_559_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - scinNb", (char*)NULL, (void*) NULL, 0);
34290 G__memfunc_setup("SetEdep",682,G__RootEventData_rootcint_559_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - edep", (char*)NULL, (void*) NULL, 0);
34291 G__memfunc_setup("SetStepL",788,G__RootEventData_rootcint_559_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - stepL", (char*)NULL, (void*) NULL, 0);
34292 G__memfunc_setup("SetTrackL",877,G__RootEventData_rootcint_559_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - length", (char*)NULL, (void*) NULL, 0);
34293 G__memfunc_setup("SetPos",606,G__RootEventData_rootcint_559_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - pos", (char*)NULL, (void*) NULL, 0);
34294 G__memfunc_setup("SetTime",699,G__RootEventData_rootcint_559_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
34295 G__memfunc_setup("SetDeltaT",874,G__RootEventData_rootcint_559_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - deltaT", (char*)NULL, (void*) NULL, 0);
34296 G__memfunc_setup("SetPDirection",1309,G__RootEventData_rootcint_559_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - pDirection", (char*)NULL, (void*) NULL, 0);
34297 G__memfunc_setup("SetMomentum",1150,G__RootEventData_rootcint_559_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - momentum", (char*)NULL, (void*) NULL, 0);
34298 G__memfunc_setup("SetCharge",886,G__RootEventData_rootcint_559_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
34299 G__memfunc_setup("GetTrackIndex",1293,G__RootEventData_rootcint_559_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34300 G__memfunc_setup("GetG4Index",915,G__RootEventData_rootcint_559_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34301 G__memfunc_setup("GetPartId",868,G__RootEventData_rootcint_559_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34302 G__memfunc_setup("GetScinNb",861,G__RootEventData_rootcint_559_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34303 G__memfunc_setup("GetEdep",670,G__RootEventData_rootcint_559_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34304 G__memfunc_setup("GetStepL",776,G__RootEventData_rootcint_559_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34305 G__memfunc_setup("GetTrackL",865,G__RootEventData_rootcint_559_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34306 G__memfunc_setup("GetPos",594,G__RootEventData_rootcint_559_0_22, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34307 G__memfunc_setup("GetTime",687,G__RootEventData_rootcint_559_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34308 G__memfunc_setup("GetDeltaT",862,G__RootEventData_rootcint_559_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34309 G__memfunc_setup("GetPDirection",1297,G__RootEventData_rootcint_559_0_25, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34310 G__memfunc_setup("GetMomentum",1138,G__RootEventData_rootcint_559_0_26, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34311 G__memfunc_setup("GetCharge",874,G__RootEventData_rootcint_559_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34312 G__memfunc_setup("Class",502,G__RootEventData_rootcint_559_0_28, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcHitTof::Class) ), 0);
34313 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_559_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitTof::Class_Name) ), 0);
34314 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_559_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcHitTof::Class_Version) ), 0);
34315 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_559_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcHitTof::Dictionary) ), 0);
34316 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34317 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34318 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34319 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_559_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34320 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_559_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitTof::DeclFileName) ), 0);
34321 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_559_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitTof::ImplFileLine) ), 0);
34322 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_559_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitTof::ImplFileName) ), 0);
34323 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_559_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitTof::DeclFileLine) ), 0);
34324 // automatic copy constructor
34325 G__memfunc_setup("TMcHitTof", 850, G__RootEventData_rootcint_559_0_40, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 0, 1, 1, 1, 0, "u 'TMcHitTof' - 11 - -", (char*) NULL, (void*) NULL, 0);
34326 // automatic destructor
34327 G__memfunc_setup("~TMcHitTof", 976, G__RootEventData_rootcint_559_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34328 // automatic assignment operator
34329 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_559_0_42, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 1, 1, 1, 1, 0, "u 'TMcHitTof' - 11 - -", (char*) NULL, (void*) NULL, 0);
34330 G__tag_memfunc_reset();
34331}
34332
34333static void G__setup_memfuncTMcHitMdc(void) {
34334 /* TMcHitMdc */
34335 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
34336 G__memfunc_setup("TMcHitMdc",829,G__RootEventData_rootcint_560_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34337 G__memfunc_setup("SetTrackID",942,G__RootEventData_rootcint_560_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 0);
34338 G__memfunc_setup("SetLayerNo",998,G__RootEventData_rootcint_560_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
34339 G__memfunc_setup("SetCellNo",873,G__RootEventData_rootcint_560_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - cell", (char*)NULL, (void*) NULL, 0);
34340 G__memfunc_setup("SetEdep",682,G__RootEventData_rootcint_560_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
34341 G__memfunc_setup("SetPos",606,G__RootEventData_rootcint_560_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - xyz", (char*)NULL, (void*) NULL, 0);
34342 G__memfunc_setup("SetDriftD",873,G__RootEventData_rootcint_560_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - distance", (char*)NULL, (void*) NULL, 0);
34343 G__memfunc_setup("SetDriftT",889,G__RootEventData_rootcint_560_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
34344 G__memfunc_setup("SetGlobalT",977,G__RootEventData_rootcint_560_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
34345 G__memfunc_setup("SetTheta",802,G__RootEventData_rootcint_560_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
34346 G__memfunc_setup("SetEnterAngle",1297,G__RootEventData_rootcint_560_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
34347 G__memfunc_setup("SetPosFlag",984,G__RootEventData_rootcint_560_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
34348 G__memfunc_setup("GetTrackID",930,G__RootEventData_rootcint_560_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34349 G__memfunc_setup("GetLayerNo",986,G__RootEventData_rootcint_560_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34350 G__memfunc_setup("GetCellNo",861,G__RootEventData_rootcint_560_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34351 G__memfunc_setup("GetEdep",670,G__RootEventData_rootcint_560_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34352 G__memfunc_setup("GetPos",594,G__RootEventData_rootcint_560_0_17, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34353 G__memfunc_setup("GetDriftD",861,G__RootEventData_rootcint_560_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34354 G__memfunc_setup("GetDriftT",877,G__RootEventData_rootcint_560_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34355 G__memfunc_setup("GetGlobalT",965,G__RootEventData_rootcint_560_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34356 G__memfunc_setup("GetTheta",790,G__RootEventData_rootcint_560_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34357 G__memfunc_setup("GetEnterAngle",1285,G__RootEventData_rootcint_560_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34358 G__memfunc_setup("GetPosFlag",972,G__RootEventData_rootcint_560_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34359 G__memfunc_setup("Class",502,G__RootEventData_rootcint_560_0_24, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcHitMdc::Class) ), 0);
34360 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_560_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitMdc::Class_Name) ), 0);
34361 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_560_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcHitMdc::Class_Version) ), 0);
34362 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_560_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcHitMdc::Dictionary) ), 0);
34363 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34364 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34365 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34366 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_560_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34367 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_560_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitMdc::DeclFileName) ), 0);
34368 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_560_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitMdc::ImplFileLine) ), 0);
34369 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_560_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitMdc::ImplFileName) ), 0);
34370 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_560_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitMdc::DeclFileLine) ), 0);
34371 // automatic copy constructor
34372 G__memfunc_setup("TMcHitMdc", 829, G__RootEventData_rootcint_560_0_36, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 0, 1, 1, 1, 0, "u 'TMcHitMdc' - 11 - -", (char*) NULL, (void*) NULL, 0);
34373 // automatic destructor
34374 G__memfunc_setup("~TMcHitMdc", 955, G__RootEventData_rootcint_560_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34375 // automatic assignment operator
34376 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_560_0_38, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 1, 1, 1, 1, 0, "u 'TMcHitMdc' - 11 - -", (char*) NULL, (void*) NULL, 0);
34377 G__tag_memfunc_reset();
34378}
34379
34380static void G__setup_memfuncTMcDigiEmc(void) {
34381 /* TMcDigiEmc */
34382 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
34383 G__memfunc_setup("TMcDigiEmc",918,G__RootEventData_rootcint_561_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34384 G__memfunc_setup("SetPartId",880,G__RootEventData_rootcint_561_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
34385 G__memfunc_setup("SetThetaNb",978,G__RootEventData_rootcint_561_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nTheta", (char*)NULL, (void*) NULL, 0);
34386 G__memfunc_setup("SetPhiNb",765,G__RootEventData_rootcint_561_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nPhi", (char*)NULL, (void*) NULL, 0);
34387 G__memfunc_setup("SetEnergy",918,G__RootEventData_rootcint_561_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
34388 G__memfunc_setup("SetTime",699,G__RootEventData_rootcint_561_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
34389 G__memfunc_setup("SetTrackIndex",1305,G__RootEventData_rootcint_561_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
34390 G__memfunc_setup("GetPartId",868,G__RootEventData_rootcint_561_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34391 G__memfunc_setup("GetThetaNb",966,G__RootEventData_rootcint_561_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34392 G__memfunc_setup("GetPhiNb",753,G__RootEventData_rootcint_561_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34393 G__memfunc_setup("GetEnergy",906,G__RootEventData_rootcint_561_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34394 G__memfunc_setup("GetTime",687,G__RootEventData_rootcint_561_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34395 G__memfunc_setup("GetTrackIndex",1293,G__RootEventData_rootcint_561_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34396 G__memfunc_setup("Class",502,G__RootEventData_rootcint_561_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcDigiEmc::Class) ), 0);
34397 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_561_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcDigiEmc::Class_Name) ), 0);
34398 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_561_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcDigiEmc::Class_Version) ), 0);
34399 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_561_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcDigiEmc::Dictionary) ), 0);
34400 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34401 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34402 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34403 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_561_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34404 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_561_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcDigiEmc::DeclFileName) ), 0);
34405 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_561_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcDigiEmc::ImplFileLine) ), 0);
34406 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_561_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcDigiEmc::ImplFileName) ), 0);
34407 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_561_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcDigiEmc::DeclFileLine) ), 0);
34408 // automatic copy constructor
34409 G__memfunc_setup("TMcDigiEmc", 918, G__RootEventData_rootcint_561_0_26, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 0, 1, 1, 1, 0, "u 'TMcDigiEmc' - 11 - -", (char*) NULL, (void*) NULL, 0);
34410 // automatic destructor
34411 G__memfunc_setup("~TMcDigiEmc", 1044, G__RootEventData_rootcint_561_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34412 // automatic assignment operator
34413 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_561_0_28, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 1, 1, 1, 1, 0, "u 'TMcDigiEmc' - 11 - -", (char*) NULL, (void*) NULL, 0);
34414 G__tag_memfunc_reset();
34415}
34416
34417static void G__setup_memfuncTMcHitEvent(void) {
34418 /* TMcHitEvent */
34419 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
34420 G__memfunc_setup("TMcHitEvent",1067,G__RootEventData_rootcint_562_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34421 G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
34422 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);
34423 G__memfunc_setup("getMcHitTofCol",1372,G__RootEventData_rootcint_562_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34424 G__memfunc_setup("addMcHitTof",1063,G__RootEventData_rootcint_562_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcHitTof' - 0 - hit", (char*)NULL, (void*) NULL, 0);
34425 G__memfunc_setup("getMcHitTof",1086,G__RootEventData_rootcint_562_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34426 G__memfunc_setup("getMcHitMdcCol",1351,G__RootEventData_rootcint_562_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34427 G__memfunc_setup("addMcHitMdc",1042,G__RootEventData_rootcint_562_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcHitMdc' - 0 - hit", (char*)NULL, (void*) NULL, 0);
34428 G__memfunc_setup("getMcHitMdc",1065,G__RootEventData_rootcint_562_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34429 G__memfunc_setup("getMcDigiEmcCol",1440,G__RootEventData_rootcint_562_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
34430 G__memfunc_setup("addMcDigiEmc",1131,G__RootEventData_rootcint_562_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcDigiEmc' - 0 - digi", (char*)NULL, (void*) NULL, 0);
34431 G__memfunc_setup("getMcDigiEmc",1154,G__RootEventData_rootcint_562_0_12, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
34432 G__memfunc_setup("setBeamTime",1104,G__RootEventData_rootcint_562_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
34433 G__memfunc_setup("getBeamTime",1092,G__RootEventData_rootcint_562_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
34434 G__memfunc_setup("Class",502,G__RootEventData_rootcint_562_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcHitEvent::Class) ), 0);
34435 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_562_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitEvent::Class_Name) ), 0);
34436 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_562_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcHitEvent::Class_Version) ), 0);
34437 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_562_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcHitEvent::Dictionary) ), 0);
34438 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34439 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34440 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34441 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_562_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34442 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_562_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitEvent::DeclFileName) ), 0);
34443 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_562_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitEvent::ImplFileLine) ), 0);
34444 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_562_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitEvent::ImplFileName) ), 0);
34445 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_562_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitEvent::DeclFileLine) ), 0);
34446 // automatic copy constructor
34447 G__memfunc_setup("TMcHitEvent", 1067, G__RootEventData_rootcint_562_0_27, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent), -1, 0, 1, 1, 1, 0, "u 'TMcHitEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
34448 // automatic destructor
34449 G__memfunc_setup("~TMcHitEvent", 1193, G__RootEventData_rootcint_562_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34450 // automatic assignment operator
34451 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_562_0_29, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent), -1, 1, 1, 1, 1, 0, "u 'TMcHitEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
34452 G__tag_memfunc_reset();
34453}
34454
34455static void G__setup_memfuncTBossFullEvent(void) {
34456 /* TBossFullEvent */
34457 G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
34458 G__memfunc_setup("TBossFullEvent",1408,G__RootEventData_rootcint_563_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34459 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);
34460 G__memfunc_setup("copy",443,G__RootEventData_rootcint_563_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBossFullEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34461 G__memfunc_setup("reset",547,G__RootEventData_rootcint_563_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34462 G__memfunc_setup("setEvtHeader",1220,G__RootEventData_rootcint_563_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtHeader' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34463 G__memfunc_setup("setDigiEvent",1227,G__RootEventData_rootcint_563_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDigiEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34464 G__memfunc_setup("setDstEvent",1145,G__RootEventData_rootcint_563_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDstEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34465 G__memfunc_setup("setMcEvent",1022,G__RootEventData_rootcint_563_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34466 G__memfunc_setup("setTrigEvent",1252,G__RootEventData_rootcint_563_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTrigEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34467 G__memfunc_setup("setHltEvent",1142,G__RootEventData_rootcint_563_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THltEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34468 G__memfunc_setup("setRecTrackEvent",1629,G__RootEventData_rootcint_563_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTrackEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34469 G__memfunc_setup("setEvtRecObject",1516,G__RootEventData_rootcint_563_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
34470 G__memfunc_setup("getEvtHeader",1208,G__RootEventData_rootcint_563_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34471 G__memfunc_setup("getDigiEvent",1215,G__RootEventData_rootcint_563_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34472 G__memfunc_setup("getDstEvent",1133,G__RootEventData_rootcint_563_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34473 G__memfunc_setup("getMcEvent",1010,G__RootEventData_rootcint_563_0_16, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34474 G__memfunc_setup("getTrigEvent",1240,G__RootEventData_rootcint_563_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34475 G__memfunc_setup("getHltEvent",1130,G__RootEventData_rootcint_563_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34476 G__memfunc_setup("getRecTrackEvent",1617,G__RootEventData_rootcint_563_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34477 G__memfunc_setup("getEvtRecObject",1504,G__RootEventData_rootcint_563_0_20, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
34478 G__memfunc_setup("Class",502,G__RootEventData_rootcint_563_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBossFullEvent::Class) ), 0);
34479 G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_563_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBossFullEvent::Class_Name) ), 0);
34480 G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_563_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBossFullEvent::Class_Version) ), 0);
34481 G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_563_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBossFullEvent::Dictionary) ), 0);
34482 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
34483 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
34484 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
34485 G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_563_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
34486 G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_563_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBossFullEvent::DeclFileName) ), 0);
34487 G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_563_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBossFullEvent::ImplFileLine) ), 0);
34488 G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_563_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBossFullEvent::ImplFileName) ), 0);
34489 G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_563_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBossFullEvent::DeclFileLine) ), 0);
34490 // automatic copy constructor
34491 G__memfunc_setup("TBossFullEvent", 1408, G__RootEventData_rootcint_563_0_33, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent), -1, 0, 1, 1, 1, 0, "u 'TBossFullEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
34492 // automatic destructor
34493 G__memfunc_setup("~TBossFullEvent", 1534, G__RootEventData_rootcint_563_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
34494 // automatic assignment operator
34495 G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_563_0_35, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent), -1, 1, 1, 1, 1, 0, "u 'TBossFullEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
34496 G__tag_memfunc_reset();
34497}
34498
34499
34500/*********************************************************
34501* Member function information setup
34502*********************************************************/
34503extern "C" void G__cpp_setup_memfuncRootEventData_rootcint() {
34504}
34505
34506/*********************************************************
34507* Global variable information setup for each class
34508*********************************************************/
34509static void G__cpp_setup_global0() {
34510
34511 /* Setting up global variables */
34512 G__resetplocal();
34513
34514}
34515
34516static void G__cpp_setup_global1() {
34517}
34518
34519static void G__cpp_setup_global2() {
34520
34521 G__resetglobalenv();
34522}
34523extern "C" void G__cpp_setup_globalRootEventData_rootcint() {
34524 G__cpp_setup_global0();
34525 G__cpp_setup_global1();
34526 G__cpp_setup_global2();
34527}
34528
34529/*********************************************************
34530* Global function information setup for each class
34531*********************************************************/
34532static void G__cpp_setup_func0() {
34533 G__lastifuncposition();
34534
34535}
34536
34537static void G__cpp_setup_func1() {
34538}
34539
34540static void G__cpp_setup_func2() {
34541}
34542
34543static void G__cpp_setup_func3() {
34544}
34545
34546static void G__cpp_setup_func4() {
34547}
34548
34549static void G__cpp_setup_func5() {
34550}
34551
34552static void G__cpp_setup_func6() {
34553}
34554
34555static void G__cpp_setup_func7() {
34556}
34557
34558static void G__cpp_setup_func8() {
34559}
34560
34561static void G__cpp_setup_func9() {
34562}
34563
34564static void G__cpp_setup_func10() {
34565}
34566
34567static void G__cpp_setup_func11() {
34568}
34569
34570static void G__cpp_setup_func12() {
34571}
34572
34573static void G__cpp_setup_func13() {
34574}
34575
34576static void G__cpp_setup_func14() {
34577}
34578
34579static void G__cpp_setup_func15() {
34580}
34581
34582static void G__cpp_setup_func16() {
34583}
34584
34585static void G__cpp_setup_func17() {
34586}
34587
34588static void G__cpp_setup_func18() {
34589}
34590
34591static void G__cpp_setup_func19() {
34592}
34593
34594static void G__cpp_setup_func20() {
34595}
34596
34597static void G__cpp_setup_func21() {
34598
34599 G__resetifuncposition();
34600}
34601
34602extern "C" void G__cpp_setup_funcRootEventData_rootcint() {
34603 G__cpp_setup_func0();
34604 G__cpp_setup_func1();
34605 G__cpp_setup_func2();
34606 G__cpp_setup_func3();
34607 G__cpp_setup_func4();
34608 G__cpp_setup_func5();
34609 G__cpp_setup_func6();
34610 G__cpp_setup_func7();
34611 G__cpp_setup_func8();
34612 G__cpp_setup_func9();
34613 G__cpp_setup_func10();
34614 G__cpp_setup_func11();
34615 G__cpp_setup_func12();
34616 G__cpp_setup_func13();
34617 G__cpp_setup_func14();
34618 G__cpp_setup_func15();
34619 G__cpp_setup_func16();
34620 G__cpp_setup_func17();
34621 G__cpp_setup_func18();
34622 G__cpp_setup_func19();
34623 G__cpp_setup_func20();
34624 G__cpp_setup_func21();
34625}
34626
34627/*********************************************************
34628* Class,struct,union,enum tag information setup
34629*********************************************************/
34630/* Setup class/struct taginfo */
34631G__linked_taginfo G__RootEventData_rootcintLN_TClass = { "TClass" , 99 , -1 };
34632G__linked_taginfo G__RootEventData_rootcintLN_TBuffer = { "TBuffer" , 99 , -1 };
34633G__linked_taginfo G__RootEventData_rootcintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
34634G__linked_taginfo G__RootEventData_rootcintLN_TObject = { "TObject" , 99 , -1 };
34635G__linked_taginfo G__RootEventData_rootcintLN_TString = { "TString" , 99 , -1 };
34636G__linked_taginfo G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
34637G__linked_taginfo G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
34638G__linked_taginfo G__RootEventData_rootcintLN_string = { "string" , 99 , -1 };
34639G__linked_taginfo G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
34640G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
34641G__linked_taginfo G__RootEventData_rootcintLN_TObjArray = { "TObjArray" , 99 , -1 };
34642G__linked_taginfo G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
34643G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
34644G__linked_taginfo G__RootEventData_rootcintLN_TJobInfo = { "TJobInfo" , 99 , -1 };
34645G__linked_taginfo G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
34646G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
34647G__linked_taginfo G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
34648G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
34649G__linked_taginfo G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
34650G__linked_taginfo G__RootEventData_rootcintLN_TRawData = { "TRawData" , 99 , -1 };
34651G__linked_taginfo G__RootEventData_rootcintLN_TMdcDigi = { "TMdcDigi" , 99 , -1 };
34652G__linked_taginfo G__RootEventData_rootcintLN_TEmcDigi = { "TEmcDigi" , 99 , -1 };
34653G__linked_taginfo G__RootEventData_rootcintLN_TTofDigi = { "TTofDigi" , 99 , -1 };
34654G__linked_taginfo G__RootEventData_rootcintLN_TMucDigi = { "TMucDigi" , 99 , -1 };
34655G__linked_taginfo G__RootEventData_rootcintLN_TLumiDigi = { "TLumiDigi" , 99 , -1 };
34656G__linked_taginfo G__RootEventData_rootcintLN_TDigiEvent = { "TDigiEvent" , 99 , -1 };
34657G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcTrack = { "TRecMdcTrack" , 99 , -1 };
34658G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalTrack = { "TRecMdcKalTrack" , 99 , -1 };
34659G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcHit = { "TRecMdcHit" , 99 , -1 };
34660G__linked_taginfo G__RootEventData_rootcintLN_TTofTrack = { "TTofTrack" , 99 , -1 };
34661G__linked_taginfo G__RootEventData_rootcintLN_TRecTofTrack = { "TRecTofTrack" , 99 , -1 };
34662G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcHit = { "TRecEmcHit" , 99 , -1 };
34663G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcCluster = { "TRecEmcCluster" , 99 , -1 };
34664G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcShower = { "TRecEmcShower" , 99 , -1 };
34665G__linked_taginfo G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
34666G__linked_taginfo G__RootEventData_rootcintLN_TRecMucTrack = { "TRecMucTrack" , 99 , -1 };
34667G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedx = { "TRecMdcDedx" , 99 , -1 };
34668G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedxHit = { "TRecMdcDedxHit" , 99 , -1 };
34669G__linked_taginfo G__RootEventData_rootcintLN_TRecExtTrack = { "TRecExtTrack" , 99 , -1 };
34670G__linked_taginfo G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
34671G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
34672G__linked_taginfo G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
34673G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
34674G__linked_taginfo G__RootEventData_rootcintLN_TRecEvTime = { "TRecEvTime" , 99 , -1 };
34675G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalHelixSeg = { "TRecMdcKalHelixSeg" , 99 , -1 };
34676G__linked_taginfo G__RootEventData_rootcintLN_TRecZddChannel = { "TRecZddChannel" , 99 , -1 };
34677G__linked_taginfo G__RootEventData_rootcintLN_pairlEintcOfloatgR = { "pair<int,float>" , 115 , -1 };
34678G__linked_taginfo G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR = { "vector<pair<int,float>,allocator<pair<int,float> > >" , 99 , -1 };
34679G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,float>,allocator<pair<int,float> > >::iterator>" , 99 , -1 };
34680G__linked_taginfo G__RootEventData_rootcintLN_TRecTrackEvent = { "TRecTrackEvent" , 99 , -1 };
34681G__linked_taginfo G__RootEventData_rootcintLN_TMdcTrack = { "TMdcTrack" , 99 , -1 };
34682G__linked_taginfo G__RootEventData_rootcintLN_TEmcTrack = { "TEmcTrack" , 99 , -1 };
34683G__linked_taginfo G__RootEventData_rootcintLN_TMucTrack = { "TMucTrack" , 99 , -1 };
34684G__linked_taginfo G__RootEventData_rootcintLN_TMdcDedx = { "TMdcDedx" , 99 , -1 };
34685G__linked_taginfo G__RootEventData_rootcintLN_TExtTrack = { "TExtTrack" , 99 , -1 };
34686G__linked_taginfo G__RootEventData_rootcintLN_TMdcKalTrack = { "TMdcKalTrack" , 99 , -1 };
34687G__linked_taginfo G__RootEventData_rootcintLN_TDstEvent = { "TDstEvent" , 99 , -1 };
34688G__linked_taginfo G__RootEventData_rootcintLN_TMdcMc = { "TMdcMc" , 99 , -1 };
34689G__linked_taginfo G__RootEventData_rootcintLN_TEmcMc = { "TEmcMc" , 99 , -1 };
34690G__linked_taginfo G__RootEventData_rootcintLN_TTofMc = { "TTofMc" , 99 , -1 };
34691G__linked_taginfo G__RootEventData_rootcintLN_TMucMc = { "TMucMc" , 99 , -1 };
34692G__linked_taginfo G__RootEventData_rootcintLN_TMcParticle = { "TMcParticle" , 99 , -1 };
34693G__linked_taginfo G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits = { "TMcParticle::StatusBits" , 101 , -1 };
34694G__linked_taginfo G__RootEventData_rootcintLN_TMcEvent = { "TMcEvent" , 99 , -1 };
34695G__linked_taginfo G__RootEventData_rootcintLN_TEvtHeader = { "TEvtHeader" , 99 , -1 };
34696G__linked_taginfo G__RootEventData_rootcintLN_TEvtNavigator = { "TEvtNavigator" , 99 , -1 };
34697G__linked_taginfo G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR = { "multimap<int,int,less<int>,allocator<pair<const int,int> > >" , 99 , -1 };
34698G__linked_taginfo G__RootEventData_rootcintLN_TTrigData = { "TTrigData" , 99 , -1 };
34699G__linked_taginfo G__RootEventData_rootcintLN_TTrigEvent = { "TTrigEvent" , 99 , -1 };
34700G__linked_taginfo G__RootEventData_rootcintLN_THltRaw = { "THltRaw" , 99 , -1 };
34701G__linked_taginfo G__RootEventData_rootcintLN_THltInf = { "THltInf" , 99 , -1 };
34702G__linked_taginfo G__RootEventData_rootcintLN_TDstHltInf = { "TDstHltInf" , 99 , -1 };
34703G__linked_taginfo G__RootEventData_rootcintLN_THltEvent = { "THltEvent" , 99 , -1 };
34704G__linked_taginfo G__RootEventData_rootcintLN_TDisTrack = { "TDisTrack" , 99 , -1 };
34705G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEvent = { "TEvtRecEvent" , 99 , -1 };
34706G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecTrack = { "TEvtRecTrack" , 99 , -1 };
34707G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPrimaryVertex = { "TEvtRecPrimaryVertex" , 99 , -1 };
34708G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecVeeVertex = { "TEvtRecVeeVertex" , 99 , -1 };
34709G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPi0 = { "TEvtRecPi0" , 99 , -1 };
34710G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEtaToGG = { "TEvtRecEtaToGG" , 99 , -1 };
34711G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecDTag = { "TEvtRecDTag" , 99 , -1 };
34712G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecObject = { "TEvtRecObject" , 99 , -1 };
34713G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
34714G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
34715G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
34716G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
34717G__linked_taginfo G__RootEventData_rootcintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
34718G__linked_taginfo G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
34719G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
34720G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
34721G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
34722G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
34723G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
34724G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
34725G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
34726G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
34727G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
34728G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
34729G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
34730G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
34731G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
34732G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
34733G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
34734G__linked_taginfo G__RootEventData_rootcintLN_TVector3 = { "TVector3" , 99 , -1 };
34735G__linked_taginfo G__RootEventData_rootcintLN_TMcHitTof = { "TMcHitTof" , 99 , -1 };
34736G__linked_taginfo G__RootEventData_rootcintLN_TMcHitMdc = { "TMcHitMdc" , 99 , -1 };
34737G__linked_taginfo G__RootEventData_rootcintLN_TMcDigiEmc = { "TMcDigiEmc" , 99 , -1 };
34738G__linked_taginfo G__RootEventData_rootcintLN_TMcHitEvent = { "TMcHitEvent" , 99 , -1 };
34739G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEvent = { "TBossFullEvent" , 99 , -1 };
34740G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEventcLcLdA = { "TBossFullEvent::$" , 101 , -1 };
34741
34742/* Reset class/struct taginfo */
34743extern "C" void G__cpp_reset_tagtableRootEventData_rootcint() {
34744 G__RootEventData_rootcintLN_TClass.tagnum = -1 ;
34745 G__RootEventData_rootcintLN_TBuffer.tagnum = -1 ;
34746 G__RootEventData_rootcintLN_TMemberInspector.tagnum = -1 ;
34747 G__RootEventData_rootcintLN_TObject.tagnum = -1 ;
34748 G__RootEventData_rootcintLN_TString.tagnum = -1 ;
34749 G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
34750 G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
34751 G__RootEventData_rootcintLN_string.tagnum = -1 ;
34752 G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
34753 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
34754 G__RootEventData_rootcintLN_TObjArray.tagnum = -1 ;
34755 G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
34756 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
34757 G__RootEventData_rootcintLN_TJobInfo.tagnum = -1 ;
34758 G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
34759 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
34760 G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
34761 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
34762 G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
34763 G__RootEventData_rootcintLN_TRawData.tagnum = -1 ;
34764 G__RootEventData_rootcintLN_TMdcDigi.tagnum = -1 ;
34765 G__RootEventData_rootcintLN_TEmcDigi.tagnum = -1 ;
34766 G__RootEventData_rootcintLN_TTofDigi.tagnum = -1 ;
34767 G__RootEventData_rootcintLN_TMucDigi.tagnum = -1 ;
34768 G__RootEventData_rootcintLN_TLumiDigi.tagnum = -1 ;
34769 G__RootEventData_rootcintLN_TDigiEvent.tagnum = -1 ;
34770 G__RootEventData_rootcintLN_TRecMdcTrack.tagnum = -1 ;
34771 G__RootEventData_rootcintLN_TRecMdcKalTrack.tagnum = -1 ;
34772 G__RootEventData_rootcintLN_TRecMdcHit.tagnum = -1 ;
34773 G__RootEventData_rootcintLN_TTofTrack.tagnum = -1 ;
34774 G__RootEventData_rootcintLN_TRecTofTrack.tagnum = -1 ;
34775 G__RootEventData_rootcintLN_TRecEmcHit.tagnum = -1 ;
34776 G__RootEventData_rootcintLN_TRecEmcCluster.tagnum = -1 ;
34777 G__RootEventData_rootcintLN_TRecEmcShower.tagnum = -1 ;
34778 G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
34779 G__RootEventData_rootcintLN_TRecMucTrack.tagnum = -1 ;
34780 G__RootEventData_rootcintLN_TRecMdcDedx.tagnum = -1 ;
34781 G__RootEventData_rootcintLN_TRecMdcDedxHit.tagnum = -1 ;
34782 G__RootEventData_rootcintLN_TRecExtTrack.tagnum = -1 ;
34783 G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
34784 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
34785 G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
34786 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
34787 G__RootEventData_rootcintLN_TRecEvTime.tagnum = -1 ;
34788 G__RootEventData_rootcintLN_TRecMdcKalHelixSeg.tagnum = -1 ;
34789 G__RootEventData_rootcintLN_TRecZddChannel.tagnum = -1 ;
34790 G__RootEventData_rootcintLN_pairlEintcOfloatgR.tagnum = -1 ;
34791 G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR.tagnum = -1 ;
34792 G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
34793 G__RootEventData_rootcintLN_TRecTrackEvent.tagnum = -1 ;
34794 G__RootEventData_rootcintLN_TMdcTrack.tagnum = -1 ;
34795 G__RootEventData_rootcintLN_TEmcTrack.tagnum = -1 ;
34796 G__RootEventData_rootcintLN_TMucTrack.tagnum = -1 ;
34797 G__RootEventData_rootcintLN_TMdcDedx.tagnum = -1 ;
34798 G__RootEventData_rootcintLN_TExtTrack.tagnum = -1 ;
34799 G__RootEventData_rootcintLN_TMdcKalTrack.tagnum = -1 ;
34800 G__RootEventData_rootcintLN_TDstEvent.tagnum = -1 ;
34801 G__RootEventData_rootcintLN_TMdcMc.tagnum = -1 ;
34802 G__RootEventData_rootcintLN_TEmcMc.tagnum = -1 ;
34803 G__RootEventData_rootcintLN_TTofMc.tagnum = -1 ;
34804 G__RootEventData_rootcintLN_TMucMc.tagnum = -1 ;
34805 G__RootEventData_rootcintLN_TMcParticle.tagnum = -1 ;
34806 G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits.tagnum = -1 ;
34807 G__RootEventData_rootcintLN_TMcEvent.tagnum = -1 ;
34808 G__RootEventData_rootcintLN_TEvtHeader.tagnum = -1 ;
34809 G__RootEventData_rootcintLN_TEvtNavigator.tagnum = -1 ;
34810 G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR.tagnum = -1 ;
34811 G__RootEventData_rootcintLN_TTrigData.tagnum = -1 ;
34812 G__RootEventData_rootcintLN_TTrigEvent.tagnum = -1 ;
34813 G__RootEventData_rootcintLN_THltRaw.tagnum = -1 ;
34814 G__RootEventData_rootcintLN_THltInf.tagnum = -1 ;
34815 G__RootEventData_rootcintLN_TDstHltInf.tagnum = -1 ;
34816 G__RootEventData_rootcintLN_THltEvent.tagnum = -1 ;
34817 G__RootEventData_rootcintLN_TDisTrack.tagnum = -1 ;
34818 G__RootEventData_rootcintLN_TEvtRecEvent.tagnum = -1 ;
34819 G__RootEventData_rootcintLN_TEvtRecTrack.tagnum = -1 ;
34820 G__RootEventData_rootcintLN_TEvtRecPrimaryVertex.tagnum = -1 ;
34821 G__RootEventData_rootcintLN_TEvtRecVeeVertex.tagnum = -1 ;
34822 G__RootEventData_rootcintLN_TEvtRecPi0.tagnum = -1 ;
34823 G__RootEventData_rootcintLN_TEvtRecEtaToGG.tagnum = -1 ;
34824 G__RootEventData_rootcintLN_TEvtRecDTag.tagnum = -1 ;
34825 G__RootEventData_rootcintLN_TEvtRecObject.tagnum = -1 ;
34826 G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
34827 G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
34828 G__RootEventData_rootcintLN_TVectorTlEfloatgR.tagnum = -1 ;
34829 G__RootEventData_rootcintLN_TVectorTlEdoublegR.tagnum = -1 ;
34830 G__RootEventData_rootcintLN_TElementActionTlEfloatgR.tagnum = -1 ;
34831 G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
34832 G__RootEventData_rootcintLN_TMatrixTlEfloatgR.tagnum = -1 ;
34833 G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
34834 G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
34835 G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
34836 G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
34837 G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
34838 G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
34839 G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
34840 G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
34841 G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
34842 G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
34843 G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
34844 G__RootEventData_rootcintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
34845 G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
34846 G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
34847 G__RootEventData_rootcintLN_TVector3.tagnum = -1 ;
34848 G__RootEventData_rootcintLN_TMcHitTof.tagnum = -1 ;
34849 G__RootEventData_rootcintLN_TMcHitMdc.tagnum = -1 ;
34850 G__RootEventData_rootcintLN_TMcDigiEmc.tagnum = -1 ;
34851 G__RootEventData_rootcintLN_TMcHitEvent.tagnum = -1 ;
34852 G__RootEventData_rootcintLN_TBossFullEvent.tagnum = -1 ;
34853 G__RootEventData_rootcintLN_TBossFullEventcLcLdA.tagnum = -1 ;
34854}
34855
34856
34857extern "C" void G__cpp_setup_tagtableRootEventData_rootcint() {
34858
34859 /* Setting up class,struct,union tag entry */
34860 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TClass);
34861 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBuffer);
34862 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMemberInspector);
34863 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TObject);
34864 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TString);
34865 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
34866 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
34867 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_string);
34868 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
34869 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
34870 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TObjArray);
34871 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
34872 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
34873 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TJobInfo),sizeof(TJobInfo),-1,292096,(char*)NULL,G__setup_memvarTJobInfo,G__setup_memfuncTJobInfo);
34874 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR);
34875 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
34876 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR);
34877 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
34878 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
34879 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRawData),sizeof(TRawData),-1,292096,(char*)NULL,G__setup_memvarTRawData,G__setup_memfuncTRawData);
34880 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcDigi),sizeof(TMdcDigi),-1,292096,(char*)NULL,G__setup_memvarTMdcDigi,G__setup_memfuncTMdcDigi);
34881 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcDigi),sizeof(TEmcDigi),-1,292096,(char*)NULL,G__setup_memvarTEmcDigi,G__setup_memfuncTEmcDigi);
34882 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofDigi),sizeof(TTofDigi),-1,292096,(char*)NULL,G__setup_memvarTTofDigi,G__setup_memfuncTTofDigi);
34883 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucDigi),sizeof(TMucDigi),-1,292096,(char*)NULL,G__setup_memvarTMucDigi,G__setup_memfuncTMucDigi);
34884 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TLumiDigi),sizeof(TLumiDigi),-1,292096,(char*)NULL,G__setup_memvarTLumiDigi,G__setup_memfuncTLumiDigi);
34885 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDigiEvent),sizeof(TDigiEvent),-1,292096,"Storage for Raw(Digi) event and subsystem data",G__setup_memvarTDigiEvent,G__setup_memfuncTDigiEvent);
34886 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcTrack),sizeof(TRecMdcTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMdcTrack,G__setup_memfuncTRecMdcTrack);
34887 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcKalTrack),sizeof(TRecMdcKalTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMdcKalTrack,G__setup_memfuncTRecMdcKalTrack);
34888 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcHit),sizeof(TRecMdcHit),-1,292096,(char*)NULL,G__setup_memvarTRecMdcHit,G__setup_memfuncTRecMdcHit);
34889 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofTrack),sizeof(TTofTrack),-1,292096,(char*)NULL,G__setup_memvarTTofTrack,G__setup_memfuncTTofTrack);
34890 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecTofTrack),sizeof(TRecTofTrack),-1,292096,(char*)NULL,G__setup_memvarTRecTofTrack,G__setup_memfuncTRecTofTrack);
34891 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcHit),sizeof(TRecEmcHit),-1,292096,(char*)NULL,G__setup_memvarTRecEmcHit,G__setup_memfuncTRecEmcHit);
34892 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcCluster),sizeof(TRecEmcCluster),-1,292096,(char*)NULL,G__setup_memvarTRecEmcCluster,G__setup_memfuncTRecEmcCluster);
34893 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcShower),sizeof(TRecEmcShower),-1,292096,(char*)NULL,G__setup_memvarTRecEmcShower,G__setup_memfuncTRecEmcShower);
34894 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
34895 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMucTrack),sizeof(TRecMucTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMucTrack,G__setup_memfuncTRecMucTrack);
34896 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcDedx),sizeof(TRecMdcDedx),-1,292096,(char*)NULL,G__setup_memvarTRecMdcDedx,G__setup_memfuncTRecMdcDedx);
34897 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcDedxHit),sizeof(TRecMdcDedxHit),-1,292096,(char*)NULL,G__setup_memvarTRecMdcDedxHit,G__setup_memfuncTRecMdcDedxHit);
34898 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecExtTrack),sizeof(TRecExtTrack),-1,292096,(char*)NULL,G__setup_memvarTRecExtTrack,G__setup_memfuncTRecExtTrack);
34899 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR);
34900 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
34901 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
34902 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
34903 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEvTime),sizeof(TRecEvTime),-1,292096,(char*)NULL,G__setup_memvarTRecEvTime,G__setup_memfuncTRecEvTime);
34904 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg),sizeof(TRecMdcKalHelixSeg),-1,292096,(char*)NULL,G__setup_memvarTRecMdcKalHelixSeg,G__setup_memfuncTRecMdcKalHelixSeg);
34905 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecZddChannel),sizeof(TRecZddChannel),-1,292096,(char*)NULL,G__setup_memvarTRecZddChannel,G__setup_memfuncTRecZddChannel);
34906 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_pairlEintcOfloatgR);
34907 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR);
34908 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR);
34909 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecTrackEvent),sizeof(TRecTrackEvent),-1,292096,(char*)NULL,G__setup_memvarTRecTrackEvent,G__setup_memfuncTRecTrackEvent);
34910 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcTrack),sizeof(TMdcTrack),-1,292096,(char*)NULL,G__setup_memvarTMdcTrack,G__setup_memfuncTMdcTrack);
34911 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcTrack),sizeof(TEmcTrack),-1,292096,(char*)NULL,G__setup_memvarTEmcTrack,G__setup_memfuncTEmcTrack);
34912 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucTrack),sizeof(TMucTrack),-1,292096,(char*)NULL,G__setup_memvarTMucTrack,G__setup_memfuncTMucTrack);
34913 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcDedx),sizeof(TMdcDedx),-1,292096,(char*)NULL,G__setup_memvarTMdcDedx,G__setup_memfuncTMdcDedx);
34914 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TExtTrack),sizeof(TExtTrack),-1,292096,(char*)NULL,G__setup_memvarTExtTrack,G__setup_memfuncTExtTrack);
34915 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcKalTrack),sizeof(TMdcKalTrack),-1,292096,(char*)NULL,G__setup_memvarTMdcKalTrack,G__setup_memfuncTMdcKalTrack);
34916 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDstEvent),sizeof(TDstEvent),-1,292096,(char*)NULL,G__setup_memvarTDstEvent,G__setup_memfuncTDstEvent);
34917 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcMc),sizeof(TMdcMc),-1,292096,(char*)NULL,G__setup_memvarTMdcMc,G__setup_memfuncTMdcMc);
34918 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcMc),sizeof(TEmcMc),-1,292096,(char*)NULL,G__setup_memvarTEmcMc,G__setup_memfuncTEmcMc);
34919 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofMc),sizeof(TTofMc),-1,292096,(char*)NULL,G__setup_memvarTTofMc,G__setup_memfuncTTofMc);
34920 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucMc),sizeof(TMucMc),-1,292096,(char*)NULL,G__setup_memvarTMucMc,G__setup_memfuncTMucMc);
34921 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcParticle),sizeof(TMcParticle),-1,292096,(char*)NULL,G__setup_memvarTMcParticle,G__setup_memfuncTMcParticle);
34922 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits);
34923 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcEvent),sizeof(TMcEvent),-1,292096,"Storage for McTruth event and subsystem data",G__setup_memvarTMcEvent,G__setup_memfuncTMcEvent);
34924 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtHeader),sizeof(TEvtHeader),-1,292096,(char*)NULL,G__setup_memvarTEvtHeader,G__setup_memfuncTEvtHeader);
34925 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtNavigator),sizeof(TEvtNavigator),-1,292096,(char*)NULL,G__setup_memvarTEvtNavigator,G__setup_memfuncTEvtNavigator);
34926 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR);
34927 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTrigData),sizeof(TTrigData),-1,292096,(char*)NULL,G__setup_memvarTTrigData,G__setup_memfuncTTrigData);
34928 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTrigEvent),sizeof(TTrigEvent),-1,292096,"Storage for trigger event and subsystem data",G__setup_memvarTTrigEvent,G__setup_memfuncTTrigEvent);
34929 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltRaw),sizeof(THltRaw),-1,292096,(char*)NULL,G__setup_memvarTHltRaw,G__setup_memfuncTHltRaw);
34930 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltInf),sizeof(THltInf),-1,292096,(char*)NULL,G__setup_memvarTHltInf,G__setup_memfuncTHltInf);
34931 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDstHltInf),sizeof(TDstHltInf),-1,292096,(char*)NULL,G__setup_memvarTDstHltInf,G__setup_memfuncTDstHltInf);
34932 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltEvent),sizeof(THltEvent),-1,292096,"Storage for event filter and subsystem data",G__setup_memvarTHltEvent,G__setup_memfuncTHltEvent);
34933 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDisTrack),sizeof(TDisTrack),-1,29952,(char*)NULL,G__setup_memvarTDisTrack,G__setup_memfuncTDisTrack);
34934 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecEvent),sizeof(TEvtRecEvent),-1,292096,(char*)NULL,G__setup_memvarTEvtRecEvent,G__setup_memfuncTEvtRecEvent);
34935 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecTrack),sizeof(TEvtRecTrack),-1,292096,(char*)NULL,G__setup_memvarTEvtRecTrack,G__setup_memfuncTEvtRecTrack);
34936 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),sizeof(TEvtRecPrimaryVertex),-1,292096,(char*)NULL,G__setup_memvarTEvtRecPrimaryVertex,G__setup_memfuncTEvtRecPrimaryVertex);
34937 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecVeeVertex),sizeof(TEvtRecVeeVertex),-1,292096,(char*)NULL,G__setup_memvarTEvtRecVeeVertex,G__setup_memfuncTEvtRecVeeVertex);
34938 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecPi0),sizeof(TEvtRecPi0),-1,292096,(char*)NULL,G__setup_memvarTEvtRecPi0,G__setup_memfuncTEvtRecPi0);
34939 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecEtaToGG),sizeof(TEvtRecEtaToGG),-1,292096,(char*)NULL,G__setup_memvarTEvtRecEtaToGG,G__setup_memfuncTEvtRecEtaToGG);
34940 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecDTag),sizeof(TEvtRecDTag),-1,292096,(char*)NULL,G__setup_memvarTEvtRecDTag,G__setup_memfuncTEvtRecDTag);
34941 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecObject),sizeof(TEvtRecObject),-1,292096,(char*)NULL,G__setup_memvarTEvtRecObject,G__setup_memfuncTEvtRecObject);
34942 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR);
34943 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR);
34944 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVectorTlEfloatgR);
34945 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVectorTlEdoublegR);
34946 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TElementActionTlEfloatgR);
34947 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR);
34948 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTlEfloatgR);
34949 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR);
34950 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR);
34951 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR);
34952 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR);
34953 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR);
34954 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR);
34955 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR);
34956 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR);
34957 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR);
34958 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR);
34959 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR);
34960 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSublEfloatgR);
34961 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR);
34962 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR);
34963 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVector3);
34964 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitTof),sizeof(TMcHitTof),-1,292096,(char*)NULL,G__setup_memvarTMcHitTof,G__setup_memfuncTMcHitTof);
34965 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitMdc),sizeof(TMcHitMdc),-1,292096,(char*)NULL,G__setup_memvarTMcHitMdc,G__setup_memfuncTMcHitMdc);
34966 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcDigiEmc),sizeof(TMcDigiEmc),-1,292096,(char*)NULL,G__setup_memvarTMcDigiEmc,G__setup_memfuncTMcDigiEmc);
34967 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitEvent),sizeof(TMcHitEvent),-1,292096,"Storage for Raw(Digi) event and subsystem data",G__setup_memvarTMcHitEvent,G__setup_memfuncTMcHitEvent);
34968 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBossFullEvent),sizeof(TBossFullEvent),-1,95488,(char*)NULL,G__setup_memvarTBossFullEvent,G__setup_memfuncTBossFullEvent);
34969 G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA);
34970}
34971extern "C" void G__cpp_setupRootEventData_rootcint(void) {
34972 G__check_setup_version(30051515,"G__cpp_setupRootEventData_rootcint()");
34973 G__set_cpp_environmentRootEventData_rootcint();
34974 G__cpp_setup_tagtableRootEventData_rootcint();
34975
34976 G__cpp_setup_inheritanceRootEventData_rootcint();
34977
34978 G__cpp_setup_typetableRootEventData_rootcint();
34979
34980 G__cpp_setup_memvarRootEventData_rootcint();
34981
34982 G__cpp_setup_memfuncRootEventData_rootcint();
34983 G__cpp_setup_globalRootEventData_rootcint();
34984 G__cpp_setup_funcRootEventData_rootcint();
34985
34986 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncRootEventData_rootcint();
34987 return;
34988}
34989class G__cpp_setup_initRootEventData_rootcint {
34990 public:
34991 G__cpp_setup_initRootEventData_rootcint() { G__add_setup_func("RootEventData_rootcint",(G__incsetup)(&G__cpp_setupRootEventData_rootcint)); G__call_setup_funcs(); }
34992 ~G__cpp_setup_initRootEventData_rootcint() { G__remove_setup_func("RootEventData_rootcint"); }
34993};
34994G__cpp_setup_initRootEventData_rootcint G__cpp_setup_initializerRootEventData_rootcint;
34995
mass
double mass
Definition: CosmicGenerator.cxx:138
n
const Int_t n
Definition: DataBase/tau_mode.c:65
data
TTree * data
Definition: DataBase/tau_mode.c:5
x
Double_t x[10]
Definition: DataBase/tau_mode.c:57
time
Double_t time
Definition: DataBase/tau_mode.c:7
G__RootEventData_rootcintLN_TEvtRecEvent
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34705
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34646
G__RootEventData_rootcintLN_TMucMc
G__linked_taginfo G__RootEventData_rootcintLN_TMucMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34691
G__RootEventData_rootcintLN_TMucDigi
G__linked_taginfo G__RootEventData_rootcintLN_TMucDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34654
G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34637
G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34714
G__TTEmcTrack
TEmcTrack G__TTEmcTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:18656
G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34670
G__cpp_setup_typetableRootEventData_rootcint
void G__cpp_setup_typetableRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:29577
G__RootEventData_rootcintLN_TRecEmcHit
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcHit
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34662
G__RootEventData_rootcintLN_TRecMdcHit
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcHit
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34659
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34679
G__RootEventData_rootcintLN_TBuffer
G__linked_taginfo G__RootEventData_rootcintLN_TBuffer
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34632
G__RootEventData_rootcintLN_TVectorTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34715
G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34645
G__TTEvtRecPrimaryVertex
TEvtRecPrimaryVertex G__TTEvtRecPrimaryVertex
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:25891
G__TTRecTofTrack
TRecTofTrack G__TTRecTofTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:12330
G__RootEventData_rootcintLN_TMucTrack
G__linked_taginfo G__RootEventData_rootcintLN_TMucTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34683
G__RootEventData_rootcintLN_TMatrixTSublEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSublEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34731
G__RootEventData_rootcintLN_TRecZddChannel
G__linked_taginfo G__RootEventData_rootcintLN_TRecZddChannel
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34676
G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34697
G__cpp_setupRootEventData_rootcint
void G__cpp_setupRootEventData_rootcint(void)
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34971
G__cpp_setup_inheritanceRootEventData_rootcint
void G__cpp_setup_inheritanceRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:29073
G__TTEvtRecPi0
TEvtRecPi0 G__TTEvtRecPi0
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:26478
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34671
G__RootEventData_rootcintLN_TVectorTlEdoublegR
G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEdoublegR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34716
G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34639
G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34726
G__RootEventData_rootcintLN_TRecExtTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecExtTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34669
G__TTRecExtTrack
TRecExtTrack G__TTRecExtTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:16626
G__TTDisTrack
TDisTrack G__TTDisTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:25112
G__RootEventData_rootcintLN_TTrigEvent
G__linked_taginfo G__RootEventData_rootcintLN_TTrigEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34699
G__set_cpp_environmentRootEventData_rootcint
void G__set_cpp_environmentRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:7828
G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34718
G__RootEventData_rootcintLN_TTofMc
G__linked_taginfo G__RootEventData_rootcintLN_TTofMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34690
G__RootEventData_rootcintLN_TMemberInspector
G__linked_taginfo G__RootEventData_rootcintLN_TMemberInspector
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34633
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34643
G__TTDigiEvent
TDigiEvent G__TTDigiEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:9341
G__TTRecEmcCluster
TRecEmcCluster G__TTRecEmcCluster
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:12730
G__TTRecEmcShower
TRecEmcShower G__TTRecEmcShower
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:13279
G__TTEvtRecDTag
TEvtRecDTag G__TTEvtRecDTag
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:27235
G__RootEventData_rootcintLN_TRecEmcShower
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcShower
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34664
G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34723
G__cpp_setup_funcRootEventData_rootcint
void G__cpp_setup_funcRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34602
G__TTEvtRecVeeVertex
TEvtRecVeeVertex G__TTEvtRecVeeVertex
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:26178
G__TTTofDigi
TTofDigi G__TTTofDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:8745
G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34729
G__RootEventData_rootcintLN_TEvtRecTrack
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34706
G__cpp_setup_globalRootEventData_rootcint
void G__cpp_setup_globalRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34523
G__TTMcDigiEmc
TMcDigiEmc G__TTMcDigiEmc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:28392
G__RootEventData_rootcintLN_TMatrixTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34719
G__RootEventData_rootcintLN_TEvtRecPi0
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPi0
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34709
G__RootEventData_rootcintLN_TRecEmcCluster
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcCluster
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34663
G__RootEventData_rootcintLN_TRecMucTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecMucTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34666
G__TTRawData
TRawData G__TTRawData
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:8274
G__TTMucDigi
TMucDigi G__TTMucDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:8889
G__RootEventData_rootcintLN_TRecMdcDedxHit
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedxHit
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34668
G__TTDstHltInf
TDstHltInf G__TTDstHltInf
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:24584
G__RootEventData_rootcintLN_TRecMdcTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34657
G__RootEventData_rootcintLN_TEvtRecVeeVertex
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecVeeVertex
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34708
G__RootEventData_rootcintLN_TDstHltInf
G__linked_taginfo G__RootEventData_rootcintLN_TDstHltInf
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34702
G__cpp_setup_memvarRootEventData_rootcint
void G__cpp_setup_memvarRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:31122
G__TTEvtNavigator
TEvtNavigator G__TTEvtNavigator
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:23464
G__RootEventData_rootcintLN_TRecTrackEvent
G__linked_taginfo G__RootEventData_rootcintLN_TRecTrackEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34680
G__TTEvtHeader
TEvtHeader G__TTEvtHeader
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:23292
G__TTBossFullEvent
TBossFullEvent G__TTBossFullEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:28868
G__TTRecZddChannel
TRecZddChannel G__TTRecZddChannel
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:17348
G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR
G__linked_taginfo G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34649
G__RootEventData_rootcintLN_string
G__linked_taginfo G__RootEventData_rootcintLN_string
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34638
G__TTTofTrack
TTofTrack G__TTTofTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:11685
G__TTRecTrackEvent
TRecTrackEvent G__TTRecTrackEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:17863
G__RootEventData_rootcintLN_THltInf
G__linked_taginfo G__RootEventData_rootcintLN_THltInf
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34701
G__TTHltEvent
THltEvent G__TTHltEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:24801
G__RootEventData_rootcintLN_TRawData
G__linked_taginfo G__RootEventData_rootcintLN_TRawData
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34650
G__get_sizep2memfuncRootEventData_rootcint
size_t G__get_sizep2memfuncRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:29056
G__TTRecMdcDedxHit
TRecMdcDedxHit G__TTRecMdcDedxHit
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:14610
G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34730
G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34732
G__TTTofMc
TTofMc G__TTTofMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:22132
G__RootEventData_rootcintLN_TTrigData
G__linked_taginfo G__RootEventData_rootcintLN_TTrigData
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34698
G__RootEventData_rootcintLN_TExtTrack
G__linked_taginfo G__RootEventData_rootcintLN_TExtTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34685
G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits
G__linked_taginfo G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34693
G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34642
G__RootEventData_rootcintLN_TRecTofTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecTofTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34661
G__TTEmcDigi
TEmcDigi G__TTEmcDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:8588
G__RootEventData_rootcintLN_TMcHitEvent
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34738
G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34678
G__RootEventData_rootcintLN_TMcDigiEmc
G__linked_taginfo G__RootEventData_rootcintLN_TMcDigiEmc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34737
G__RootEventData_rootcintLN_THltEvent
G__linked_taginfo G__RootEventData_rootcintLN_THltEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34703
G__cpp_dllrevRootEventData_rootcint
int G__cpp_dllrevRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:7891
G__RootEventData_rootcintLN_TEmcTrack
G__linked_taginfo G__RootEventData_rootcintLN_TEmcTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34682
G__TTHltInf
THltInf G__TTHltInf
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:24349
G__RootEventData_rootcintLN_pairlEintcOfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_pairlEintcOfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34677
G__RootEventData_rootcintLN_TRecEvTime
G__linked_taginfo G__RootEventData_rootcintLN_TRecEvTime
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34674
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34640
G__TTRecMdcDedx
TRecMdcDedx G__TTRecMdcDedx
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:14362
G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34713
G__TTRecMdcKalTrack
TRecMdcKalTrack G__TTRecMdcKalTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:10662
G__RootEventData_rootcintLN_TObjArray
G__linked_taginfo G__RootEventData_rootcintLN_TObjArray
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34641
G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34721
G__cpp_setup_tagtableRootEventData_rootcint
void G__cpp_setup_tagtableRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34857
G__RootEventData_rootcintLN_TElementActionTlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TElementActionTlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34717
G__TTMucTrack
TMucTrack G__TTMucTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:19203
G__RootEventData_rootcintLN_TBossFullEventcLcLdA
G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEventcLcLdA
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34740
G__RootEventData_rootcintLN_TEmcMc
G__linked_taginfo G__RootEventData_rootcintLN_TEmcMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34689
G__TTExtTrack
TExtTrack G__TTExtTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:20452
G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34665
G__TTMucMc
TMucMc G__TTMucMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:22380
G__RootEventData_rootcintLN_TObject
G__linked_taginfo G__RootEventData_rootcintLN_TObject
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34634
G__RootEventData_rootcintLN_TMdcMc
G__linked_taginfo G__RootEventData_rootcintLN_TMdcMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34688
G__RootEventData_rootcintLN_TTofDigi
G__linked_taginfo G__RootEventData_rootcintLN_TTofDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34653
G__TTRecEmcHit
TRecEmcHit G__TTRecEmcHit
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:12513
G__RootEventData_rootcintLN_TMdcDigi
G__linked_taginfo G__RootEventData_rootcintLN_TMdcDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34651
G__TTTrigEvent
TTrigEvent G__TTTrigEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:23870
G__TTMdcTrack
TMdcTrack G__TTMdcTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:18209
G__TTHltRaw
THltRaw G__TTHltRaw
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:24014
G__TTEvtRecEvent
TEvtRecEvent G__TTEvtRecEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:25354
G__TTEmcMc
TEmcMc G__TTEmcMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:21858
G__cpp_reset_tagtableRootEventData_rootcint
void G__cpp_reset_tagtableRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34743
G__TTMcEvent
TMcEvent G__TTMcEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:23083
G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34728
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34648
G__RootEventData_rootcintLN_TJobInfo
G__linked_taginfo G__RootEventData_rootcintLN_TJobInfo
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34644
G__TTTrigData
TTrigData G__TTTrigData
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:23699
G__RootEventData_rootcintLN_TBossFullEvent
G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34739
G__TTMcHitEvent
TMcHitEvent G__TTMcHitEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:28606
G__TTMdcDigi
TMdcDigi G__TTMdcDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:8431
G__RootEventData_rootcintLN_TEvtRecDTag
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecDTag
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34711
G__cpp_setup_initializerRootEventData_rootcint
G__cpp_setup_initRootEventData_rootcint G__cpp_setup_initializerRootEventData_rootcint
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34994
G__RootEventData_rootcintLN_TMcHitTof
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitTof
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34735
G__RootEventData_rootcintLN_TMdcKalTrack
G__linked_taginfo G__RootEventData_rootcintLN_TMdcKalTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34686
G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34733
G__RootEventData_rootcintLN_TEvtRecPrimaryVertex
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPrimaryVertex
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34707
G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34673
G__RootEventData_rootcintLN_TEvtNavigator
G__linked_taginfo G__RootEventData_rootcintLN_TEvtNavigator
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34696
G__RootEventData_rootcintLN_TRecMdcDedx
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedx
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34667
G__RootEventData_rootcintLN_TTofTrack
G__linked_taginfo G__RootEventData_rootcintLN_TTofTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34660
G__RootEventData_rootcintLN_TDstEvent
G__linked_taginfo G__RootEventData_rootcintLN_TDstEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34687
G__TTEvtRecObject
TEvtRecObject G__TTEvtRecObject
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:27542
G__RootEventData_rootcintLN_TDisTrack
G__linked_taginfo G__RootEventData_rootcintLN_TDisTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34704
G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34724
G__TTMdcKalTrack
TMdcKalTrack G__TTMdcKalTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:20944
G__RootEventData_rootcintLN_TEvtRecObject
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecObject
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34712
G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34636
G__TTMcHitTof
TMcHitTof G__TTMcHitTof
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:27876
G__TTRecMdcTrack
TRecMdcTrack G__TTRecMdcTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:9733
G__RootEventData_rootcintLN_TEvtHeader
G__linked_taginfo G__RootEventData_rootcintLN_TEvtHeader
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34695
G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34720
G__RootEventData_rootcintLN_TLumiDigi
G__linked_taginfo G__RootEventData_rootcintLN_TLumiDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34655
G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34672
G__TTLumiDigi
TLumiDigi G__TTLumiDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:9046
G__RootEventData_rootcintLN_TRecMdcKalHelixSeg
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalHelixSeg
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34675
G__TTRecMdcKalHelixSeg
TRecMdcKalHelixSeg G__TTRecMdcKalHelixSeg
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:17135
G__TTMcParticle
TMcParticle G__TTMcParticle
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:22802
G__TTJobInfo
TJobInfo G__TTJobInfo
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:8079
G__RootEventData_rootcintLN_TMcParticle
G__linked_taginfo G__RootEventData_rootcintLN_TMcParticle
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34692
G__TTRecEvTime
TRecEvTime G__TTRecEvTime
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:16809
G__TTRecMdcHit
TRecMdcHit G__TTRecMdcHit
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:11047
G__RootEventData_rootcintLN_TMcEvent
G__linked_taginfo G__RootEventData_rootcintLN_TMcEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34694
G__RootEventData_rootcintLN_TEvtRecEtaToGG
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEtaToGG
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34710
G__TTMcHitMdc
TMcHitMdc G__TTMcHitMdc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:28170
G__TTDstEvent
TDstEvent G__TTDstEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:21277
G__TTMdcDedx
TMdcDedx G__TTMdcDedx
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:19548
G__TTMdcMc
TMdcMc G__TTMdcMc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:21525
G__RootEventData_rootcintLN_TRecMdcKalTrack
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34658
G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34647
G__RootEventData_rootcintLN_TMcHitMdc
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitMdc
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34736
G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34725
G__RootEventData_rootcintLN_TString
G__linked_taginfo G__RootEventData_rootcintLN_TString
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34635
G__RootEventData_rootcintLN_TVector3
G__linked_taginfo G__RootEventData_rootcintLN_TVector3
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34734
G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34722
G__TTEvtRecEtaToGG
TEvtRecEtaToGG G__TTEvtRecEtaToGG
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:26778
G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34727
G__RootEventData_rootcintLN_TClass
G__linked_taginfo G__RootEventData_rootcintLN_TClass
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34631
G__RootEventData_rootcintLN_TMdcTrack
G__linked_taginfo G__RootEventData_rootcintLN_TMdcTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34681
G__RootEventData_rootcintLN_TDigiEvent
G__linked_taginfo G__RootEventData_rootcintLN_TDigiEvent
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34656
G__RootEventData_rootcintLN_TMdcDedx
G__linked_taginfo G__RootEventData_rootcintLN_TMdcDedx
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34684
G__cpp_setup_memfuncRootEventData_rootcint
void G__cpp_setup_memfuncRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34503
G__RootEventData_rootcintLN_TEmcDigi
G__linked_taginfo G__RootEventData_rootcintLN_TEmcDigi
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34652
G__TTEvtRecTrack
TEvtRecTrack G__TTEvtRecTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:25639
G__TTRecMucTrack
TRecMucTrack G__TTRecMucTrack
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:13893
G__RootEventData_rootcintLN_THltRaw
G__linked_taginfo G__RootEventData_rootcintLN_THltRaw
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34700
w
double w
Definition: EvtPhokharaDef.hh:26
G__cpp_setupRootEventData_rootcint
void G__cpp_setupRootEventData_rootcint(void)
Definition: InstallArea/include/RootEventData/RootEventData/RootEventData_rootcint.cxx:34971
RootEventData_rootcint.h
energy
************Class m_ypar INTEGER m_KeyWgt INTEGER m_KeyIHVP INTEGER m_KeyGPS INTEGER m_IsBeamPolarized INTEGER m_EvtGenInterface DOUBLE PRECISION m_Emin DOUBLE PRECISION m_sphot DOUBLE PRECISION m_Xenph DOUBLE PRECISION m_q2 DOUBLE PRECISION m_PolBeam2 DOUBLE PRECISION m_xErrPb *COMMON c_KK2f $ !CMS energy average $ !Spin Polarization vector first beam $ !Spin Polarization vector second beam $ !Beam energy spread[GeV] $ !minimum hadronization energy[GeV] $ !input READ never touch them !$ !debug facility $ !maximum weight $ !inverse alfaQED $ !minimum real photon energy
Definition: KK2f.h:50
G__Sizep2memfuncRootEventData_rootcint
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:29048
G__Sizep2memfuncRootEventData_rootcint::sizep2memfunc
size_t sizep2memfunc()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:29051
G__Sizep2memfuncRootEventData_rootcint::G__Sizep2memfuncRootEventData_rootcint
G__Sizep2memfuncRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:29050
G__cpp_setup_initRootEventData_rootcint
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34989
G__cpp_setup_initRootEventData_rootcint::~G__cpp_setup_initRootEventData_rootcint
~G__cpp_setup_initRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34992
G__cpp_setup_initRootEventData_rootcint::G__cpp_setup_initRootEventData_rootcint
G__cpp_setup_initRootEventData_rootcint()
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx:34991
TMcParticle::ERROR
@ ERROR
this particle is a leaf in the particle tree
Definition: Event/RootEventData/RootEventData-00-03-80/RootEventData/TMcParticle.h:93
Alignment::getDoca
bool getDoca(double trkpar[], double wpos[], double &doca, double whitPos[], double zini)
Definition: Alignment.cxx:366
ROOT::TRecMdcDedxHit_ShowMembers
void TRecMdcDedxHit_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::multimaplEintcOintgR_ShowMembers
void multimaplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEmcDigi_ShowMembers
void TEmcDigi_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecMdcDedx_ShowMembers
void TRecMdcDedx_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecMdcKalHelixSeg_ShowMembers
void TRecMdcKalHelixSeg_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TDstHltInf_ShowMembers
void TDstHltInf_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMcDigiEmc_ShowMembers
void TMcDigiEmc_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TExtTrack_ShowMembers
void TExtTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecEmcCluster_ShowMembers
void TRecEmcCluster_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vectorlEintgR_ShowMembers
void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecMdcKalTrack_ShowMembers
void TRecMdcKalTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecObject_ShowMembers
void TEvtRecObject_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecEvent_ShowMembers
void TEvtRecEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMcParticle_ShowMembers
void TMcParticle_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMcEvent_ShowMembers
void TMcEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecMdcHit_ShowMembers
void TRecMdcHit_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::THltInf_ShowMembers
void THltInf_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecTofTrack_ShowMembers
void TRecTofTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtNavigator_ShowMembers
void TEvtNavigator_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecEmcShower_ShowMembers
void TRecEmcShower_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vectorlEpairlEintcOfloatgRsPgR_ShowMembers
void vectorlEpairlEintcOfloatgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMucDigi_ShowMembers
void TMucDigi_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEmcTrack_ShowMembers
void TEmcTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecVeeVertex_ShowMembers
void TEvtRecVeeVertex_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecEmcHit_ShowMembers
void TRecEmcHit_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vectorlEfloatgR_ShowMembers
void vectorlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtHeader_ShowMembers
void TEvtHeader_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TTofTrack_ShowMembers
void TTofTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMdcDigi_ShowMembers
void TMdcDigi_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecTrackEvent_ShowMembers
void TRecTrackEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMcHitTof_ShowMembers
void TMcHitTof_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vectorlETStringgR_ShowMembers
void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecMucTrack_ShowMembers
void TRecMucTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TDisTrack_ShowMembers
void TDisTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMdcDedx_ShowMembers
void TMdcDedx_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TTofDigi_ShowMembers
void TTofDigi_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::THltRaw_ShowMembers
void THltRaw_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::THltEvent_ShowMembers
void THltEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TDstEvent_ShowMembers
void TDstEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TJobInfo_ShowMembers
void TJobInfo_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMucMc_ShowMembers
void TMucMc_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEmcMc_ShowMembers
void TEmcMc_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecTrack_ShowMembers
void TEvtRecTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecPi0_ShowMembers
void TEvtRecPi0_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TTrigData_ShowMembers
void TTrigData_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::maplEintcOdoublegR_ShowMembers
void maplEintcOdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMdcTrack_ShowMembers
void TMdcTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TLumiDigi_ShowMembers
void TLumiDigi_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vectorlEstringgR_ShowMembers
void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TBossFullEvent_ShowMembers
void TBossFullEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMcHitMdc_ShowMembers
void TMcHitMdc_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecEtaToGG_ShowMembers
void TEvtRecEtaToGG_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecExtTrack_ShowMembers
void TRecExtTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TTofMc_ShowMembers
void TTofMc_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecDTag_ShowMembers
void TEvtRecDTag_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TDigiEvent_ShowMembers
void TDigiEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMdcMc_ShowMembers
void TMdcMc_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecMdcTrack_ShowMembers
void TRecMdcTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMucTrack_ShowMembers
void TMucTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMdcKalTrack_ShowMembers
void TMdcKalTrack_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecZddChannel_ShowMembers
void TRecZddChannel_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::vectorlEvectorlEdoublegRsPgR_ShowMembers
void vectorlEvectorlEdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TMcHitEvent_ShowMembers
void TMcHitEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::R__UseDummy
R__UseDummy(_R__UNIQUE_(Init))
ROOT::vectorlEdoublegR_ShowMembers
void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TTrigEvent_ShowMembers
void TTrigEvent_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRecEvTime_ShowMembers
void TRecEvTime_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TEvtRecPrimaryVertex_ShowMembers
void TEvtRecPrimaryVertex_ShowMembers(void *obj, TMemberInspector &R__insp)
ROOT::TRawData_ShowMembers
void TRawData_ShowMembers(void *obj, TMemberInspector &R__insp)
eformat::write::copy
uint32_t copy(const node_t &list, uint32_t *dest, size_t max)
Definition: node.cxx:64